| /* |
| * 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.ipsec.ike.message; |
| |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_ATTR_INTERNAL_IP4_ADDRESS; |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_ATTR_INTERNAL_IP4_DHCP; |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_ATTR_INTERNAL_IP4_DNS; |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_ATTR_INTERNAL_IP4_NETMASK; |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_ATTR_INTERNAL_IP4_SUBNET; |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_ATTR_INTERNAL_IP6_ADDRESS; |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_ATTR_INTERNAL_IP6_DNS; |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_ATTR_INTERNAL_IP6_SUBNET; |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_TYPE_REPLY; |
| import static com.android.internal.net.ipsec.ike.message.IkeConfigPayload.CONFIG_TYPE_REQUEST; |
| import static com.android.internal.net.ipsec.ike.message.IkePayload.PAYLOAD_TYPE_CP; |
| import static com.android.internal.net.ipsec.ike.message.IkePayload.PAYLOAD_TYPE_NOTIFY; |
| |
| import static org.junit.Assert.assertArrayEquals; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| import static org.mockito.Matchers.any; |
| import static org.mockito.Mockito.doAnswer; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.when; |
| |
| import android.net.LinkAddress; |
| |
| import com.android.internal.net.TestUtils; |
| import com.android.internal.net.ipsec.ike.exceptions.InvalidSyntaxException; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttrIpv4AddressBase; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttrIpv6AddrRangeBase; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttribute; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttributeIpv4Address; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttributeIpv4Dhcp; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttributeIpv4Dns; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttributeIpv4Netmask; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttributeIpv4Subnet; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttributeIpv6Address; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttributeIpv6Dns; |
| import com.android.internal.net.ipsec.ike.message.IkeConfigPayload.ConfigAttributeIpv6Subnet; |
| |
| import libcore.net.InetAddressUtils; |
| |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| import java.net.Inet4Address; |
| import java.net.Inet6Address; |
| import java.net.InetAddress; |
| import java.nio.ByteBuffer; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| public final class IkeConfigPayloadTest { |
| private static final String CONFIG_REQ_PAYLOAD_HEX = |
| "2900001801000000000100000008000000030000000a0000"; |
| private static final String CONFIG_RESP_PAYLOAD_HEX = |
| "210000200200000000010004c000026400030004080808080003000408080404"; |
| private static final String CONFIG_RESP_PAYLOAD_INVALID_ONE_HEX = |
| "210000200200000000010004c000026400020004fffffffe00020004fffffffe"; |
| private static final String CONFIG_RESP_PAYLOAD_INVALID_TWO_HEX = |
| "210000100200000000020004fffffffe"; |
| |
| private static final byte[] CONFIG_REQ_PAYLOAD = |
| TestUtils.hexStringToByteArray(CONFIG_REQ_PAYLOAD_HEX); |
| private static final byte[] CONFIG_RESP_PAYLOAD = |
| TestUtils.hexStringToByteArray(CONFIG_RESP_PAYLOAD_HEX); |
| |
| private static final Inet4Address IPV4_ADDRESS = |
| (Inet4Address) (InetAddressUtils.parseNumericAddress("192.0.2.100")); |
| private static final Inet4Address IPV4_NETMASK = |
| (Inet4Address) (InetAddressUtils.parseNumericAddress("255.255.255.240")); |
| private static final int IP4_PREFIX_LEN = 28; |
| private static final LinkAddress IPV4_LINK_ADDRESS = |
| new LinkAddress(IPV4_ADDRESS, IP4_PREFIX_LEN); |
| |
| private static final byte[] IPV4_ADDRESS_ATTRIBUTE_WITH_VALUE = |
| TestUtils.hexStringToByteArray("00010004c0000264"); |
| private static final byte[] IPV4_ADDRESS_ATTRIBUTE_WITHOUT_VALUE = |
| TestUtils.hexStringToByteArray("00010000"); |
| |
| private static final byte[] IPV4_NETMASK_ATTRIBUTE_WITHOUT_VALUE = |
| TestUtils.hexStringToByteArray("00020000"); |
| |
| private static final Inet4Address IPV4_DNS = |
| (Inet4Address) (InetAddressUtils.parseNumericAddress("8.8.8.8")); |
| private static final byte[] IPV4_DNS_ATTRIBUTE_VALUE = |
| TestUtils.hexStringToByteArray("08080808"); |
| private static final byte[] IPV4_DNS_ATTRIBUTE_WITHOUT_VALUE = |
| TestUtils.hexStringToByteArray("00030000"); |
| |
| private static final Inet4Address IPV4_DHCP = |
| (Inet4Address) (InetAddressUtils.parseNumericAddress("192.0.2.200")); |
| private static final byte[] IPV4_DHCP_ATTRIBUTE_WITH_VALUE = |
| TestUtils.hexStringToByteArray("00060004c00002c8"); |
| private static final byte[] IPV4_DHCP_ATTRIBUTE_WITHOUT_VALUE = |
| TestUtils.hexStringToByteArray("00060000"); |
| |
| private static final byte[] IPV4_SUBNET_ATTRIBUTE_VALUE = |
| TestUtils.hexStringToByteArray("c0000264fffffff0"); |
| private static final byte[] IPV4_SUBNET_ATTRIBUTE_WITH_VALUE = |
| TestUtils.hexStringToByteArray("000d0008c0000264fffffff0"); |
| private static final byte[] IPV4_SUBNET_ATTRIBUTE_WITHOUT_VALUE = |
| TestUtils.hexStringToByteArray("000d0000"); |
| |
| private static final Inet6Address IPV6_ADDRESS = |
| (Inet6Address) (InetAddressUtils.parseNumericAddress("2001:db8::1")); |
| private static final int IP6_PREFIX_LEN = 64; |
| private static final LinkAddress IPV6_LINK_ADDRESS = |
| new LinkAddress(IPV6_ADDRESS, IP6_PREFIX_LEN); |
| |
| private static final byte[] IPV6_ADDRESS_ATTRIBUTE_VALUE = |
| TestUtils.hexStringToByteArray("20010db800000000000000000000000140"); |
| private static final byte[] IPV6_ADDRESS_ATTRIBUTE_WITH_VALUE = |
| TestUtils.hexStringToByteArray("0008001120010db800000000000000000000000140"); |
| private static final byte[] IPV6_ADDRESS_ATTRIBUTE_WITHOUT_VALUE = |
| TestUtils.hexStringToByteArray("00080000"); |
| |
| private static final byte[] IPV6_SUBNET_ATTRIBUTE_VALUE = IPV6_ADDRESS_ATTRIBUTE_VALUE; |
| private static final byte[] IPV6_SUBNET_ATTRIBUTE_WITH_VALUE = |
| TestUtils.hexStringToByteArray("000f001120010db800000000000000000000000140"); |
| private static final byte[] IPV6_SUBNET_ATTRIBUTE_WITHOUT_VALUE = |
| TestUtils.hexStringToByteArray("000f0000"); |
| |
| private static final Inet6Address IPV6_DNS = |
| (Inet6Address) (InetAddressUtils.parseNumericAddress("2001:db8:100::1")); |
| private static final byte[] IPV6_DNS_ATTRIBUTE_WITHOUT_VALUE = |
| TestUtils.hexStringToByteArray("000a0000"); |
| |
| private Inet4Address[] mNetMasks; |
| private int[] mIpv4PrefixLens; |
| |
| @Before |
| public void setUp() throws Exception { |
| mNetMasks = |
| new Inet4Address[] { |
| (Inet4Address) (InetAddressUtils.parseNumericAddress("0.0.0.0")), |
| (Inet4Address) (InetAddressUtils.parseNumericAddress("255.255.255.255")), |
| (Inet4Address) (InetAddressUtils.parseNumericAddress("255.255.255.240")) |
| }; |
| mIpv4PrefixLens = new int[] {0, 32, 28}; |
| } |
| |
| private IkeConfigPayload verifyDecodeHeaderAndGetPayload( |
| IkePayload payload, int expectedConfigType) { |
| assertEquals(PAYLOAD_TYPE_CP, payload.payloadType); |
| assertFalse(payload.isCritical); |
| assertTrue(payload instanceof IkeConfigPayload); |
| |
| IkeConfigPayload configPayload = (IkeConfigPayload) payload; |
| assertEquals(expectedConfigType, configPayload.configType); |
| |
| return configPayload; |
| } |
| |
| @Test |
| public void testDecodeConfigRequest() throws Exception { |
| IkePayload payload = |
| IkePayloadFactory.getIkePayload( |
| PAYLOAD_TYPE_CP, |
| false /*isResp*/, |
| ByteBuffer.wrap(CONFIG_REQ_PAYLOAD)) |
| .first; |
| |
| IkeConfigPayload configPayload = |
| verifyDecodeHeaderAndGetPayload(payload, CONFIG_TYPE_REQUEST); |
| |
| List<ConfigAttribute> recognizedAttributeList = configPayload.recognizedAttributeList; |
| assertEquals(4, recognizedAttributeList.size()); |
| |
| ConfigAttribute att = recognizedAttributeList.get(0); |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_ADDRESS, att.attributeType); |
| assertNull(((ConfigAttributeIpv4Address) att).address); |
| |
| att = recognizedAttributeList.get(1); |
| assertEquals(CONFIG_ATTR_INTERNAL_IP6_ADDRESS, att.attributeType); |
| assertNull(((ConfigAttributeIpv6Address) att).linkAddress); |
| |
| att = recognizedAttributeList.get(2); |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_DNS, att.attributeType); |
| assertNull(((ConfigAttributeIpv4Dns) att).address); |
| |
| att = recognizedAttributeList.get(3); |
| assertEquals(CONFIG_ATTR_INTERNAL_IP6_DNS, att.attributeType); |
| assertNull(((ConfigAttributeIpv6Dns) att).address); |
| } |
| |
| @Test |
| public void testDecodeConfigResponse() throws Exception { |
| IkePayload payload = |
| IkePayloadFactory.getIkePayload( |
| PAYLOAD_TYPE_CP, |
| true /*isResp*/, |
| ByteBuffer.wrap(CONFIG_RESP_PAYLOAD)) |
| .first; |
| |
| IkeConfigPayload configPayload = |
| verifyDecodeHeaderAndGetPayload(payload, CONFIG_TYPE_REPLY); |
| |
| List<ConfigAttribute> recognizedAttributeList = configPayload.recognizedAttributeList; |
| assertEquals(3, recognizedAttributeList.size()); |
| |
| ConfigAttribute att = recognizedAttributeList.get(0); |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_ADDRESS, att.attributeType); |
| assertEquals(IPV4_ADDRESS, ((ConfigAttributeIpv4Address) att).address); |
| |
| att = recognizedAttributeList.get(1); |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_DNS, att.attributeType); |
| assertEquals(IPV4_DNS, ((ConfigAttributeIpv4Dns) att).address); |
| |
| att = recognizedAttributeList.get(2); |
| InetAddress expectedDns = InetAddress.getByName("8.8.4.4"); |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_DNS, att.attributeType); |
| assertEquals(expectedDns, ((ConfigAttributeIpv4Dns) att).address); |
| } |
| |
| @Test |
| public void testDecodeConfigRespWithTwoNetmask() throws Exception { |
| byte[] configPayloadBytes = |
| TestUtils.hexStringToByteArray(CONFIG_RESP_PAYLOAD_INVALID_ONE_HEX); |
| try { |
| IkePayloadFactory.getIkePayload( |
| PAYLOAD_TYPE_CP, true /*isResp*/, ByteBuffer.wrap(configPayloadBytes)); |
| fail("Expected to fail because more than on netmask found"); |
| } catch (InvalidSyntaxException expected) { |
| } |
| } |
| |
| @Test |
| public void testDecodeConfigRespNetmaskFoundWithoutIpv4Addr() throws Exception { |
| byte[] configPayloadBytes = |
| TestUtils.hexStringToByteArray(CONFIG_RESP_PAYLOAD_INVALID_TWO_HEX); |
| try { |
| IkePayloadFactory.getIkePayload( |
| PAYLOAD_TYPE_CP, true /*isResp*/, ByteBuffer.wrap(configPayloadBytes)); |
| fail("Expected to fail because netmask is found without a IPv4 address"); |
| } catch (InvalidSyntaxException expected) { |
| } |
| } |
| |
| private ConfigAttribute makeMockAttribute(byte[] encodedAttribute) { |
| ConfigAttribute mockAttribute = mock(ConfigAttribute.class); |
| |
| when(mockAttribute.getAttributeLen()).thenReturn(encodedAttribute.length); |
| |
| doAnswer( |
| (invocation) -> { |
| ByteBuffer buffer = (ByteBuffer) invocation.getArguments()[0]; |
| buffer.put(encodedAttribute); |
| return null; |
| }) |
| .when(mockAttribute) |
| .encodeAttributeToByteBuffer(any(ByteBuffer.class)); |
| |
| return mockAttribute; |
| } |
| |
| @Test |
| public void testBuildAndEncodeOutboundConfig() throws Exception { |
| List<ConfigAttribute> mockAttributeList = new LinkedList<>(); |
| mockAttributeList.add(makeMockAttribute(IPV4_ADDRESS_ATTRIBUTE_WITHOUT_VALUE)); |
| mockAttributeList.add(makeMockAttribute(IPV6_ADDRESS_ATTRIBUTE_WITHOUT_VALUE)); |
| mockAttributeList.add(makeMockAttribute(IPV4_DNS_ATTRIBUTE_WITHOUT_VALUE)); |
| mockAttributeList.add(makeMockAttribute(IPV6_DNS_ATTRIBUTE_WITHOUT_VALUE)); |
| IkeConfigPayload configPayload = new IkeConfigPayload(false /*isReply*/, mockAttributeList); |
| |
| assertEquals(PAYLOAD_TYPE_CP, configPayload.payloadType); |
| assertFalse(configPayload.isCritical); |
| assertEquals(CONFIG_TYPE_REQUEST, configPayload.configType); |
| assertEquals(mockAttributeList, configPayload.recognizedAttributeList); |
| |
| ByteBuffer buffer = ByteBuffer.allocate(configPayload.getPayloadLength()); |
| configPayload.encodeToByteBuffer(PAYLOAD_TYPE_NOTIFY, buffer); |
| assertArrayEquals(CONFIG_REQ_PAYLOAD, buffer.array()); |
| } |
| |
| private void verifyBuildAndEncodeAttributeCommon( |
| ConfigAttribute attribute, int expectedAttributeType, byte[] expectedEncodedAttribute) { |
| assertEquals(expectedAttributeType, attribute.attributeType); |
| |
| ByteBuffer buffer = ByteBuffer.allocate(attribute.getAttributeLen()); |
| attribute.encodeAttributeToByteBuffer(buffer); |
| assertArrayEquals(expectedEncodedAttribute, buffer.array()); |
| } |
| |
| private void verifyEncodeIpv4AddresBaseAttribute( |
| ConfigAttrIpv4AddressBase attribute, |
| int expectedAttributeType, |
| byte[] expectedEncodedAttribute, |
| Inet4Address expectedAddress) { |
| verifyBuildAndEncodeAttributeCommon( |
| attribute, expectedAttributeType, expectedEncodedAttribute); |
| assertEquals(expectedAddress, attribute.address); |
| } |
| |
| private void verifyEncodeIpv6RangeBaseAttribute( |
| ConfigAttrIpv6AddrRangeBase attribute, |
| int expectedAttributeType, |
| byte[] expectedEncodedAttribute, |
| LinkAddress expectedLinkAddress) { |
| verifyBuildAndEncodeAttributeCommon( |
| attribute, expectedAttributeType, expectedEncodedAttribute); |
| assertEquals(expectedLinkAddress, attribute.linkAddress); |
| } |
| |
| @Test |
| public void testDecodeIpv4AddressWithValue() throws Exception { |
| ConfigAttributeIpv4Address attributeIp4Address = |
| new ConfigAttributeIpv4Address(IPV4_ADDRESS.getAddress()); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_ADDRESS, attributeIp4Address.attributeType); |
| assertEquals(IPV4_ADDRESS, attributeIp4Address.address); |
| } |
| |
| @Test |
| public void testDecodeIpv4AddressWithoutValue() throws Exception { |
| ConfigAttributeIpv4Address attributeIp4Address = |
| new ConfigAttributeIpv4Address(new byte[0]); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_ADDRESS, attributeIp4Address.attributeType); |
| assertNull(attributeIp4Address.address); |
| } |
| |
| @Test |
| public void testDecodeIpv4AddressWithInvalidValue() throws Exception { |
| byte[] invalidValue = new byte[] {1}; |
| |
| try { |
| ConfigAttributeIpv4Address attributeIp4Address = |
| new ConfigAttributeIpv4Address(invalidValue); |
| fail("Expected to fail due to invalid attribute value"); |
| } catch (InvalidSyntaxException expected) { |
| } |
| } |
| |
| @Test |
| public void testEncodeIpv4AddressWithValue() throws Exception { |
| ConfigAttributeIpv4Address attributeIp4Address = |
| new ConfigAttributeIpv4Address(IPV4_ADDRESS); |
| |
| verifyEncodeIpv4AddresBaseAttribute( |
| attributeIp4Address, |
| CONFIG_ATTR_INTERNAL_IP4_ADDRESS, |
| IPV4_ADDRESS_ATTRIBUTE_WITH_VALUE, |
| IPV4_ADDRESS); |
| } |
| |
| @Test |
| public void testEncodeIpv4AddressWithoutValue() throws Exception { |
| ConfigAttributeIpv4Address attributeIp4Address = new ConfigAttributeIpv4Address(); |
| |
| verifyEncodeIpv4AddresBaseAttribute( |
| attributeIp4Address, |
| CONFIG_ATTR_INTERNAL_IP4_ADDRESS, |
| IPV4_ADDRESS_ATTRIBUTE_WITHOUT_VALUE, |
| null /*expectedAddress*/); |
| } |
| |
| @Test |
| public void testDecodeIpv4NetmaskWithValue() throws Exception { |
| ConfigAttributeIpv4Netmask attribute = |
| new ConfigAttributeIpv4Netmask(IPV4_NETMASK.getAddress()); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_NETMASK, attribute.attributeType); |
| assertEquals(IPV4_NETMASK, attribute.address); |
| } |
| |
| @Test |
| public void testDecodeIpv4NetmaskWithoutValue() throws Exception { |
| ConfigAttributeIpv4Netmask attribute = new ConfigAttributeIpv4Netmask(new byte[0]); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_NETMASK, attribute.attributeType); |
| assertNull(attribute.address); |
| } |
| |
| @Test |
| public void testEncodeIpv4Netmask() throws Exception { |
| ConfigAttributeIpv4Netmask attribute = new ConfigAttributeIpv4Netmask(); |
| |
| verifyEncodeIpv4AddresBaseAttribute( |
| attribute, |
| CONFIG_ATTR_INTERNAL_IP4_NETMASK, |
| IPV4_NETMASK_ATTRIBUTE_WITHOUT_VALUE, |
| null /*expectedAddress*/); |
| } |
| |
| @Test |
| public void testDecodeIpv4DnsWithValue() throws Exception { |
| ConfigAttributeIpv4Dns attribute = new ConfigAttributeIpv4Dns(IPV4_DNS.getAddress()); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_DNS, attribute.attributeType); |
| assertEquals(IPV4_DNS, attribute.address); |
| } |
| |
| @Test |
| public void testDecodeIpv4DnsWithoutValue() throws Exception { |
| ConfigAttributeIpv4Dns attribute = new ConfigAttributeIpv4Dns(new byte[0]); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_DNS, attribute.attributeType); |
| assertNull(attribute.address); |
| } |
| |
| @Test |
| public void testEncodeIpv4Dns() throws Exception { |
| ConfigAttributeIpv4Dns attribute = new ConfigAttributeIpv4Dns(); |
| |
| verifyEncodeIpv4AddresBaseAttribute( |
| attribute, |
| CONFIG_ATTR_INTERNAL_IP4_DNS, |
| IPV4_DNS_ATTRIBUTE_WITHOUT_VALUE, |
| null /*expectedAddress*/); |
| } |
| |
| @Test |
| public void testDecodeIpv4DhcpWithValue() throws Exception { |
| ConfigAttributeIpv4Dhcp attribute = new ConfigAttributeIpv4Dhcp(IPV4_DHCP.getAddress()); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_DHCP, attribute.attributeType); |
| assertEquals(IPV4_DHCP, attribute.address); |
| } |
| |
| @Test |
| public void testDecodeIpv4DhcpWithoutValue() throws Exception { |
| ConfigAttributeIpv4Dhcp attribute = new ConfigAttributeIpv4Dhcp(new byte[0]); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_DHCP, attribute.attributeType); |
| assertNull(attribute.address); |
| } |
| |
| @Test |
| public void testEncodeIpv4DhcpWithValue() throws Exception { |
| ConfigAttributeIpv4Dhcp attributeIp4Dhcp = new ConfigAttributeIpv4Dhcp(IPV4_DHCP); |
| |
| verifyEncodeIpv4AddresBaseAttribute( |
| attributeIp4Dhcp, |
| CONFIG_ATTR_INTERNAL_IP4_DHCP, |
| IPV4_DHCP_ATTRIBUTE_WITH_VALUE, |
| IPV4_DHCP); |
| } |
| |
| @Test |
| public void testEncodeIpv4DhcpWithoutValue() throws Exception { |
| ConfigAttributeIpv4Dhcp attribute = new ConfigAttributeIpv4Dhcp(); |
| |
| verifyEncodeIpv4AddresBaseAttribute( |
| attribute, |
| CONFIG_ATTR_INTERNAL_IP4_DHCP, |
| IPV4_DHCP_ATTRIBUTE_WITHOUT_VALUE, |
| null /*expectedAddress*/); |
| } |
| |
| @Test |
| public void testDecodeIpv4SubnetWithValue() throws Exception { |
| ConfigAttributeIpv4Subnet attributeIp4Subnet = |
| new ConfigAttributeIpv4Subnet(IPV4_SUBNET_ATTRIBUTE_VALUE); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_SUBNET, attributeIp4Subnet.attributeType); |
| assertEquals(IPV4_LINK_ADDRESS, attributeIp4Subnet.linkAddress); |
| } |
| |
| @Test |
| public void testDecodeIpv4SubnetWithoutValue() throws Exception { |
| ConfigAttributeIpv4Subnet attributeIp4Subnet = new ConfigAttributeIpv4Subnet(new byte[0]); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP4_SUBNET, attributeIp4Subnet.attributeType); |
| assertNull(attributeIp4Subnet.linkAddress); |
| } |
| |
| @Test |
| public void testDecodeIpv4SubnetWithInvalidValue() throws Exception { |
| byte[] ipAddress = IPV4_ADDRESS.getAddress(); |
| ByteBuffer buffer = ByteBuffer.allocate(ipAddress.length * 2); |
| buffer.put(ipAddress).put(ipAddress); |
| |
| try { |
| new ConfigAttributeIpv4Subnet(buffer.array()); |
| fail("Expected to fail due to invalid netmask."); |
| } catch (InvalidSyntaxException expected) { |
| } |
| } |
| |
| @Test |
| public void testEncodeIpv4SubnetWithoutValue() throws Exception { |
| ConfigAttributeIpv4Subnet attributeIp4Subnet = new ConfigAttributeIpv4Subnet(); |
| |
| verifyBuildAndEncodeAttributeCommon( |
| attributeIp4Subnet, |
| CONFIG_ATTR_INTERNAL_IP4_SUBNET, |
| IPV4_SUBNET_ATTRIBUTE_WITHOUT_VALUE); |
| assertNull(attributeIp4Subnet.linkAddress); |
| } |
| |
| @Test |
| public void testNetmaskToPrefixLen() throws Exception { |
| for (int i = 0; i < mNetMasks.length; i++) { |
| assertEquals(mIpv4PrefixLens[i], ConfigAttribute.netmaskToPrefixLen(mNetMasks[i])); |
| } |
| } |
| |
| @Test |
| public void testPrefixToNetmaskBytes() throws Exception { |
| for (int i = 0; i < mIpv4PrefixLens.length; i++) { |
| assertArrayEquals( |
| mNetMasks[i].getAddress(), |
| ConfigAttribute.prefixToNetmaskBytes(mIpv4PrefixLens[i])); |
| } |
| } |
| |
| @Test |
| public void testDecodeIpv6AddressWithValue() throws Exception { |
| ConfigAttributeIpv6Address attributeIp6Address = |
| new ConfigAttributeIpv6Address(IPV6_ADDRESS_ATTRIBUTE_VALUE); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP6_ADDRESS, attributeIp6Address.attributeType); |
| assertEquals(IPV6_LINK_ADDRESS, attributeIp6Address.linkAddress); |
| } |
| |
| @Test |
| public void testDecodeIpv6AddressWithoutValue() throws Exception { |
| ConfigAttributeIpv6Address attributeIp6Address = |
| new ConfigAttributeIpv6Address(new byte[0]); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP6_ADDRESS, attributeIp6Address.attributeType); |
| assertNull(attributeIp6Address.linkAddress); |
| } |
| |
| @Test |
| public void testDecodeIpv6AddressWithInvalidValue() throws Exception { |
| byte[] invalidValue = new byte[] {1}; |
| |
| try { |
| ConfigAttributeIpv6Address attributeIp6Address = |
| new ConfigAttributeIpv6Address(invalidValue); |
| fail("Expected to fail due to invalid attribute value"); |
| } catch (InvalidSyntaxException expected) { |
| } |
| } |
| |
| @Test |
| public void testEncodeIpv6AddressWithValue() throws Exception { |
| ConfigAttributeIpv6Address attributeIp6Address = |
| new ConfigAttributeIpv6Address(IPV6_LINK_ADDRESS); |
| |
| verifyEncodeIpv6RangeBaseAttribute( |
| attributeIp6Address, |
| CONFIG_ATTR_INTERNAL_IP6_ADDRESS, |
| IPV6_ADDRESS_ATTRIBUTE_WITH_VALUE, |
| IPV6_LINK_ADDRESS); |
| } |
| |
| @Test |
| public void testEncodeIpv6AddressWithoutValue() throws Exception { |
| ConfigAttributeIpv6Address attributeIp6Address = new ConfigAttributeIpv6Address(); |
| |
| verifyEncodeIpv6RangeBaseAttribute( |
| attributeIp6Address, |
| CONFIG_ATTR_INTERNAL_IP6_ADDRESS, |
| IPV6_ADDRESS_ATTRIBUTE_WITHOUT_VALUE, |
| null /*expectedLinkAddress*/); |
| } |
| |
| @Test |
| public void testDecodeIpv6SubnetWithValue() throws Exception { |
| ConfigAttributeIpv6Subnet attributeIp6Subnet = |
| new ConfigAttributeIpv6Subnet(IPV6_SUBNET_ATTRIBUTE_VALUE); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP6_SUBNET, attributeIp6Subnet.attributeType); |
| assertEquals(IPV6_LINK_ADDRESS, attributeIp6Subnet.linkAddress); |
| } |
| |
| @Test |
| public void testDecodeIpv6SubnetWithoutValue() throws Exception { |
| ConfigAttributeIpv6Subnet attributeIp6Subnet = new ConfigAttributeIpv6Subnet(new byte[0]); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP6_SUBNET, attributeIp6Subnet.attributeType); |
| assertNull(attributeIp6Subnet.linkAddress); |
| } |
| |
| @Test |
| public void testEncodeIpv6SubnetWithoutValue() throws Exception { |
| ConfigAttributeIpv6Subnet attributeIp6Subnet = new ConfigAttributeIpv6Subnet(); |
| |
| verifyEncodeIpv6RangeBaseAttribute( |
| attributeIp6Subnet, |
| CONFIG_ATTR_INTERNAL_IP6_SUBNET, |
| IPV6_SUBNET_ATTRIBUTE_WITHOUT_VALUE, |
| null /*expectedLinkAddress*/); |
| } |
| |
| @Test |
| public void testDecodeIpv6DnsWithValue() throws Exception { |
| ConfigAttributeIpv6Dns attribute = new ConfigAttributeIpv6Dns(IPV6_DNS.getAddress()); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP6_DNS, attribute.attributeType); |
| assertEquals(IPV6_DNS, attribute.address); |
| } |
| |
| @Test |
| public void testDecodeIpv6DnsWithoutValue() throws Exception { |
| ConfigAttributeIpv6Dns attribute = new ConfigAttributeIpv6Dns(new byte[0]); |
| |
| assertEquals(CONFIG_ATTR_INTERNAL_IP6_DNS, attribute.attributeType); |
| assertNull(attribute.address); |
| } |
| |
| @Test |
| public void testEncodeIpv6Dns() throws Exception { |
| ConfigAttributeIpv6Dns attribute = new ConfigAttributeIpv6Dns(); |
| |
| verifyBuildAndEncodeAttributeCommon( |
| attribute, CONFIG_ATTR_INTERNAL_IP6_DNS, IPV6_DNS_ATTRIBUTE_WITHOUT_VALUE); |
| assertNull(attribute.address); |
| } |
| } |
