Snap for 6001391 from eb4c77d7228f956f928c7d3500a220339ee78388 to qt-aml-networking-releaseandroid-mainline-10.0.0_r6android10-mainline-networking-release

Change-Id: Ifede049eeae909912e9792f87a89bf4ede7e34d9

8 files changed, 1112 insertions, 0 deletions

diff --git a/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2ChallengeRequestTest.java b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2ChallengeRequestTest.java
new file mode 100644
index 00000000..45a86735
--- /dev/null
+++ b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2ChallengeRequestTest.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+package com.android.internal.net.eap.message.mschapv2;
+
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.CHALLENGE_BYTES;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.CHALLENGE_REQUEST_LONG_MS_LENGTH;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.CHALLENGE_REQUEST_SHORT_CHALLENGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.CHALLENGE_REQUEST_SHORT_MS_LENGTH;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.CHALLENGE_REQUEST_WRONG_OP_CODE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_CHALLENGE_REQUEST;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.ID_INT;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SERVER_NAME_BYTES;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EAP_MSCHAP_V2_CHALLENGE;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.android.internal.net.eap.EapResult.EapError;
+import com.android.internal.net.eap.exceptions.mschapv2.EapMsChapV2ParsingException;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2ChallengeRequest;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2TypeDataDecoder;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2TypeDataDecoder.DecodeResult;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.nio.BufferUnderflowException;
+
+public class EapMsChapV2ChallengeRequestTest {
+    private static final String TAG = EapMsChapV2ChallengeRequestTest.class.getSimpleName();
+
+    private EapMsChapV2TypeDataDecoder mTypeDataDecoder;
+
+    @Before
+    public void setUp() {
+        mTypeDataDecoder = new EapMsChapV2TypeDataDecoder();
+    }
+
+    @Test
+    public void testDecodeChallengeRequest() {
+        DecodeResult<EapMsChapV2ChallengeRequest> result =
+                mTypeDataDecoder.decodeChallengeRequest(TAG, EAP_MSCHAP_V2_CHALLENGE_REQUEST);
+        assertTrue(result.isSuccessfulDecode());
+        EapMsChapV2ChallengeRequest challengeRequest = result.eapTypeData;
+
+        assertEquals(EAP_MSCHAP_V2_CHALLENGE, challengeRequest.opCode);
+        assertEquals(ID_INT, challengeRequest.msChapV2Id);
+        assertEquals(EAP_MSCHAP_V2_CHALLENGE_REQUEST.length, challengeRequest.msLength);
+        assertArrayEquals(CHALLENGE_BYTES, challengeRequest.challenge);
+        assertArrayEquals(SERVER_NAME_BYTES, challengeRequest.name);
+    }
+
+    @Test
+    public void testDecodeChallengeRequestWrongOpCode() {
+        DecodeResult<EapMsChapV2ChallengeRequest> result =
+                mTypeDataDecoder.decodeChallengeRequest(TAG, CHALLENGE_REQUEST_WRONG_OP_CODE);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof EapMsChapV2ParsingException);
+    }
+
+    @Test
+    public void testDecodeChallengeRequestShortChallenge() {
+        DecodeResult<EapMsChapV2ChallengeRequest> result =
+                mTypeDataDecoder.decodeChallengeRequest(TAG, CHALLENGE_REQUEST_SHORT_CHALLENGE);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof EapMsChapV2ParsingException);
+    }
+
+    @Test
+    public void testDecodeChallengeRequestShortMsLength() {
+        DecodeResult<EapMsChapV2ChallengeRequest> result =
+                mTypeDataDecoder.decodeChallengeRequest(TAG, CHALLENGE_REQUEST_SHORT_MS_LENGTH);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof EapMsChapV2ParsingException);
+    }
+
+    @Test
+    public void testDecodeChallengeRequestLongMsLength() {
+        DecodeResult<EapMsChapV2ChallengeRequest> result =
+                mTypeDataDecoder.decodeChallengeRequest(TAG, CHALLENGE_REQUEST_LONG_MS_LENGTH);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof BufferUnderflowException);
+    }
+
+    @Test
+    public void testEncodeChallengeRequestFails() throws Exception {
+        EapMsChapV2ChallengeRequest challengeRequest =
+                new EapMsChapV2ChallengeRequest(
+                        ID_INT,
+                        EAP_MSCHAP_V2_CHALLENGE_REQUEST.length,
+                        CHALLENGE_BYTES,
+                        SERVER_NAME_BYTES);
+        try {
+            challengeRequest.encode();
+            fail("Expected UnsupportedOperationException for encoding a Challenge Request");
+        } catch (UnsupportedOperationException expected) {
+        }
+    }
+}
diff --git a/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2ChallengeResponseTest.java b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2ChallengeResponseTest.java
new file mode 100644
index 00000000..3e243a98
--- /dev/null
+++ b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2ChallengeResponseTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+package com.android.internal.net.eap.message.mschapv2;
+
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_CHALLENGE_RESPONSE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.ID_INT;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.NT_RESPONSE_BYTES;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.PEER_CHALLENGE_BYTES;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.PEER_NAME_BYTES;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SHORT_CHALLENGE_BYTES;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SHORT_NT_RESPONSE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EAP_MSCHAP_V2_RESPONSE;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.android.internal.net.eap.exceptions.mschapv2.EapMsChapV2ParsingException;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2ChallengeResponse;
+
+import org.junit.Test;
+
+public class EapMsChapV2ChallengeResponseTest {
+    private static final int FLAGS = 0;
+    private static final int INVALID_FLAGS = 0xFF;
+
+    @Test
+    public void testConstructor() throws Exception {
+        EapMsChapV2ChallengeResponse challengeResponse =
+                new EapMsChapV2ChallengeResponse(
+                        ID_INT, PEER_CHALLENGE_BYTES, NT_RESPONSE_BYTES, FLAGS, PEER_NAME_BYTES);
+        assertEquals(EAP_MSCHAP_V2_RESPONSE, challengeResponse.opCode);
+        assertEquals(ID_INT, challengeResponse.msChapV2Id);
+        assertEquals(EAP_MSCHAP_V2_CHALLENGE_RESPONSE.length, challengeResponse.msLength);
+        assertArrayEquals(PEER_CHALLENGE_BYTES, challengeResponse.peerChallenge);
+        assertArrayEquals(NT_RESPONSE_BYTES, challengeResponse.ntResponse);
+        assertEquals(FLAGS, challengeResponse.flags);
+        assertArrayEquals(PEER_NAME_BYTES, challengeResponse.name);
+    }
+
+    @Test
+    public void testConstructorInvalidChallenge() {
+        try {
+            EapMsChapV2ChallengeResponse challengeResponse =
+                    new EapMsChapV2ChallengeResponse(
+                            ID_INT,
+                            SHORT_CHALLENGE_BYTES,
+                            NT_RESPONSE_BYTES,
+                            FLAGS,
+                            PEER_NAME_BYTES);
+            fail("Expected EapMsChapV2ParsingException for invalid Peer Challenge length");
+        } catch (EapMsChapV2ParsingException expected) {
+        }
+    }
+
+    @Test
+    public void testConstructorInvalidNtResponse() {
+        try {
+            EapMsChapV2ChallengeResponse challengeResponse =
+                    new EapMsChapV2ChallengeResponse(
+                            ID_INT,
+                            PEER_CHALLENGE_BYTES,
+                            SHORT_NT_RESPONSE,
+                            FLAGS,
+                            PEER_NAME_BYTES);
+            fail("Expected EapMsChapV2ParsingException for invalid NT-Response length");
+        } catch (EapMsChapV2ParsingException expected) {
+        }
+    }
+
+    @Test
+    public void testConstructorInvalidFlags() {
+        try {
+            EapMsChapV2ChallengeResponse challengeResponse =
+                    new EapMsChapV2ChallengeResponse(
+                            ID_INT,
+                            PEER_CHALLENGE_BYTES,
+                            NT_RESPONSE_BYTES,
+                            INVALID_FLAGS,
+                            PEER_NAME_BYTES);
+            fail("Expected EapMsChapV2ParsingException for non-zero Flags value");
+        } catch (EapMsChapV2ParsingException expected) {
+        }
+    }
+
+    @Test
+    public void testEncode() throws Exception {
+        EapMsChapV2ChallengeResponse challengeResponse =
+                new EapMsChapV2ChallengeResponse(
+                        ID_INT, PEER_CHALLENGE_BYTES, NT_RESPONSE_BYTES, FLAGS, PEER_NAME_BYTES);
+        byte[] encodedChallengeResponse = challengeResponse.encode();
+
+        assertArrayEquals(EAP_MSCHAP_V2_CHALLENGE_RESPONSE, encodedChallengeResponse);
+    }
+}
diff --git a/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2FailureRequestTest.java b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2FailureRequestTest.java
new file mode 100644
index 00000000..ead8022a
--- /dev/null
+++ b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2FailureRequestTest.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+package com.android.internal.net.eap.message.mschapv2;
+
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.CHALLENGE_BYTES;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_FAILURE_REQUEST;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_FAILURE_REQUEST_MISSING_MESSAGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_FAILURE_REQUEST_MISSING_MESSAGE_WITH_SPACE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.ERROR_CODE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.FAILURE_REQUEST_EXTRA_ATTRIBUTE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.FAILURE_REQUEST_INVALID_CHALLENGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.FAILURE_REQUEST_INVALID_ERROR_CODE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.FAILURE_REQUEST_INVALID_PASSWORD_CHANGE_PROTOCOL;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.FAILURE_REQUEST_SHORT_CHALLENGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.ID_INT;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.MESSAGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.MESSAGE_MISSING_TEXT;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.PASSWORD_CHANGE_PROTOCOL;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.RETRY_BIT;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EAP_MSCHAP_V2_FAILURE;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.android.internal.net.eap.exceptions.mschapv2.EapMsChapV2ParsingException;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2FailureRequest;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2TypeDataDecoder;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2TypeDataDecoder.DecodeResult;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class EapMsChapV2FailureRequestTest {
+    private static final String TAG = EapMsChapV2FailureRequestTest.class.getSimpleName();
+
+    private EapMsChapV2TypeDataDecoder mTypeDataDecoder;
+
+    @Before
+    public void setUp() {
+        mTypeDataDecoder = new EapMsChapV2TypeDataDecoder();
+    }
+
+    @Test
+    public void testDecodeFailureRequest() {
+        DecodeResult<EapMsChapV2FailureRequest> result =
+                mTypeDataDecoder.decodeFailureRequest(TAG, EAP_MSCHAP_V2_FAILURE_REQUEST);
+        assertTrue(result.isSuccessfulDecode());
+
+        EapMsChapV2FailureRequest failureRequest = result.eapTypeData;
+        assertEquals(EAP_MSCHAP_V2_FAILURE, failureRequest.opCode);
+        assertEquals(ID_INT, failureRequest.msChapV2Id);
+        assertEquals(EAP_MSCHAP_V2_FAILURE_REQUEST.length, failureRequest.msLength);
+        assertEquals(ERROR_CODE, failureRequest.errorCode);
+        assertEquals(RETRY_BIT, failureRequest.isRetryable);
+        assertArrayEquals(CHALLENGE_BYTES, failureRequest.challenge);
+        assertEquals(PASSWORD_CHANGE_PROTOCOL, failureRequest.passwordChangeProtocol);
+        assertEquals(MESSAGE, failureRequest.message);
+    }
+
+    @Test
+    public void testDecodeFailureRequestMissingMessage() {
+        DecodeResult<EapMsChapV2FailureRequest> result =
+                mTypeDataDecoder.decodeFailureRequest(
+                        TAG, EAP_MSCHAP_V2_FAILURE_REQUEST_MISSING_MESSAGE);
+        assertTrue(result.isSuccessfulDecode());
+
+        EapMsChapV2FailureRequest failureRequest = result.eapTypeData;
+        assertEquals(EAP_MSCHAP_V2_FAILURE, failureRequest.opCode);
+        assertEquals(ID_INT, failureRequest.msChapV2Id);
+        assertEquals(EAP_MSCHAP_V2_FAILURE_REQUEST_MISSING_MESSAGE.length, failureRequest.msLength);
+        assertEquals(ERROR_CODE, failureRequest.errorCode);
+        assertEquals(RETRY_BIT, failureRequest.isRetryable);
+        assertArrayEquals(CHALLENGE_BYTES, failureRequest.challenge);
+        assertEquals(PASSWORD_CHANGE_PROTOCOL, failureRequest.passwordChangeProtocol);
+        assertEquals(MESSAGE_MISSING_TEXT, failureRequest.message);
+    }
+
+    @Test
+    public void testDecodeFailureRequestMissingMessageWithSpace() {
+        DecodeResult<EapMsChapV2FailureRequest> result =
+                mTypeDataDecoder.decodeFailureRequest(
+                        TAG, EAP_MSCHAP_V2_FAILURE_REQUEST_MISSING_MESSAGE_WITH_SPACE);
+        assertTrue(result.isSuccessfulDecode());
+
+        EapMsChapV2FailureRequest failureRequest = result.eapTypeData;
+        assertEquals(EAP_MSCHAP_V2_FAILURE, failureRequest.opCode);
+        assertEquals(ID_INT, failureRequest.msChapV2Id);
+        assertEquals(
+                EAP_MSCHAP_V2_FAILURE_REQUEST_MISSING_MESSAGE_WITH_SPACE.length,
+                failureRequest.msLength);
+        assertEquals(ERROR_CODE, failureRequest.errorCode);
+        assertEquals(RETRY_BIT, failureRequest.isRetryable);
+        assertArrayEquals(CHALLENGE_BYTES, failureRequest.challenge);
+        assertEquals(PASSWORD_CHANGE_PROTOCOL, failureRequest.passwordChangeProtocol);
+        assertEquals(MESSAGE_MISSING_TEXT, failureRequest.message);
+    }
+
+    @Test
+    public void testDecodeFailureRequestInvalidErrorCode() {
+        DecodeResult<EapMsChapV2FailureRequest> result =
+                mTypeDataDecoder.decodeFailureRequest(TAG, FAILURE_REQUEST_INVALID_ERROR_CODE);
+        assertTrue(!result.isSuccessfulDecode());
+        assertTrue(result.eapError.cause instanceof NumberFormatException);
+    }
+
+    @Test
+    public void testDecodeFailureRequestInvalidChallenge() {
+        DecodeResult<EapMsChapV2FailureRequest> result =
+                mTypeDataDecoder.decodeFailureRequest(TAG, FAILURE_REQUEST_INVALID_CHALLENGE);
+        assertTrue(!result.isSuccessfulDecode());
+        assertTrue(result.eapError.cause instanceof NumberFormatException);
+    }
+
+    @Test
+    public void testDecodeFailureRequestShortChallenge() {
+        DecodeResult<EapMsChapV2FailureRequest> result =
+                mTypeDataDecoder.decodeFailureRequest(TAG, FAILURE_REQUEST_SHORT_CHALLENGE);
+        assertTrue(!result.isSuccessfulDecode());
+        assertTrue(result.eapError.cause instanceof EapMsChapV2ParsingException);
+    }
+
+    @Test
+    public void testDecodeFailureRequestInvalidPasswordChangeProtocol() {
+        DecodeResult<EapMsChapV2FailureRequest> result =
+                mTypeDataDecoder.decodeFailureRequest(
+                        TAG, FAILURE_REQUEST_INVALID_PASSWORD_CHANGE_PROTOCOL);
+        assertTrue(!result.isSuccessfulDecode());
+        assertTrue(result.eapError.cause instanceof NumberFormatException);
+    }
+
+    @Test
+    public void testDecodeFailureExtraAttribute() {
+        DecodeResult<EapMsChapV2FailureRequest> result =
+                mTypeDataDecoder.decodeFailureRequest(TAG, FAILURE_REQUEST_EXTRA_ATTRIBUTE);
+        assertTrue(!result.isSuccessfulDecode());
+        assertTrue(result.eapError.cause instanceof EapMsChapV2ParsingException);
+    }
+
+    @Test
+    public void testEncodeFails() throws Exception {
+        EapMsChapV2FailureRequest failureRequest =
+                new EapMsChapV2FailureRequest(
+                        ID_INT,
+                        EAP_MSCHAP_V2_FAILURE_REQUEST.length,
+                        ERROR_CODE,
+                        RETRY_BIT,
+                        CHALLENGE_BYTES,
+                        PASSWORD_CHANGE_PROTOCOL,
+                        MESSAGE);
+        try {
+            failureRequest.encode();
+            fail("Expected UnsupportedOperationException for encoding a request");
+        } catch (UnsupportedOperationException expected) {
+        }
+    }
+}
diff --git a/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2FailureResponseTest.java b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2FailureResponseTest.java
new file mode 100644
index 00000000..261ddb28
--- /dev/null
+++ b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2FailureResponseTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+package com.android.internal.net.eap.message.mschapv2;
+
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_FAILURE_RESPONSE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EAP_MSCHAP_V2_FAILURE;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2FailureResponse;
+
+import org.junit.Test;
+
+public class EapMsChapV2FailureResponseTest {
+    @Test
+    public void testGetEapMsChapV2FailureResponse() {
+        EapMsChapV2FailureResponse failureResponse =
+                EapMsChapV2FailureResponse.getEapMsChapV2FailureResponse();
+        assertEquals(EAP_MSCHAP_V2_FAILURE, failureResponse.opCode);
+    }
+
+    @Test
+    public void testEncode() {
+        EapMsChapV2FailureResponse failureResponse =
+                EapMsChapV2FailureResponse.getEapMsChapV2FailureResponse();
+        assertArrayEquals(EAP_MSCHAP_V2_FAILURE_RESPONSE, failureResponse.encode());
+    }
+}
diff --git a/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2PacketDefinitions.java b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2PacketDefinitions.java
new file mode 100644
index 00000000..e70c2a2f
--- /dev/null
+++ b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2PacketDefinitions.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+package com.android.internal.net.eap.message.mschapv2;
+
+import static com.android.internal.net.TestUtils.hexStringToByteArray;
+
+public class EapMsChapV2PacketDefinitions {
+    public static final String ID = "1F";
+    public static final int ID_INT = Integer.parseInt(ID, 16 /* radix */);
+
+    public static final String CHALLENGE = "000102030405060708090A0B0C0D0E0F";
+    public static final byte[] CHALLENGE_BYTES = hexStringToByteArray(CHALLENGE);
+
+    // server name is the ASCII hex for "authenticator@android.net"
+    public static final String SERVER_NAME = "61757468656E74696361746F7240616E64726F69642E6E6574";
+    public static final byte[] SERVER_NAME_BYTES = hexStringToByteArray(SERVER_NAME);
+    public static final byte[] EAP_MSCHAP_V2_CHALLENGE_REQUEST =
+            hexStringToByteArray("01" + ID + "002E10" + CHALLENGE + SERVER_NAME);
+
+    public static final byte[] CHALLENGE_REQUEST_WRONG_OP_CODE = hexStringToByteArray("02");
+    public static final String SHORT_CHALLENGE = "001122334455";
+    public static final byte[] SHORT_CHALLENGE_BYTES = hexStringToByteArray(SHORT_CHALLENGE);
+    public static final byte[] CHALLENGE_REQUEST_SHORT_CHALLENGE =
+            hexStringToByteArray("01" + ID + "002406" + SHORT_CHALLENGE + SERVER_NAME);
+    public static final byte[] CHALLENGE_REQUEST_SHORT_MS_LENGTH =
+            hexStringToByteArray("01" + ID + "000110" + CHALLENGE + SERVER_NAME);
+    public static final byte[] CHALLENGE_REQUEST_LONG_MS_LENGTH =
+            hexStringToByteArray("01" + ID + "00FF10" + CHALLENGE + SERVER_NAME);
+
+    public static final String PEER_CHALLENGE = "00112233445566778899AABBCCDDEEFF";
+    public static final byte[] PEER_CHALLENGE_BYTES = hexStringToByteArray(PEER_CHALLENGE);
+    public static final String NT_RESPONSE = "FFEEDDCCBBAA998877665544332211000011223344556677";
+    public static final byte[] NT_RESPONSE_BYTES = hexStringToByteArray(NT_RESPONSE);
+
+    // peer name is the ASCII hex for "peer@android.net"
+    public static final String PEER_NAME = "7065657240616E64726F69642E6E6574";
+    public static final byte[] PEER_NAME_BYTES = hexStringToByteArray(PEER_NAME);
+    public static final byte[] EAP_MSCHAP_V2_CHALLENGE_RESPONSE =
+            hexStringToByteArray(
+                    "02"
+                            + ID
+                            + "004631"
+                            + PEER_CHALLENGE
+                            + "0000000000000000"
+                            + NT_RESPONSE
+                            + "00"
+                            + PEER_NAME);
+
+    public static final byte[] SHORT_NT_RESPONSE = hexStringToByteArray("0011223344");
+
+    public static final String AUTH_STRING = "00112233445566778899AABBCCDDEEFF00112233";
+
+    // ASCII hex for AUTH_STRING
+    public static final String AUTH_STRING_HEX =
+            "30303131323233333434353536363737383839394141424243434444454546463030313132323333";
+    public static final byte[] AUTH_BYTES = hexStringToByteArray(AUTH_STRING);
+
+    // hex("S=") + AUTH_STRING_HEX
+    public static final String FORMATTED_AUTH_STRING = "533D" + AUTH_STRING_HEX;
+
+    public static final String SPACE_HEX = "20";
+
+    // ASCII hex for: "test Android 1234"
+    public static final String MESSAGE = "test Android 1234";
+    public static final String MESSAGE_HEX = "7465737420416E64726F69642031323334";
+
+    // hex("M=") + MESSAGE_HEX
+    public static final String FORMATTED_MESSAGE = "4D3D" + MESSAGE_HEX;
+
+    public static final byte[] EAP_MSCHAP_V2_SUCCESS_REQUEST =
+            hexStringToByteArray(
+                    "03" + ID + "0042" + FORMATTED_AUTH_STRING + SPACE_HEX + FORMATTED_MESSAGE);
+    public static final byte[] EAP_MSCHAP_V2_SUCCESS_REQUEST_EMPTY_MESSAGE =
+            hexStringToByteArray("03" + ID + "0031" + FORMATTED_AUTH_STRING + SPACE_HEX + "4D3D");
+    public static final byte[] EAP_MSCHAP_V2_SUCCESS_REQUEST_MISSING_MESSAGE =
+            hexStringToByteArray("03" + ID + "002E" + FORMATTED_AUTH_STRING);
+    public static final byte[] EAP_MSCHAP_V2_SUCCESS_REQUEST_MISSING_MESSAGE_WITH_SPACE =
+            hexStringToByteArray("03" + ID + "002F" + FORMATTED_AUTH_STRING + SPACE_HEX);
+    public static final String MESSAGE_MISSING_TEXT = "<omitted by authenticator>";
+
+    public static final String SHORT_AUTH_STRING = "001122334455";
+
+    public static final byte[] SUCCESS_REQUEST_WRONG_OP_CODE = hexStringToByteArray("02");
+
+    // message format: hex("M=") + AUTH_STRING_HEX + hex("M=") + MESSAGE_HEX
+    public static final byte[] SUCCESS_REQUEST_WRONG_PREFIX =
+            hexStringToByteArray("03" + ID + "00314D3D" + AUTH_STRING_HEX + SPACE_HEX + "4D3D");
+
+    // message format: hex("S=") + SHORT_AUTH_STRING + hex("M=") + MESSAGE_HEX
+    public static final byte[] SUCCESS_REQUEST_SHORT_AUTH_STRING =
+            hexStringToByteArray("03" + ID + "0031533D" + SHORT_AUTH_STRING + SPACE_HEX + "4D3D");
+
+    public static final String INVALID_AUTH_HEX =
+            "3030313132323333343435353636373738383939414142424343444445454646303031317A7A7979";
+    public static final byte[] SUCCESS_REQUEST_INVALID_AUTH_STRING =
+            hexStringToByteArray("03" + ID + "0031533D" + INVALID_AUTH_HEX + SPACE_HEX + "4D3D");
+
+    // extra key-value: hex("N=12")
+    public static final String EXTRA_KEY = "4E3D3132";
+    public static final byte[] SUCCESS_REQUEST_EXTRA_ATTRIBUTE =
+            hexStringToByteArray(
+                    "03"
+                            + ID
+                            + "0042"
+                            + FORMATTED_AUTH_STRING
+                            + SPACE_HEX
+                            + EXTRA_KEY
+                            + SPACE_HEX
+                            + FORMATTED_MESSAGE);
+
+    public static final String SUCCESS_REQUEST = "S=" + AUTH_STRING + " M=" + MESSAGE;
+    public static final String EXTRA_M_MESSAGE = "M=" + MESSAGE;
+    public static final String SUCCESS_REQUEST_EXTRA_M =
+            "S=" + AUTH_STRING + " M=" + EXTRA_M_MESSAGE;
+    public static final String SUCCESS_REQUEST_MISSING_M = "S=" + AUTH_STRING;
+    public static final String SUCCESS_REQUEST_INVALID_FORMAT =
+            "S==" + AUTH_STRING + "M=" + MESSAGE;
+    public static final String SUCCESS_REQUEST_DUPLICATE_KEY =
+            "S=" + AUTH_STRING + " S=" + AUTH_STRING + " M=" + MESSAGE;
+
+    public static final byte[] EAP_MSCHAP_V2_SUCCESS_RESPONSE = hexStringToByteArray("03");
+
+    public static final int ERROR_CODE = 647; // account disabled
+
+    // formatted error code: hex("E=" + ERROR_CODE)
+    public static final String FORMATTED_ERROR_CODE = "453D363437";
+    public static final boolean RETRY_BIT = true;
+
+    // formatted retry bit: hex("R=1")
+    public static final String FORMATTED_RETRY_BIT = "523D31";
+
+    // challenge hex: hex(CHALLENGE)
+    public static final String CHALLENGE_HEX =
+            "3030303130323033303430353036303730383039304130423043304430453046";
+
+    // formatted challenge: hex("C=") + CHALLENGE_HEX
+    public static final String FORMATTED_CHALLENGE = "433D" + CHALLENGE_HEX;
+
+    public static final int PASSWORD_CHANGE_PROTOCOL = 3;
+
+    // formatted password change protocol: hex("V=3")
+    public static final String FORMATTED_PASSWORD_CHANGE_PROTOCOL = "563D33";
+
+    public static final byte[] EAP_MSCHAP_V2_FAILURE_REQUEST =
+            hexStringToByteArray(
+                    "04"
+                            + ID
+                            + "0048"
+                            + FORMATTED_ERROR_CODE
+                            + SPACE_HEX
+                            + FORMATTED_RETRY_BIT
+                            + SPACE_HEX
+                            + FORMATTED_CHALLENGE
+                            + SPACE_HEX
+                            + FORMATTED_PASSWORD_CHANGE_PROTOCOL
+                            + SPACE_HEX
+                            + FORMATTED_MESSAGE);
+    public static final byte[] EAP_MSCHAP_V2_FAILURE_REQUEST_MISSING_MESSAGE =
+            hexStringToByteArray(
+                    "04"
+                            + ID
+                            + "0034"
+                            + FORMATTED_ERROR_CODE
+                            + SPACE_HEX
+                            + FORMATTED_RETRY_BIT
+                            + SPACE_HEX
+                            + FORMATTED_CHALLENGE
+                            + SPACE_HEX
+                            + FORMATTED_PASSWORD_CHANGE_PROTOCOL);
+    public static final byte[] EAP_MSCHAP_V2_FAILURE_REQUEST_MISSING_MESSAGE_WITH_SPACE =
+            hexStringToByteArray(
+                    "04"
+                            + ID
+                            + "0035"
+                            + FORMATTED_ERROR_CODE
+                            + SPACE_HEX
+                            + FORMATTED_RETRY_BIT
+                            + SPACE_HEX
+                            + FORMATTED_CHALLENGE
+                            + SPACE_HEX
+                            + FORMATTED_PASSWORD_CHANGE_PROTOCOL
+                            + SPACE_HEX);
+
+    // invalid error code: hex("E=abc")
+    public static final String INVALID_ERROR_CODE = "453D616263";
+    public static final byte[] FAILURE_REQUEST_INVALID_ERROR_CODE =
+            hexStringToByteArray(
+                    "04"
+                            + ID
+                            + "0048"
+                            + INVALID_ERROR_CODE
+                            + SPACE_HEX
+                            + FORMATTED_RETRY_BIT
+                            + SPACE_HEX
+                            + FORMATTED_CHALLENGE
+                            + SPACE_HEX
+                            + FORMATTED_PASSWORD_CHANGE_PROTOCOL
+                            + SPACE_HEX
+                            + FORMATTED_MESSAGE);
+
+    // invalid challenge: hex("C=zyxd")
+    public static final String INVALID_CHALLENGE = "433D7A797864";
+    public static final byte[] FAILURE_REQUEST_INVALID_CHALLENGE =
+            hexStringToByteArray(
+                    "04"
+                            + ID
+                            + "0032"
+                            + FORMATTED_ERROR_CODE
+                            + SPACE_HEX
+                            + FORMATTED_RETRY_BIT
+                            + SPACE_HEX
+                            + INVALID_CHALLENGE
+                            + SPACE_HEX
+                            + FORMATTED_PASSWORD_CHANGE_PROTOCOL
+                            + SPACE_HEX
+                            + FORMATTED_MESSAGE);
+
+    // short challenge: hex("C=" + SHORT_CHALLENGE)
+    public static final String FORMATTED_SHORT_CHALLENGE = "433D303031313232333334343535";
+    public static final byte[] FAILURE_REQUEST_SHORT_CHALLENGE =
+            hexStringToByteArray(
+                    "04"
+                            + ID
+                            + "0034"
+                            + FORMATTED_ERROR_CODE
+                            + SPACE_HEX
+                            + FORMATTED_RETRY_BIT
+                            + SPACE_HEX
+                            + FORMATTED_SHORT_CHALLENGE
+                            + SPACE_HEX
+                            + FORMATTED_PASSWORD_CHANGE_PROTOCOL
+                            + SPACE_HEX
+                            + FORMATTED_MESSAGE);
+
+    // invalid password change protocol: hex("V=d")
+    public static final String INVALID_PASSWORD_CHANGE_PROTOCOL = "563D64";
+    public static final byte[] FAILURE_REQUEST_INVALID_PASSWORD_CHANGE_PROTOCOL =
+            hexStringToByteArray(
+                    "04"
+                            + ID
+                            + "0048"
+                            + FORMATTED_ERROR_CODE
+                            + SPACE_HEX
+                            + FORMATTED_RETRY_BIT
+                            + SPACE_HEX
+                            + FORMATTED_CHALLENGE
+                            + SPACE_HEX
+                            + INVALID_PASSWORD_CHANGE_PROTOCOL
+                            + SPACE_HEX
+                            + FORMATTED_MESSAGE);
+
+    public static final byte[] FAILURE_REQUEST_EXTRA_ATTRIBUTE =
+            hexStringToByteArray(
+                    "04"
+                            + ID
+                            + "0048"
+                            + FORMATTED_ERROR_CODE
+                            + SPACE_HEX
+                            + FORMATTED_RETRY_BIT
+                            + SPACE_HEX
+                            + FORMATTED_CHALLENGE
+                            + SPACE_HEX
+                            + FORMATTED_PASSWORD_CHANGE_PROTOCOL
+                            + SPACE_HEX
+                            + EXTRA_KEY
+                            + SPACE_HEX
+                            + FORMATTED_MESSAGE);
+
+    public static final byte[] EAP_MSCHAP_V2_FAILURE_RESPONSE = hexStringToByteArray("04");
+}
diff --git a/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2SuccessRequestTest.java b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2SuccessRequestTest.java
new file mode 100644
index 00000000..1e0909ed
--- /dev/null
+++ b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2SuccessRequestTest.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+package com.android.internal.net.eap.message.mschapv2;
+
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.AUTH_BYTES;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_SUCCESS_REQUEST;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_SUCCESS_REQUEST_EMPTY_MESSAGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_SUCCESS_REQUEST_MISSING_MESSAGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_SUCCESS_REQUEST_MISSING_MESSAGE_WITH_SPACE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.ID_INT;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.MESSAGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.MESSAGE_MISSING_TEXT;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST_EXTRA_ATTRIBUTE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST_INVALID_AUTH_STRING;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST_SHORT_AUTH_STRING;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST_WRONG_OP_CODE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST_WRONG_PREFIX;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EAP_MSCHAP_V2_SUCCESS;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.android.internal.net.eap.EapResult.EapError;
+import com.android.internal.net.eap.exceptions.mschapv2.EapMsChapV2ParsingException;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2SuccessRequest;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2TypeDataDecoder;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2TypeDataDecoder.DecodeResult;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.nio.BufferUnderflowException;
+
+public class EapMsChapV2SuccessRequestTest {
+    private static final String TAG = EapMsChapV2SuccessRequestTest.class.getSimpleName();
+
+    private EapMsChapV2TypeDataDecoder mTypeDataDecoder;
+
+    @Before
+    public void setUp() {
+        mTypeDataDecoder = new EapMsChapV2TypeDataDecoder();
+    }
+
+    @Test
+    public void testDecodeSuccessRequest() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(TAG, EAP_MSCHAP_V2_SUCCESS_REQUEST);
+        assertTrue(result.isSuccessfulDecode());
+
+        EapMsChapV2SuccessRequest successRequest = result.eapTypeData;
+        assertEquals(EAP_MSCHAP_V2_SUCCESS, successRequest.opCode);
+        assertEquals(ID_INT, successRequest.msChapV2Id);
+        assertEquals(EAP_MSCHAP_V2_SUCCESS_REQUEST.length, successRequest.msLength);
+        assertArrayEquals(AUTH_BYTES, successRequest.authBytes);
+        assertEquals(MESSAGE, successRequest.message);
+    }
+
+    @Test
+    public void testDecodeSuccessRequestEmptyMessage() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(
+                        TAG, EAP_MSCHAP_V2_SUCCESS_REQUEST_EMPTY_MESSAGE);
+        assertTrue(result.isSuccessfulDecode());
+
+        EapMsChapV2SuccessRequest successRequest = result.eapTypeData;
+        assertEquals(EAP_MSCHAP_V2_SUCCESS, successRequest.opCode);
+        assertEquals(ID_INT, successRequest.msChapV2Id);
+        assertEquals(EAP_MSCHAP_V2_SUCCESS_REQUEST_EMPTY_MESSAGE.length, successRequest.msLength);
+        assertArrayEquals(AUTH_BYTES, successRequest.authBytes);
+        assertTrue(successRequest.message.isEmpty());
+    }
+
+    @Test
+    public void testDecodeSuccessRequestMissingMessage() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(
+                        TAG, EAP_MSCHAP_V2_SUCCESS_REQUEST_MISSING_MESSAGE);
+        assertTrue(result.isSuccessfulDecode());
+
+        EapMsChapV2SuccessRequest successRequest = result.eapTypeData;
+        assertEquals(EAP_MSCHAP_V2_SUCCESS, successRequest.opCode);
+        assertEquals(ID_INT, successRequest.msChapV2Id);
+        assertEquals(EAP_MSCHAP_V2_SUCCESS_REQUEST_MISSING_MESSAGE.length, successRequest.msLength);
+        assertArrayEquals(AUTH_BYTES, successRequest.authBytes);
+        assertEquals(MESSAGE_MISSING_TEXT, successRequest.message);
+    }
+
+    @Test
+    public void testDecodeSuccessRequestMissingMessageWithSpace() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(
+                        TAG, EAP_MSCHAP_V2_SUCCESS_REQUEST_MISSING_MESSAGE_WITH_SPACE);
+        assertTrue(result.isSuccessfulDecode());
+
+        EapMsChapV2SuccessRequest successRequest = result.eapTypeData;
+        assertEquals(EAP_MSCHAP_V2_SUCCESS, successRequest.opCode);
+        assertEquals(ID_INT, successRequest.msChapV2Id);
+        assertEquals(
+                EAP_MSCHAP_V2_SUCCESS_REQUEST_MISSING_MESSAGE_WITH_SPACE.length,
+                successRequest.msLength);
+        assertArrayEquals(AUTH_BYTES, successRequest.authBytes);
+        assertEquals(MESSAGE_MISSING_TEXT, successRequest.message);
+    }
+
+    @Test
+    public void testDecodeSuccessRequestWrongOpCode() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(TAG, SUCCESS_REQUEST_WRONG_OP_CODE);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof EapMsChapV2ParsingException);
+    }
+
+    @Test
+    public void testDecodeSuccessRequestShortMessage() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(TAG, new byte[0]);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof BufferUnderflowException);
+    }
+
+    @Test
+    public void testDecodeSuccessRequestInvalidPrefix() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(TAG, SUCCESS_REQUEST_WRONG_PREFIX);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof EapMsChapV2ParsingException);
+    }
+
+    @Test
+    public void testDecodeSuccessRequestShortAuthString() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(TAG, SUCCESS_REQUEST_SHORT_AUTH_STRING);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof EapMsChapV2ParsingException);
+    }
+
+    @Test
+    public void testDecodeSuccessRequestInvalidAuthString() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(TAG, SUCCESS_REQUEST_INVALID_AUTH_STRING);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof NumberFormatException);
+    }
+
+    @Test
+    public void testDecodeSuccessRequestExtraAttribute() {
+        DecodeResult<EapMsChapV2SuccessRequest> result =
+                mTypeDataDecoder.decodeSuccessRequest(TAG, SUCCESS_REQUEST_EXTRA_ATTRIBUTE);
+        assertFalse(result.isSuccessfulDecode());
+        EapError eapError = result.eapError;
+        assertTrue(eapError.cause instanceof EapMsChapV2ParsingException);
+    }
+
+    @Test
+    public void testEncodeFails() throws Exception {
+        EapMsChapV2SuccessRequest successRequest =
+                new EapMsChapV2SuccessRequest(
+                        ID_INT, EAP_MSCHAP_V2_SUCCESS_REQUEST.length, AUTH_BYTES, MESSAGE);
+        try {
+            successRequest.encode();
+            fail("Expected UnsupportedOperationException for encoding a request");
+        } catch (UnsupportedOperationException expected) {
+        }
+    }
+}
diff --git a/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2SuccessResponseTest.java b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2SuccessResponseTest.java
new file mode 100644
index 00000000..524b3ecf
--- /dev/null
+++ b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2SuccessResponseTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+package com.android.internal.net.eap.message.mschapv2;
+
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EAP_MSCHAP_V2_SUCCESS_RESPONSE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EAP_MSCHAP_V2_SUCCESS;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2SuccessResponse;
+
+import org.junit.Test;
+
+public class EapMsChapV2SuccessResponseTest {
+    @Test
+    public void testGetEapMsChapV2SuccessResponse() {
+        EapMsChapV2SuccessResponse successResponse =
+                EapMsChapV2SuccessResponse.getEapMsChapV2SuccessResponse();
+        assertEquals(EAP_MSCHAP_V2_SUCCESS, successResponse.opCode);
+    }
+
+    @Test
+    public void testEncode() {
+        EapMsChapV2SuccessResponse successResponse =
+                EapMsChapV2SuccessResponse.getEapMsChapV2SuccessResponse();
+        assertArrayEquals(EAP_MSCHAP_V2_SUCCESS_RESPONSE, successResponse.encode());
+    }
+}
diff --git a/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2TypeDataTest.java b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2TypeDataTest.java
new file mode 100644
index 00000000..45f1c641
--- /dev/null
+++ b/tests/iketests/src/java/com/android/internal/net/eap/message/mschapv2/EapMsChapV2TypeDataTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+package com.android.internal.net.eap.message.mschapv2;
+
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.AUTH_BYTES;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.AUTH_STRING;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.EXTRA_M_MESSAGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.MESSAGE;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.MESSAGE_MISSING_TEXT;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST_DUPLICATE_KEY;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST_EXTRA_M;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST_INVALID_FORMAT;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2PacketDefinitions.SUCCESS_REQUEST_MISSING_M;
+import static com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EAP_MSCHAP_V2_CHALLENGE;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.android.internal.net.eap.EapResult.EapError;
+import com.android.internal.net.eap.exceptions.mschapv2.EapMsChapV2ParsingException;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2TypeDataDecoder.DecodeResult;
+import com.android.internal.net.eap.message.mschapv2.EapMsChapV2TypeData.EapMsChapV2VariableTypeData;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class EapMsChapV2TypeDataTest {
+    private static final int INVALID_OPCODE = -1;
+    private static final int MSCHAP_V2_ID = 1;
+    private static final int MS_LENGTH = 32;
+    private static final String HEX_STRING_INVALID_LENGTH = "00112";
+    private static final String HEX_STRING_INVALID_CHARS = "001122z-+x";
+
+    @Test
+    public void testEapMsChapV2TypeDataConstructor() throws Exception {
+        EapMsChapV2TypeData typeData = new EapMsChapV2TypeData(EAP_MSCHAP_V2_CHALLENGE) {};
+        assertEquals(EAP_MSCHAP_V2_CHALLENGE, typeData.opCode);
+
+        try {
+            new EapMsChapV2TypeData(INVALID_OPCODE) {};
+            fail("ExpectedEapMsChapV2ParsingException for invalid OpCode");
+        } catch (EapMsChapV2ParsingException expected) {
+        }
+    }
+
+    @Test
+    public void testEapMsChapV2VariableTypeDataConstructor() throws Exception {
+        EapMsChapV2VariableTypeData typeData =
+                new EapMsChapV2VariableTypeData(
+                        EAP_MSCHAP_V2_CHALLENGE, MSCHAP_V2_ID, MS_LENGTH) {};
+        assertEquals(EAP_MSCHAP_V2_CHALLENGE, typeData.opCode);
+        assertEquals(MSCHAP_V2_ID, typeData.msChapV2Id);
+        assertEquals(MS_LENGTH, typeData.msLength);
+
+        try {
+            new EapMsChapV2VariableTypeData(INVALID_OPCODE, MSCHAP_V2_ID, MS_LENGTH) {};
+            fail("ExpectedEapMsChapV2ParsingException for invalid OpCode");
+        } catch (EapMsChapV2ParsingException expected) {
+        }
+    }
+
+    @Test
+    public void testDecodeResultIsSuccessfulDecode() throws Exception {
+        DecodeResult<EapMsChapV2TypeData> result =
+                new DecodeResult(new EapMsChapV2TypeData(EAP_MSCHAP_V2_CHALLENGE) {});
+        assertTrue(result.isSuccessfulDecode());
+
+        result = new DecodeResult(new EapError(new Exception()));
+        assertFalse(result.isSuccessfulDecode());
+    }
+
+    @Test
+    public void testGetMessageMappings() throws Exception {
+        Map<String, String> expectedMappings = new HashMap<>();
+        expectedMappings.put("S", AUTH_STRING);
+        expectedMappings.put("M", MESSAGE);
+        assertEquals(expectedMappings, EapMsChapV2TypeData.getMessageMappings(SUCCESS_REQUEST));
+
+        expectedMappings = new HashMap<>();
+        expectedMappings.put("S", AUTH_STRING);
+        expectedMappings.put("M", EXTRA_M_MESSAGE);
+        assertEquals(
+                expectedMappings, EapMsChapV2TypeData.getMessageMappings(SUCCESS_REQUEST_EXTRA_M));
+
+        expectedMappings = new HashMap<>();
+        expectedMappings.put("S", AUTH_STRING);
+        expectedMappings.put("M", MESSAGE_MISSING_TEXT);
+        assertEquals(
+                expectedMappings,
+                EapMsChapV2TypeData.getMessageMappings(SUCCESS_REQUEST_MISSING_M));
+    }
+
+    @Test
+    public void testGetMessageMappingsInvalidFormat() {
+        try {
+            EapMsChapV2TypeData.getMessageMappings(SUCCESS_REQUEST_INVALID_FORMAT);
+            fail("Expected EapMsChapV2ParsingException for extra '='s in message");
+        } catch (EapMsChapV2ParsingException expected) {
+        }
+    }
+
+    @Test
+    public void testGetMessageMappingDuplicateKey() {
+        try {
+            EapMsChapV2TypeData.getMessageMappings(SUCCESS_REQUEST_DUPLICATE_KEY);
+            fail("Expected EapMsChapV2ParsingException for duplicate key in message");
+        } catch (EapMsChapV2ParsingException expected) {
+        }
+    }
+
+    @Test
+    public void testHexStringToByteArray() throws Exception {
+        byte[] result = EapMsChapV2TypeData.hexStringToByteArray(AUTH_STRING);
+        assertArrayEquals(AUTH_BYTES, result);
+    }
+
+    @Test
+    public void testHexStringToByteArrayInvalidLength() {
+        try {
+            EapMsChapV2TypeData.hexStringToByteArray(HEX_STRING_INVALID_LENGTH);
+            fail("Expected EapMsChapV2ParsingException for invalid hex string length");
+        } catch (EapMsChapV2ParsingException expected) {
+        }
+    }
+
+    @Test
+    public void testHexStringToByteArrayInvalidChars() throws Exception {
+        try {
+            EapMsChapV2TypeData.hexStringToByteArray(HEX_STRING_INVALID_CHARS);
+            fail("Expected NumberFormatException for invalid hex chars");
+        } catch (NumberFormatException expected) {
+        }
+    }
+}