Merge "Check if the NTN is connected or not and change the signal threshold criteria." into main

3 files changed, 813 insertions, 6 deletions

diff --git a/src/java/com/android/internal/telephony/SignalStrengthController.java b/src/java/com/android/internal/telephony/SignalStrengthController.java
index 387c501c61..b11d7e564f 100644
--- a/src/java/com/android/internal/telephony/SignalStrengthController.java
+++ b/src/java/com/android/internal/telephony/SignalStrengthController.java
@@ -64,6 +64,7 @@ import java.util.Set;
 import java.util.TreeSet;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.regex.PatternSyntaxException;
 
 /**
@@ -101,6 +102,7 @@ public class SignalStrengthController extends Handler {
     private static final int EVENT_POLL_SIGNAL_STRENGTH                     = 7;
     private static final int EVENT_SIGNAL_STRENGTH_UPDATE                   = 8;
     private static final int EVENT_POLL_SIGNAL_STRENGTH_DONE                = 9;
+    private static final int EVENT_SERVICE_STATE_CHANGED                    = 10;
 
     @NonNull
     private final Phone mPhone;
@@ -146,6 +148,8 @@ public class SignalStrengthController extends Handler {
     @NonNull
     private final LocalLog mLocalLog = new LocalLog(64);
 
+    private final AtomicBoolean mNTNConnected = new AtomicBoolean(false);
+
     public SignalStrengthController(@NonNull Phone phone) {
         mPhone = phone;
         mCi = mPhone.mCi;
@@ -161,6 +165,8 @@ public class SignalStrengthController extends Handler {
         ccm.registerCarrierConfigChangeListener(this::post,
                 (slotIndex, subId, carrierId, specificCarrierId) ->
                         onCarrierConfigurationChanged(slotIndex));
+
+        mPhone.registerForServiceStateChanged(this, EVENT_SERVICE_STATE_CHANGED, null);
     }
 
     @Override
@@ -273,6 +279,11 @@ public class SignalStrengthController extends Handler {
                 break;
             }
 
+            case EVENT_SERVICE_STATE_CHANGED: {
+                onServiceStateChanged((ServiceState) ((AsyncResult) msg.obj).result);
+                break;
+            }
+
             default:
                 log("Unhandled message with number: " + msg.what);
                 break;
@@ -406,10 +417,13 @@ public class SignalStrengthController extends Handler {
                             true));
         }
 
-        int lteMeasurementEnabled = mCarrierConfig.getInt(CarrierConfigManager
-                .KEY_PARAMETERS_USED_FOR_LTE_SIGNAL_BAR_INT, CellSignalStrengthLte.USE_RSRP);
-        int[] lteRsrpThresholds = mCarrierConfig.getIntArray(
-                CarrierConfigManager.KEY_LTE_RSRP_THRESHOLDS_INT_ARRAY);
+        int lteMeasurementEnabled = mCarrierConfig.getInt(isUsingNonTerrestrialNetwork()
+                        ? CarrierConfigManager.KEY_PARAMETERS_USED_FOR_NTN_LTE_SIGNAL_BAR_INT
+                        : CarrierConfigManager.KEY_PARAMETERS_USED_FOR_LTE_SIGNAL_BAR_INT,
+                CellSignalStrengthLte.USE_RSRP);
+        int[] lteRsrpThresholds = mCarrierConfig.getIntArray(isUsingNonTerrestrialNetwork()
+                ? CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY
+                : CarrierConfigManager.KEY_LTE_RSRP_THRESHOLDS_INT_ARRAY);
         if (lteRsrpThresholds != null) {
             signalThresholdInfos.add(
                     validateAndCreateSignalThresholdInfo(
@@ -421,7 +435,8 @@ public class SignalStrengthController extends Handler {
         }
 
         if (mPhone.getHalVersion(HAL_SERVICE_NETWORK).greaterOrEqual(RIL.RADIO_HAL_VERSION_1_5)) {
-            int[] lteRsrqThresholds = mCarrierConfig.getIntArray(
+            int[] lteRsrqThresholds = mCarrierConfig.getIntArray(isUsingNonTerrestrialNetwork()
+                    ? CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY :
                     CarrierConfigManager.KEY_LTE_RSRQ_THRESHOLDS_INT_ARRAY);
             if (lteRsrqThresholds != null) {
                 signalThresholdInfos.add(
@@ -433,7 +448,8 @@ public class SignalStrengthController extends Handler {
                                 (lteMeasurementEnabled & CellSignalStrengthLte.USE_RSRQ) != 0));
             }
 
-            int[] lteRssnrThresholds = mCarrierConfig.getIntArray(
+            int[] lteRssnrThresholds = mCarrierConfig.getIntArray(isUsingNonTerrestrialNetwork()
+                    ? CarrierConfigManager.KEY_NTN_LTE_RSSNR_THRESHOLDS_INT_ARRAY :
                     CarrierConfigManager.KEY_LTE_RSSNR_THRESHOLDS_INT_ARRAY);
             if (lteRssnrThresholds != null) {
                 signalThresholdInfos.add(
@@ -1322,6 +1338,25 @@ public class SignalStrengthController extends Handler {
         };
     }
 
+    private void onServiceStateChanged(ServiceState state) {
+        if (state.getState() != ServiceState.STATE_IN_SERVICE) {
+            return;
+        }
+
+        if (mNTNConnected.get() != state.isUsingNonTerrestrialNetwork()) {
+            log("onServiceStateChanged: update it to " + state.isUsingNonTerrestrialNetwork());
+            updateReportingCriteria();
+            mNTNConnected.set(state.isUsingNonTerrestrialNetwork());
+        }
+    }
+
+    private boolean isUsingNonTerrestrialNetwork() {
+        if (mPhone.getServiceState() == null) {
+            return false;
+        }
+        return mPhone.getServiceState().isUsingNonTerrestrialNetwork();
+    }
+
     private static void log(String msg) {
         if (DBG) Rlog.d(TAG, msg);
     }
diff --git a/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java
index 98980a1bf0..fa890825f7 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthControllerTest.java
@@ -16,6 +16,9 @@
 
 package com.android.internal.telephony;
 
+import static android.telephony.ServiceState.STATE_IN_SERVICE;
+import static android.telephony.ServiceState.STATE_OUT_OF_SERVICE;
+import static android.telephony.ServiceState.STATE_POWER_OFF;
 import static android.telephony.SignalThresholdInfo.SIGNAL_MEASUREMENT_TYPE_RSRP;
 import static android.telephony.SignalThresholdInfo.SIGNAL_MEASUREMENT_TYPE_RSSI;
 import static android.telephony.SignalThresholdInfo.SIGNAL_MEASUREMENT_TYPE_SSRSRP;
@@ -27,14 +30,19 @@ import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyList;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
+import android.os.AsyncResult;
 import android.os.Handler;
 import android.os.Message;
 import android.os.PersistableBundle;
@@ -1269,6 +1277,238 @@ public class SignalStrengthControllerTest extends TelephonyTest {
         sendCarrierConfigUpdate();
     }
 
+    @Test
+    public void testInvalidCarrierConfig_NTN_LTE_RSRP_thresholdIsTooSmall() {
+        // 4 threshold integers must be within the boundaries [-140, -44]
+        mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+                new int[]{
+                        -141, /* SIGNAL_STRENGTH_POOR */
+                        -118, /* SIGNAL_STRENGTH_MODERATE */
+                        -108, /* SIGNAL_STRENGTH_GOOD */
+                        -98  /* SIGNAL_STRENGTH_GREAT */
+                });
+        sendCarrierConfigUpdate();
+    }
+
+
+    @Test
+    public void testInvalidCarrierConfig_NTN_LTE_RSRP_thresholdIsTooLarge() {
+        // 4 threshold integers must be within the boundaries [-140, -44]
+        mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+                new int[]{
+                        -128, /* SIGNAL_STRENGTH_POOR */
+                        -118, /* SIGNAL_STRENGTH_MODERATE */
+                        -108, /* SIGNAL_STRENGTH_GOOD */
+                        -43,  /* SIGNAL_STRENGTH_GREAT */
+                });
+        sendCarrierConfigUpdate();
+    }
+
+    @Test
+    public void testInvalidCarrierConfig_NTN_LTE_RSRQ_thresholdIsTooSmall() {
+        // 4 threshold integers must be within the boundaries [-34, 3]
+        mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+                new int[]{
+                        -35, /* SIGNAL_STRENGTH_POOR */
+                        -17, /* SIGNAL_STRENGTH_MODERATE */
+                        -14, /* SIGNAL_STRENGTH_GOOD */
+                        -11  /* SIGNAL_STRENGTH_GREAT */
+                });
+        sendCarrierConfigUpdate();
+    }
+
+
+    @Test
+    public void testInvalidCarrierConfig_NTN_LTE_RSRQ_thresholdIsTooLarge() {
+        // 4 threshold integers must be within the boundaries [-34, 3]
+        mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+                new int[]{
+                        -20, /* SIGNAL_STRENGTH_POOR */
+                        -17, /* SIGNAL_STRENGTH_MODERATE */
+                        -14, /* SIGNAL_STRENGTH_GOOD */
+                        4  /* SIGNAL_STRENGTH_GREAT */
+                });
+        sendCarrierConfigUpdate();
+    }
+
+    @Test
+    public void testInvalidCarrierConfig_NTN_LTE_RSSNR_thresholdIsTooSmall() {
+        // 4 threshold integers must be within the boundaries [-20, 30]
+        mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSSNR_THRESHOLDS_INT_ARRAY,
+                new int[]{
+                        -21, /* SIGNAL_STRENGTH_POOR */
+                        1,  /* SIGNAL_STRENGTH_MODERATE */
+                        5,  /* SIGNAL_STRENGTH_GOOD */
+                        13  /* SIGNAL_STRENGTH_GREAT */
+                });
+        sendCarrierConfigUpdate();
+    }
+
+    @Test
+    public void testInvalidCarrierConfig_NTN_LTE_RSSNR_thresholdIsTooLarge() {
+        // 4 threshold integers must be within the boundaries [-20, 30]
+        mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSSNR_THRESHOLDS_INT_ARRAY,
+                new int[]{
+                        -3, /* SIGNAL_STRENGTH_POOR */
+                        1,  /* SIGNAL_STRENGTH_MODERATE */
+                        5,  /* SIGNAL_STRENGTH_GOOD */
+                        31  /* SIGNAL_STRENGTH_GREAT */
+                });
+        sendCarrierConfigUpdate();
+    }
+
+    @Test
+    public void testLteSignalStrengthReportingCriteriaWhenServiceStateChanged() {
+        SignalStrength ss = new SignalStrength(
+                new CellSignalStrengthCdma(),
+                new CellSignalStrengthGsm(),
+                new CellSignalStrengthWcdma(),
+                new CellSignalStrengthTdscdma(),
+                new CellSignalStrengthLte(
+                        -110, /* rssi */
+                        -114, /* rsrp */
+                        -5, /* rsrq */
+                        0, /* rssnr */
+                        SignalStrength.INVALID, /* cqi */
+                        SignalStrength.INVALID /* ta */),
+                new CellSignalStrengthNr());
+
+        // RSRP NTN_LTE threshold set to Good and LTE threshold set to poor.
+        mBundle.putInt(CarrierConfigManager.KEY_PARAMETERS_USED_FOR_NTN_LTE_SIGNAL_BAR_INT,
+                CellSignalStrengthLte.USE_RSRP);
+        mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+                new int[]{-125 /* SIGNAL_STRENGTH_POOR */, -120 /* SIGNAL_STRENGTH_MODERATE */,
+                        -115 /* SIGNAL_STRENGTH_GOOD */, -110/* SIGNAL_STRENGTH_GREAT */});
+        mBundle.putIntArray(CarrierConfigManager.KEY_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+                new int[]{-114, /* SIGNAL_STRENGTH_POOR */ -110, /* SIGNAL_STRENGTH_MODERATE */
+                        -105, /* SIGNAL_STRENGTH_GOOD */ -100, /* SIGNAL_STRENGTH_GREAT */});
+        CarrierConfigManager mockConfigManager = Mockito.mock(CarrierConfigManager.class);
+        when(mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE))
+                .thenReturn(mockConfigManager);
+        when(mockConfigManager.getConfigForSubId(anyInt())).thenReturn(mBundle);
+
+        // When NTN is connected, check the signal strength is GOOD
+        AsyncResult asyncResult = mock(AsyncResult.class);
+        asyncResult.result = mServiceState;
+        doReturn(true).when(mServiceState).isUsingNonTerrestrialNetwork();
+        mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+        processAllMessages();
+
+        mSimulatedCommands.setSignalStrength(ss);
+        mSimulatedCommands.notifySignalStrength();
+        processAllMessages();
+        assertEquals(CellSignalStrength.SIGNAL_STRENGTH_GOOD, mSsc.getSignalStrength().getLevel());
+
+        // When TN connected, check the signal strength is POOR
+        doReturn(false).when(mServiceState).isUsingNonTerrestrialNetwork();
+        mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+        processAllMessages();
+
+        mSimulatedCommands.setSignalStrength(ss);
+        mSimulatedCommands.notifySignalStrength();
+        processAllMessages();
+        assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR, mSsc.getSignalStrength().getLevel());
+
+        // RSRP NTN_LTE threshold set to Moderate and LTE threshold set to poor.
+        // When TN connected, check the signal strength is POOR.
+        mBundle.putIntArray(CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+                new int[]{-130 /* SIGNAL_STRENGTH_POOR */, -120 /* SIGNAL_STRENGTH_MODERATE */,
+                        -110 /* SIGNAL_STRENGTH_GOOD */, -100/* SIGNAL_STRENGTH_GREAT */});
+        mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+        processAllMessages();
+
+        mSimulatedCommands.setSignalStrength(ss);
+        mSimulatedCommands.notifySignalStrength();
+        processAllMessages();
+        assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR, mSsc.getSignalStrength().getLevel());
+
+        // Service State Changed with OUT_OF_SERVICE, then no update
+        // SignalStrengthReportingCriteria.
+        reset(mSimulatedCommandsVerifier);
+        doReturn(STATE_OUT_OF_SERVICE).when(mServiceState).getState();
+        mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+        processAllMessages();
+
+        mSimulatedCommands.setSignalStrength(ss);
+        mSimulatedCommands.notifySignalStrength();
+        processAllMessages();
+        assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR, mSsc.getSignalStrength().getLevel());
+        verify(mSimulatedCommandsVerifier, never()).setSignalStrengthReportingCriteria(anyList(),
+                isNull());
+
+        // Service State Changed with POWER_OFF, then no update SignalStrengthReportingCriteria.
+        reset(mSimulatedCommandsVerifier);
+        doReturn(STATE_POWER_OFF).when(mServiceState).getState();
+        mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+        processAllMessages();
+
+        mSimulatedCommands.setSignalStrength(ss);
+        mSimulatedCommands.notifySignalStrength();
+        processAllMessages();
+        assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR, mSsc.getSignalStrength().getLevel());
+        verify(mSimulatedCommandsVerifier, never()).setSignalStrengthReportingCriteria(anyList(),
+                isNull());
+
+        // Service State Changed with IN_SERVICE, then update SignalStrengthReportingCriteria.
+        // When NTN is connected, check the signal strength is MODERATE
+        reset(mSimulatedCommandsVerifier);
+        doReturn(true).when(mServiceState).isUsingNonTerrestrialNetwork();
+        doReturn(STATE_IN_SERVICE).when(mServiceState).getState();
+        mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+        processAllMessages();
+
+        mSimulatedCommands.setSignalStrength(ss);
+        mSimulatedCommands.notifySignalStrength();
+        processAllMessages();
+        assertEquals(CellSignalStrength.SIGNAL_STRENGTH_MODERATE,
+                mSsc.getSignalStrength().getLevel());
+        verify(mSimulatedCommandsVerifier).setSignalStrengthReportingCriteria(anyList(), isNull());
+
+        // Service State Changed with IN_SERVICE and still NTN is connected,
+        // verify not update SignalStrengthReportingCriteria and the signal strength is MODERATE.
+        reset(mSimulatedCommandsVerifier);
+        mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+        processAllMessages();
+
+        mSimulatedCommands.setSignalStrength(ss);
+        mSimulatedCommands.notifySignalStrength();
+        processAllMessages();
+        assertEquals(CellSignalStrength.SIGNAL_STRENGTH_MODERATE,
+                mSsc.getSignalStrength().getLevel());
+        verify(mSimulatedCommandsVerifier, never()).setSignalStrengthReportingCriteria(anyList(),
+                isNull());
+
+        // Service State Changed with IN_SERVICE, then update SignalStrengthReportingCriteria.
+        // When TN is connected, check the signal strength is POOR.
+        reset(mSimulatedCommandsVerifier);
+        doReturn(false).when(mServiceState).isUsingNonTerrestrialNetwork();
+        mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+        processAllMessages();
+
+        mSimulatedCommands.setSignalStrength(ss);
+        mSimulatedCommands.notifySignalStrength();
+        processAllMessages();
+        assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR,
+                mSsc.getSignalStrength().getLevel());
+        verify(mSimulatedCommandsVerifier).setSignalStrengthReportingCriteria(anyList(), isNull());
+
+        // Service State Changed with IN_SERVICE and still TN is connected,
+        // verify not update SignalStrengthReportingCriteria and the signal strength is POOR.
+        reset(mSimulatedCommandsVerifier);
+        mSsc.handleMessage(mSsc.obtainMessage(10/*EVENT_SERVICE_STATE_CHANGED*/, asyncResult));
+        processAllMessages();
+
+        mSimulatedCommands.setSignalStrength(ss);
+        mSimulatedCommands.notifySignalStrength();
+        processAllMessages();
+        assertEquals(CellSignalStrength.SIGNAL_STRENGTH_POOR,
+                mSsc.getSignalStrength().getLevel());
+        verify(mSimulatedCommandsVerifier, never()).setSignalStrengthReportingCriteria(anyList(),
+                isNull());
+
+        reset(mSimulatedCommandsVerifier);
+    }
+
     private void verifyAllEmptyThresholdAreDisabledWhenSetSignalStrengthReportingCriteria(
             int expectedNonEmptyThreshold) {
         ArgumentCaptor<List<SignalThresholdInfo>> signalThresholdInfoCaptor =
diff --git a/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthTest.java b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthTest.java
index 96184c5ec7..8df40527dc 100644
--- a/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthTest.java
+++ b/tests/telephonytests/src/com/android/internal/telephony/SignalStrengthTest.java
@@ -21,6 +21,7 @@ import static org.junit.Assert.assertTrue;
 
 import android.os.Parcel;
 import android.os.PersistableBundle;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.telephony.CarrierConfigManager;
 import android.telephony.CellInfo;
 import android.telephony.CellSignalStrength;
@@ -30,10 +31,16 @@ import android.telephony.CellSignalStrengthLte;
 import android.telephony.CellSignalStrengthNr;
 import android.telephony.CellSignalStrengthTdscdma;
 import android.telephony.CellSignalStrengthWcdma;
+import android.telephony.NetworkRegistrationInfo;
+import android.telephony.ServiceState;
 import android.telephony.SignalStrength;
 
 import androidx.test.filters.SmallTest;
 
+import com.android.internal.telephony.flags.Flags;
+
+import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -46,6 +53,7 @@ import java.util.List;
 @SmallTest
 @RunWith(JUnit4.class)
 public class SignalStrengthTest {
+    @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
     private static final int[] DEFAULT_LTE_RSRP_THRESHOLDS = {
             -128,  // SIGNAL_STRENGTH_POOR
             -118,  // SIGNAL_STRENGTH_MODERATE
@@ -70,6 +78,42 @@ public class SignalStrengthTest {
             -105,  // SIGNAL_STRENGTH_GOOD
             -95 }; // SIGNAL_STRENGTH_GREAT
 
+    private static final int[] DEFAULT_NTN_LTE_RSRP_THRESHOLDS = {
+            -118,  // SIGNAL_STRENGTH_POOR
+            -108,  // SIGNAL_STRENGTH_MODERATE
+            -98,  // SIGNAL_STRENGTH_GOOD
+            -88 }; // SIGNAL_STRENGTH_GREAT
+
+    private static final int[] DEFAULT_NTN_LTE_RSRQ_THRESHOLDS = {
+            -17,   // SIGNAL_STRENGTH_POOR
+            -14,   // SIGNAL_STRENGTH_MODERATE
+            -12,   // SIGNAL_STRENGTH_GOOD
+            -10 }; // SIGNAL_STRENGTH_GREAT
+
+    private static final int[] DEFAULT_NTN_LTE_RSSNR_THRESHOLDS = {
+            1,   // SIGNAL_STRENGTH_POOR
+            5,    // SIGNAL_STRENGTH_MODERATE
+            13,    // SIGNAL_STRENGTH_GOOD
+            17 }; // SIGNAL_STRENGTH_GREAT
+
+    // RSRP, RSSNR thresholds boundaries
+    private static final int MIN_RSRP = -140;
+    private static final int MIN_RSRQ = -34;
+    private static final int MAX_RSRQ = 3;
+    private static final int MIN_RSSNR = -20;
+    private static final int MAX_RSSNR = 30;
+
+    // Default NTN & TN LTE thresholds's index
+    private static final int INDEX_SIGNAL_STRENGTH_POOR = 0;
+    private static final int INDEX_SIGNAL_STRENGTH_MODERATE = 1;
+    private static final int INDEX_SIGNAL_STRENGTH_GOOD = 2;
+    private static final int INDEX_SIGNAL_STRENGTH_GREAT = 3;
+
+    @Before
+    public void setUp() {
+        mSetFlagsRule.enableFlags(Flags.FLAG_CARRIER_ENABLED_SATELLITE_FLAG);
+    }
+
     @Test
     public void testDefaults() throws Exception {
         SignalStrength s = new SignalStrength();
@@ -229,6 +273,58 @@ public class SignalStrengthTest {
         return signalStrength;
     }
 
+    private static SignalStrength createSignalStrengthLteReport(int lteRsrp, int lteRsrq,
+            int lteRssnr, boolean isNTN) {
+        CellSignalStrengthLte lte = new CellSignalStrengthLte(
+                -89,               // rssi
+                lteRsrp,               // rsrp
+                lteRsrq,               // rsrq
+                lteRssnr,              // rssnr
+                CellInfo.UNAVAILABLE,  // cqiTableIndex
+                CellInfo.UNAVAILABLE,  // cqi
+                CellInfo.UNAVAILABLE); // timingAdvance
+
+        SignalStrength signalStrength = new SignalStrength(
+                new CellSignalStrengthCdma(),
+                new CellSignalStrengthGsm(),
+                new CellSignalStrengthWcdma(),
+                new CellSignalStrengthTdscdma(),
+                lte,
+                new CellSignalStrengthNr());
+
+        PersistableBundle bundle = new PersistableBundle();
+        bundle.putInt(
+                CarrierConfigManager.KEY_PARAMETERS_USED_FOR_LTE_SIGNAL_BAR_INT,
+                CellSignalStrengthLte.USE_RSRP | CellSignalStrengthLte.USE_RSRQ
+                        | CellSignalStrengthLte.USE_RSSNR);
+        bundle.putIntArray(CarrierConfigManager.KEY_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+                DEFAULT_LTE_RSRP_THRESHOLDS);
+        bundle.putIntArray(CarrierConfigManager.KEY_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+                DEFAULT_LTE_RSRQ_THRESHOLDS);
+        bundle.putIntArray(CarrierConfigManager.KEY_LTE_RSSNR_THRESHOLDS_INT_ARRAY,
+                DEFAULT_LTE_RSSNR_THRESHOLDS);
+        bundle.putInt(
+                CarrierConfigManager.KEY_PARAMETERS_USED_FOR_NTN_LTE_SIGNAL_BAR_INT,
+                CellSignalStrengthLte.USE_RSRP | CellSignalStrengthLte.USE_RSRQ
+                        | CellSignalStrengthLte.USE_RSSNR);
+        bundle.putIntArray(
+                CarrierConfigManager.KEY_NTN_LTE_RSRP_THRESHOLDS_INT_ARRAY,
+                DEFAULT_NTN_LTE_RSRP_THRESHOLDS);
+        bundle.putIntArray(
+                CarrierConfigManager.KEY_NTN_LTE_RSRQ_THRESHOLDS_INT_ARRAY,
+                DEFAULT_NTN_LTE_RSRQ_THRESHOLDS);
+        bundle.putIntArray(
+                CarrierConfigManager.KEY_NTN_LTE_RSSNR_THRESHOLDS_INT_ARRAY,
+                DEFAULT_NTN_LTE_RSSNR_THRESHOLDS);
+        ServiceState serviceState = new ServiceState();
+        NetworkRegistrationInfo nri = new NetworkRegistrationInfo.Builder()
+                .setIsNonTerrestrialNetwork(isNTN)
+                .build();
+        serviceState.addNetworkRegistrationInfo(nri);
+        signalStrength.updateLevel(bundle, serviceState);
+        return signalStrength;
+    }
+
     @Test
     public void testValidateInput() throws Exception {
 
@@ -265,6 +361,44 @@ public class SignalStrengthTest {
         // Input value of RSSNR: -21[dB]
         ss = createSignalStrengthLteReportRssnr(60, -21);
         assertEquals(SignalStrength.INVALID, ss.getLteRssnr());
+
+        // Test for NTN LTE RSRQ Thresholds based on Boundaries [-34 dB, 3 dB]
+        boolean isNTN = true;
+        int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rsrq = MAX_RSRQ + 1;
+        ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+        assertEquals(SignalStrength.INVALID, ss.getLteRsrq());
+
+        rsrq = MAX_RSRQ;
+        ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+        assertEquals(3, ss.getLteRsrq());
+
+        rsrq = MIN_RSRQ - 1;
+        ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+        assertEquals(SignalStrength.INVALID, ss.getLteRsrq());
+
+        rsrq = MIN_RSRQ;
+        ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+        assertEquals(-34, ss.getLteRsrq());
+
+        // Test for NTN LTE RSSNR Thresholds based on Boundaries [-20 dBm, 30 dBm]
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT]; // or 3 ?
+        rssnr = MAX_RSSNR + 1;
+        ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+        assertEquals(SignalStrength.INVALID, ss.getLteRssnr());
+
+        rssnr = MAX_RSSNR;
+        ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+        assertEquals(30, ss.getLteRssnr());
+
+        rssnr = MIN_RSSNR - 1;
+        ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+        assertEquals(SignalStrength.INVALID, ss.getLteRssnr());
+
+        rssnr = MIN_RSSNR;
+        ss = createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN);
+        assertEquals(-20, ss.getLteRssnr());
     }
 
     @Test
@@ -279,6 +413,46 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRsrq(-98, -14).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
                 createSignalStrengthLteReportRsrq(-98, -12).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 
     @Test
@@ -293,6 +467,46 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRsrq(-108, -14).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
                 createSignalStrengthLteReportRsrq(-108, -12).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 
     @Test
@@ -307,6 +521,46 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRsrq(-118, -14).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
                 createSignalStrengthLteReportRsrq(-118, -12).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 
     @Test
@@ -321,6 +575,46 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRsrq(-128, -14).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
                 createSignalStrengthLteReportRsrq(-128, -12).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 
     @Test
@@ -335,6 +629,45 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRsrq(-138, -14).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
                 createSignalStrengthLteReportRsrq(-138, -12).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = MIN_RSRP;
+        int rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rsrq = MIN_RSRQ;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 
     @Test
@@ -349,6 +682,46 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRssnr(-98, 5).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
                 createSignalStrengthLteReportRssnr(-98, 13).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GREAT,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 
     @Test
@@ -363,6 +736,46 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRssnr(-108, 5).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
                 createSignalStrengthLteReportRssnr(-108, 13).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_GOOD,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 
     @Test
@@ -377,6 +790,46 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRssnr(-118, 5).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
                 createSignalStrengthLteReportRssnr(-118, 13).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_MODERATE,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 
     @Test
@@ -391,6 +844,46 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRssnr(-128, 5).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
                 createSignalStrengthLteReportRssnr(-128, 13).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = DEFAULT_NTN_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rsrp = DEFAULT_LTE_RSRP_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_POOR,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 
     @Test
@@ -405,6 +898,45 @@ public class SignalStrengthTest {
                 createSignalStrengthLteReportRssnr(-138, 5).getLteLevel());
         assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
                 createSignalStrengthLteReportRssnr(-138, 13).getLteLevel());
+
+        // When NTN is connected, check the signal strength
+        boolean isNTN = true;
+        int rsrp = MIN_RSRP;
+        int rsrq = DEFAULT_NTN_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        int rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_NTN_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+
+        // When NTN is disconnected, check the signal strength
+        isNTN = false;
+        rsrq = DEFAULT_LTE_RSRQ_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        rssnr = MIN_RSSNR;
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_POOR];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_MODERATE];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GOOD];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
+        rssnr = DEFAULT_LTE_RSSNR_THRESHOLDS[INDEX_SIGNAL_STRENGTH_GREAT];
+        assertEquals(SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN,
+                createSignalStrengthLteReport(rsrp, rsrq, rssnr, isNTN).getLteLevel());
     }
 }