Merge "Add additional tests to HeadsetClientStateMachineTest" (f6d79936) · Commits · e / os / android_packages_modules_Bluetooth

android/app/src/com/android/bluetooth/hfpclient/HeadsetClientStateMachine.java

+38 −19

Original line number	Original line	Diff line number	Diff line
	@@ -110,10 +110,14 @@ public class HeadsetClientStateMachine extends StateMachine {
	public static final int SEND_BIEV = 22;		public static final int SEND_BIEV = 22;

	// internal actions		// internal actions
	private static final int QUERY_CURRENT_CALLS = 50;		@VisibleForTesting
	private static final int QUERY_OPERATOR_NAME = 51;		static final int QUERY_CURRENT_CALLS = 50;
	private static final int SUBSCRIBER_INFO = 52;		@VisibleForTesting
	private static final int CONNECTING_TIMEOUT = 53;		static final int QUERY_OPERATOR_NAME = 51;
			@VisibleForTesting
			static final int SUBSCRIBER_INFO = 52;
			@VisibleForTesting
			static final int CONNECTING_TIMEOUT = 53;

	// special action to handle terminating specific call from multiparty call		// special action to handle terminating specific call from multiparty call
	static final int TERMINATE_SPECIFIC_CALL = 53;		static final int TERMINATE_SPECIFIC_CALL = 53;
	@@ -144,7 +148,8 @@ public class HeadsetClientStateMachine extends StateMachine {

	// Set of calls that represent the accurate state of calls that exists on AG and the calls that		// Set of calls that represent the accurate state of calls that exists on AG and the calls that
	// are currently in process of being notified to the AG from HF.		// are currently in process of being notified to the AG from HF.
	private final Hashtable<Integer, HfpClientCall> mCalls = new Hashtable<>();		@VisibleForTesting
			final Hashtable<Integer, HfpClientCall> mCalls = new Hashtable<>();
	// Set of calls received from AG via the AT+CLCC command. We use this map to update the mCalls		// Set of calls received from AG via the AT+CLCC command. We use this map to update the mCalls
	// which is eventually used to inform the telephony stack of any changes to call on HF.		// which is eventually used to inform the telephony stack of any changes to call on HF.
	private final Hashtable<Integer, HfpClientCall> mCallsUpdate = new Hashtable<>();		private final Hashtable<Integer, HfpClientCall> mCallsUpdate = new Hashtable<>();
	@@ -156,19 +161,22 @@ public class HeadsetClientStateMachine extends StateMachine {
	private boolean mInBandRing;		private boolean mInBandRing;

	private String mOperatorName;		private String mOperatorName;
	private String mSubscriberInfo;		@VisibleForTesting
			String mSubscriberInfo;

	private static int sMaxAmVcVol;		private static int sMaxAmVcVol;
	private static int sMinAmVcVol;		private static int sMinAmVcVol;

	// queue of send actions (pair action, action_data)		// queue of send actions (pair action, action_data)
	private Queue<Pair<Integer, Object>> mQueuedActions;		@VisibleForTesting
			Queue<Pair<Integer, Object>> mQueuedActions;

	// last executed command, before action is complete e.g. waiting for some		// last executed command, before action is complete e.g. waiting for some
	// indicator		// indicator
	private Pair<Integer, Object> mPendingAction;		private Pair<Integer, Object> mPendingAction;

	private int mAudioState;		@VisibleForTesting
			int mAudioState;
	// Indicates whether audio can be routed to the device		// Indicates whether audio can be routed to the device
	private boolean mAudioRouteAllowed;		private boolean mAudioRouteAllowed;
	private boolean mAudioWbs;		private boolean mAudioWbs;
	@@ -176,11 +184,14 @@ public class HeadsetClientStateMachine extends StateMachine {
	private final BluetoothAdapter mAdapter;		private final BluetoothAdapter mAdapter;

	// currently connected device		// currently connected device
	private BluetoothDevice mCurrentDevice = null;		@VisibleForTesting
			BluetoothDevice mCurrentDevice = null;

	// general peer features and call handling features		// general peer features and call handling features
	private int mPeerFeatures;		@VisibleForTesting
	private int mChldFeatures;		int mPeerFeatures;
			@VisibleForTesting
			int mChldFeatures;

	// This is returned when requesting focus from AudioManager		// This is returned when requesting focus from AudioManager
	private AudioFocusRequest mAudioFocusRequest;		private AudioFocusRequest mAudioFocusRequest;
	@@ -257,7 +268,8 @@ public class HeadsetClientStateMachine extends StateMachine {
	return builder.toString();		return builder.toString();
	}		}

	private static String getMessageName(int what) {		@VisibleForTesting
			static String getMessageName(int what) {
	switch (what) {		switch (what) {
	case StackEvent.STACK_EVENT:		case StackEvent.STACK_EVENT:
	return "STACK_EVENT";		return "STACK_EVENT";
	@@ -328,7 +340,8 @@ public class HeadsetClientStateMachine extends StateMachine {
	mQueuedActions.add(new Pair<Integer, Object>(action, data));		mQueuedActions.add(new Pair<Integer, Object>(action, data));
	}		}

	private HfpClientCall getCall(int... states) {		@VisibleForTesting
			HfpClientCall getCall(int... states) {
	logD("getFromCallsWithStates states:" + Arrays.toString(states));		logD("getFromCallsWithStates states:" + Arrays.toString(states));
	for (HfpClientCall c : mCalls.values()) {		for (HfpClientCall c : mCalls.values()) {
	for (int s : states) {		for (int s : states) {
	@@ -340,7 +353,8 @@ public class HeadsetClientStateMachine extends StateMachine {
	return null;		return null;
	}		}

	private int callsInState(int state) {		@VisibleForTesting
			int callsInState(int state) {
	int i = 0;		int i = 0;
	for (HfpClientCall c : mCalls.values()) {		for (HfpClientCall c : mCalls.values()) {
	if (c.getState() == state) {		if (c.getState() == state) {
	@@ -708,7 +722,8 @@ public class HeadsetClientStateMachine extends StateMachine {
	}		}
	}		}

	private void enterPrivateMode(int idx) {		@VisibleForTesting
			void enterPrivateMode(int idx) {
	logD("enterPrivateMode: " + idx);		logD("enterPrivateMode: " + idx);

	HfpClientCall c = mCalls.get(idx);		HfpClientCall c = mCalls.get(idx);
	@@ -726,7 +741,8 @@ public class HeadsetClientStateMachine extends StateMachine {
	}		}
	}		}

	private void explicitCallTransfer() {		@VisibleForTesting
			void explicitCallTransfer() {
	logD("explicitCallTransfer");		logD("explicitCallTransfer");

	// can't transfer call if there is not enough call parties		// can't transfer call if there is not enough call parties
	@@ -1879,7 +1895,8 @@ public class HeadsetClientStateMachine extends StateMachine {
	return BluetoothProfile.STATE_DISCONNECTED;		return BluetoothProfile.STATE_DISCONNECTED;
	}		}

	private void broadcastAudioState(BluetoothDevice device, int newState, int prevState) {		@VisibleForTesting
			void broadcastAudioState(BluetoothDevice device, int newState, int prevState) {
	BluetoothStatsLog.write(BluetoothStatsLog.BLUETOOTH_SCO_CONNECTION_STATE_CHANGED,		BluetoothStatsLog.write(BluetoothStatsLog.BLUETOOTH_SCO_CONNECTION_STATE_CHANGED,
	AdapterService.getAdapterService().obfuscateAddress(device),		AdapterService.getAdapterService().obfuscateAddress(device),
	getConnectionStateFromAudioState(newState), mAudioWbs		getConnectionStateFromAudioState(newState), mAudioWbs
	@@ -2028,7 +2045,8 @@ public class HeadsetClientStateMachine extends StateMachine {
	return devices;		return devices;
	}		}

	private byte[] getByteAddress(BluetoothDevice device) {		@VisibleForTesting
			byte[] getByteAddress(BluetoothDevice device) {
	return Utils.getBytesFromAddress(device.getAddress());		return Utils.getBytesFromAddress(device.getAddress());
	}		}

	@@ -2047,7 +2065,8 @@ public class HeadsetClientStateMachine extends StateMachine {
	return b;		return b;
	}		}

	private static int getConnectionStateFromAudioState(int audioState) {		@VisibleForTesting
			static int getConnectionStateFromAudioState(int audioState) {
	switch (audioState) {		switch (audioState) {
	case BluetoothHeadsetClient.STATE_AUDIO_CONNECTED:		case BluetoothHeadsetClient.STATE_AUDIO_CONNECTED:
	return BluetoothAdapter.STATE_CONNECTED;		return BluetoothAdapter.STATE_CONNECTED;

android/app/tests/unit/src/com/android/bluetooth/hfpclient/HeadsetClientStateMachineTest.java

+285 −0

Original line number	Original line	Diff line number	Diff line
	package com.android.bluetooth.hfpclient;		package com.android.bluetooth.hfpclient;

	import static com.android.bluetooth.hfpclient.HeadsetClientStateMachine.AT_OK;		import static com.android.bluetooth.hfpclient.HeadsetClientStateMachine.AT_OK;
			import static com.android.bluetooth.hfpclient.HeadsetClientStateMachine.ENTER_PRIVATE_MODE;
			import static com.android.bluetooth.hfpclient.HeadsetClientStateMachine.EXPLICIT_CALL_TRANSFER;
	import static com.android.bluetooth.hfpclient.HeadsetClientStateMachine.VOICE_RECOGNITION_START;		import static com.android.bluetooth.hfpclient.HeadsetClientStateMachine.VOICE_RECOGNITION_START;
	import static com.android.bluetooth.hfpclient.HeadsetClientStateMachine.VOICE_RECOGNITION_STOP;		import static com.android.bluetooth.hfpclient.HeadsetClientStateMachine.VOICE_RECOGNITION_STOP;

	@@ -19,6 +21,7 @@ import android.media.AudioManager;
	import android.os.Bundle;		import android.os.Bundle;
	import android.os.HandlerThread;		import android.os.HandlerThread;
	import android.os.Message;		import android.os.Message;
			import android.util.Pair;

	import androidx.test.InstrumentationRegistry;		import androidx.test.InstrumentationRegistry;
	import androidx.test.espresso.intent.matcher.IntentMatchers;		import androidx.test.espresso.intent.matcher.IntentMatchers;
	@@ -46,6 +49,9 @@ import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;		import org.mockito.MockitoAnnotations;
	import org.mockito.hamcrest.MockitoHamcrest;		import org.mockito.hamcrest.MockitoHamcrest;

			import java.util.List;
			import java.util.Set;

	@LargeTest		@LargeTest
	@RunWith(AndroidJUnit4.class)		@RunWith(AndroidJUnit4.class)
	public class HeadsetClientStateMachineTest {		public class HeadsetClientStateMachineTest {
	@@ -706,4 +712,283 @@ public class HeadsetClientStateMachineTest {
	verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(1))		verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(1))
	.updateBatteryLevel();		.updateBatteryLevel();
	}		}

			@Test
			public void testBroadcastAudioState() {
			mHeadsetClientStateMachine.broadcastAudioState(mTestDevice,
			BluetoothHeadsetClient.STATE_AUDIO_CONNECTED,
			BluetoothHeadsetClient.STATE_AUDIO_CONNECTING);

			verify(mHeadsetClientService).sendBroadcast(any(), any(), any());
			}

			@Test
			public void testCallsInState() {
			HfpClientCall call = new HfpClientCall(mTestDevice, 0, HfpClientCall.CALL_STATE_WAITING,
			"1", false, false, false);
			mHeadsetClientStateMachine.mCalls.put(0, call);

			Assert.assertEquals(
			mHeadsetClientStateMachine.callsInState(HfpClientCall.CALL_STATE_WAITING), 1);
			}

			@Test
			public void testEnterPrivateMode() {
			HfpClientCall call = new HfpClientCall(mTestDevice, 0, HfpClientCall.CALL_STATE_ACTIVE,
			"1", true, false, false);
			mHeadsetClientStateMachine.mCalls.put(0, call);
			doReturn(true).when(mNativeInterface).handleCallAction(null,
			HeadsetClientHalConstants.CALL_ACTION_CHLD_2X, 0);

			mHeadsetClientStateMachine.enterPrivateMode(0);

			Pair expectedPair = new Pair<Integer, Object>(ENTER_PRIVATE_MODE, call);
			Assert.assertEquals(mHeadsetClientStateMachine.mQueuedActions.peek(), expectedPair);
			}

			@Test
			public void testExplicitCallTransfer() {
			HfpClientCall callOne = new HfpClientCall(mTestDevice, 0, HfpClientCall.CALL_STATE_ACTIVE,
			"1", true, false, false);
			HfpClientCall callTwo = new HfpClientCall(mTestDevice, 0, HfpClientCall.CALL_STATE_ACTIVE,
			"1", true, false, false);
			mHeadsetClientStateMachine.mCalls.put(0, callOne);
			mHeadsetClientStateMachine.mCalls.put(1, callTwo);
			doReturn(true).when(mNativeInterface).handleCallAction(null,
			HeadsetClientHalConstants.CALL_ACTION_CHLD_4, -1);

			mHeadsetClientStateMachine.explicitCallTransfer();

			Pair expectedPair = new Pair<Integer, Object>(EXPLICIT_CALL_TRANSFER, 0);
			Assert.assertEquals(mHeadsetClientStateMachine.mQueuedActions.peek(), expectedPair);
			}

			@Test
			public void testSetAudioRouteAllowed() {
			mHeadsetClientStateMachine.setAudioRouteAllowed(true);

			Assert.assertTrue(mHeadsetClientStateMachine.getAudioRouteAllowed());
			}

			@Test
			public void testGetAudioState_withCurrentDeviceNull() {
			Assert.assertNull(mHeadsetClientStateMachine.mCurrentDevice);

			Assert.assertEquals(mHeadsetClientStateMachine.getAudioState(mTestDevice),
			BluetoothHeadsetClient.STATE_AUDIO_DISCONNECTED);
			}

			@Test
			public void testGetAudioState_withCurrentDeviceNotNull() {
			int audioState = 1;
			mHeadsetClientStateMachine.mAudioState = audioState;
			mHeadsetClientStateMachine.mCurrentDevice = mTestDevice;

			Assert.assertEquals(mHeadsetClientStateMachine.getAudioState(mTestDevice), audioState);
			}

			@Test
			public void testGetCall_withMatchingState() {
			HfpClientCall call = new HfpClientCall(mTestDevice, 0, HfpClientCall.CALL_STATE_ACTIVE,
			"1", true, false, false);
			mHeadsetClientStateMachine.mCalls.put(0, call);
			int[] states = new int[1];
			states[0] = HfpClientCall.CALL_STATE_ACTIVE;

			Assert.assertEquals(mHeadsetClientStateMachine.getCall(states), call);
			}

			@Test
			public void testGetCall_withNoMatchingState() {
			HfpClientCall call = new HfpClientCall(mTestDevice, 0, HfpClientCall.CALL_STATE_WAITING,
			"1", true, false, false);
			mHeadsetClientStateMachine.mCalls.put(0, call);
			int[] states = new int[1];
			states[0] = HfpClientCall.CALL_STATE_ACTIVE;

			Assert.assertNull(mHeadsetClientStateMachine.getCall(states));
			}

			@Test
			public void testGetConnectionState_withNullDevice() {
			Assert.assertEquals(mHeadsetClientStateMachine.getConnectionState(null),
			BluetoothProfile.STATE_DISCONNECTED);
			}

			@Test
			public void testGetConnectionState_withNonNullDevice() {
			mHeadsetClientStateMachine.mCurrentDevice = mTestDevice;

			Assert.assertEquals(mHeadsetClientStateMachine.getConnectionState(mTestDevice),
			BluetoothProfile.STATE_DISCONNECTED);
			}

			@Test
			public void testGetConnectionStateFromAudioState() {
			Assert.assertEquals(HeadsetClientStateMachine.getConnectionStateFromAudioState(
			BluetoothHeadsetClient.STATE_AUDIO_CONNECTED), BluetoothAdapter.STATE_CONNECTED);
			Assert.assertEquals(HeadsetClientStateMachine.getConnectionStateFromAudioState(
			BluetoothHeadsetClient.STATE_AUDIO_CONNECTING), BluetoothAdapter.STATE_CONNECTING);
			Assert.assertEquals(HeadsetClientStateMachine.getConnectionStateFromAudioState(
			BluetoothHeadsetClient.STATE_AUDIO_DISCONNECTED),
			BluetoothAdapter.STATE_DISCONNECTED);
			int invalidAudioState = 3;
			Assert.assertEquals(
			HeadsetClientStateMachine.getConnectionStateFromAudioState(invalidAudioState),
			BluetoothAdapter.STATE_DISCONNECTED);
			}

			@Test
			public void testGetCurrentAgEvents() {
			Bundle bundle = mHeadsetClientStateMachine.getCurrentAgEvents();

			Assert.assertEquals(bundle.getString(BluetoothHeadsetClient.EXTRA_SUBSCRIBER_INFO),
			mHeadsetClientStateMachine.mSubscriberInfo);
			}

			@Test
			public void testGetCurrentAgFeatures() {
			mHeadsetClientStateMachine.mPeerFeatures = HeadsetClientHalConstants.PEER_FEAT_3WAY;
			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_HOLD_ACC;
			Set<Integer> features = mHeadsetClientStateMachine.getCurrentAgFeatures();
			Assert.assertTrue(features.contains(HeadsetClientHalConstants.PEER_FEAT_3WAY));
			Assert.assertTrue(features.contains(HeadsetClientHalConstants.CHLD_FEAT_HOLD_ACC));

			mHeadsetClientStateMachine.mPeerFeatures = HeadsetClientHalConstants.PEER_FEAT_VREC;
			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_REL;
			features = mHeadsetClientStateMachine.getCurrentAgFeatures();
			Assert.assertTrue(features.contains(HeadsetClientHalConstants.PEER_FEAT_VREC));
			Assert.assertTrue(features.contains(HeadsetClientHalConstants.CHLD_FEAT_REL));

			mHeadsetClientStateMachine.mPeerFeatures = HeadsetClientHalConstants.PEER_FEAT_REJECT;
			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_REL_ACC;
			features = mHeadsetClientStateMachine.getCurrentAgFeatures();
			Assert.assertTrue(features.contains(HeadsetClientHalConstants.PEER_FEAT_REJECT));
			Assert.assertTrue(features.contains(HeadsetClientHalConstants.CHLD_FEAT_REL_ACC));

			mHeadsetClientStateMachine.mPeerFeatures = HeadsetClientHalConstants.PEER_FEAT_ECC;
			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_MERGE;
			features = mHeadsetClientStateMachine.getCurrentAgFeatures();
			Assert.assertTrue(features.contains(HeadsetClientHalConstants.PEER_FEAT_ECC));
			Assert.assertTrue(features.contains(HeadsetClientHalConstants.CHLD_FEAT_MERGE));

			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_MERGE_DETACH;
			features = mHeadsetClientStateMachine.getCurrentAgFeatures();
			Assert.assertTrue(features.contains(HeadsetClientHalConstants.CHLD_FEAT_MERGE_DETACH));
			}

			@Test
			public void testGetCurrentAgFeaturesBundle() {
			mHeadsetClientStateMachine.mPeerFeatures = HeadsetClientHalConstants.PEER_FEAT_3WAY;
			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_HOLD_ACC;
			Bundle bundle = mHeadsetClientStateMachine.getCurrentAgFeaturesBundle();
			Assert.assertTrue(bundle.getBoolean(BluetoothHeadsetClient.EXTRA_AG_FEATURE_3WAY_CALLING));
			Assert.assertTrue(bundle.getBoolean(
			BluetoothHeadsetClient.EXTRA_AG_FEATURE_ACCEPT_HELD_OR_WAITING_CALL));

			mHeadsetClientStateMachine.mPeerFeatures = HeadsetClientHalConstants.PEER_FEAT_VREC;
			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_REL;
			bundle = mHeadsetClientStateMachine.getCurrentAgFeaturesBundle();
			Assert.assertTrue(
			bundle.getBoolean(BluetoothHeadsetClient.EXTRA_AG_FEATURE_VOICE_RECOGNITION));
			Assert.assertTrue(bundle.getBoolean(
			BluetoothHeadsetClient.EXTRA_AG_FEATURE_RELEASE_HELD_OR_WAITING_CALL));

			mHeadsetClientStateMachine.mPeerFeatures = HeadsetClientHalConstants.PEER_FEAT_REJECT;
			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_REL_ACC;
			bundle = mHeadsetClientStateMachine.getCurrentAgFeaturesBundle();
			Assert.assertTrue(bundle.getBoolean(BluetoothHeadsetClient.EXTRA_AG_FEATURE_REJECT_CALL));
			Assert.assertTrue(
			bundle.getBoolean(BluetoothHeadsetClient.EXTRA_AG_FEATURE_RELEASE_AND_ACCEPT));

			mHeadsetClientStateMachine.mPeerFeatures = HeadsetClientHalConstants.PEER_FEAT_ECC;
			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_MERGE;
			bundle = mHeadsetClientStateMachine.getCurrentAgFeaturesBundle();
			Assert.assertTrue(bundle.getBoolean(BluetoothHeadsetClient.EXTRA_AG_FEATURE_ECC));
			Assert.assertTrue(bundle.getBoolean(BluetoothHeadsetClient.EXTRA_AG_FEATURE_MERGE));

			mHeadsetClientStateMachine.mChldFeatures = HeadsetClientHalConstants.CHLD_FEAT_MERGE_DETACH;
			bundle = mHeadsetClientStateMachine.getCurrentAgFeaturesBundle();
			Assert.assertTrue(
			bundle.getBoolean(BluetoothHeadsetClient.EXTRA_AG_FEATURE_MERGE_AND_DETACH));
			}

			@Test
			public void testGetCurrentCalls() {
			HfpClientCall call = new HfpClientCall(mTestDevice, 0, HfpClientCall.CALL_STATE_WAITING,
			"1", true, false, false);
			mHeadsetClientStateMachine.mCalls.put(0, call);

			List<HfpClientCall> currentCalls = mHeadsetClientStateMachine.getCurrentCalls();

			Assert.assertEquals(currentCalls.get(0), call);
			}

			@Test
			public void testGetMessageName() {
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(StackEvent.STACK_EVENT),
			"STACK_EVENT");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.CONNECT),
			"CONNECT");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.DISCONNECT),
			"DISCONNECT");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.CONNECT_AUDIO),
			"CONNECT_AUDIO");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(
			HeadsetClientStateMachine.DISCONNECT_AUDIO), "DISCONNECT_AUDIO");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(VOICE_RECOGNITION_START),
			"VOICE_RECOGNITION_START");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(VOICE_RECOGNITION_STOP),
			"VOICE_RECOGNITION_STOP");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.SET_MIC_VOLUME),
			"SET_MIC_VOLUME");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(
			HeadsetClientStateMachine.SET_SPEAKER_VOLUME), "SET_SPEAKER_VOLUME");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.DIAL_NUMBER),
			"DIAL_NUMBER");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.ACCEPT_CALL),
			"ACCEPT_CALL");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.REJECT_CALL),
			"REJECT_CALL");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.HOLD_CALL),
			"HOLD_CALL");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.TERMINATE_CALL),
			"TERMINATE_CALL");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(ENTER_PRIVATE_MODE),
			"ENTER_PRIVATE_MODE");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.SEND_DTMF),
			"SEND_DTMF");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(EXPLICIT_CALL_TRANSFER),
			"EXPLICIT_CALL_TRANSFER");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.DISABLE_NREC),
			"DISABLE_NREC");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(
			HeadsetClientStateMachine.SEND_VENDOR_AT_COMMAND), "SEND_VENDOR_AT_COMMAND");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.SEND_BIEV),
			"SEND_BIEV");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(
			HeadsetClientStateMachine.QUERY_CURRENT_CALLS), "QUERY_CURRENT_CALLS");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(
			HeadsetClientStateMachine.QUERY_OPERATOR_NAME), "QUERY_OPERATOR_NAME");
			Assert.assertEquals(
			HeadsetClientStateMachine.getMessageName(HeadsetClientStateMachine.SUBSCRIBER_INFO),
			"SUBSCRIBER_INFO");
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(
			HeadsetClientStateMachine.CONNECTING_TIMEOUT), "CONNECTING_TIMEOUT");
			int unknownMessageInt = 54;
			Assert.assertEquals(HeadsetClientStateMachine.getMessageName(unknownMessageInt),
			"UNKNOWN(" + unknownMessageInt + ")");
			}
	}		}