Merge "hotspot2: ANQP elements cleanup Part 2"

5 files changed, 514 insertions, 0 deletions

diff --git a/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/DomainNameElementTest.java b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/DomainNameElementTest.java
new file mode 100644
index 000000000..d17a7fa1d
--- /dev/null
+++ b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/DomainNameElementTest.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wifi.hotspot2.anqp;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Unit tests for {@link com.android.server.wifi.hotspot2.anqp.DomainNameElement}.
+ */
+@SmallTest
+public class DomainNameElementTest {
+    private static final String TEST_DOMAIN_NAME1 = "test1.com";
+    private static final String TEST_DOMAIN_NAME2 = "test2.com";
+
+    /**
+     * Helper function for appending a Domain Name to an output stream.
+     *
+     * @param stream Stream to write to
+     * @param domain The domain name string
+     * @throws IOException
+     */
+    private void appendDomain(ByteArrayOutputStream stream, String domain) throws IOException {
+        byte[] domainBytes = domain.getBytes(StandardCharsets.ISO_8859_1);
+        stream.write((byte) domainBytes.length);
+        stream.write(domainBytes);
+    }
+
+    /**
+     * Helper function for generating test data.
+     *
+     * @return byte[] of data
+     * @throws IOException
+     */
+    private byte[] getTestData(String[] domains) throws IOException {
+        ByteArrayOutputStream stream = new ByteArrayOutputStream();
+        for (String domain : domains) {
+            appendDomain(stream, domain);
+        }
+        return stream.toByteArray();
+    }
+
+    /**
+     * Verify that a DomainNameElement with empty domain list will be returned when parsing an
+     * empty buffer.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void parseEmptyBuffer() throws Exception {
+        assertTrue(DomainNameElement.parse(ByteBuffer.allocate(0)).getDomains().isEmpty());
+    }
+
+    /**
+     * Verify that BufferUnderflowException will be thrown when parsing a truncated buffer
+     * (missing a byte at the end).
+     *
+     * @throws Exception
+     */
+    @Test(expected = BufferUnderflowException.class)
+    public void parseTruncatedBuffer() throws Exception {
+        ByteBuffer buffer = ByteBuffer.wrap(getTestData(new String[] {TEST_DOMAIN_NAME1}));
+        buffer.limit(buffer.remaining() - 1);
+        DomainNameElement.parse(buffer);
+    }
+
+    /**
+     * Verify that a DomainNameElement with expected domain list will be returned when parsing a
+     * buffer contained valid domain name list.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void parseBufferWithValidDomainNames() throws Exception {
+        byte[] testData = getTestData(new String[] {TEST_DOMAIN_NAME1, TEST_DOMAIN_NAME2});
+        ByteBuffer buffer = ByteBuffer.wrap(testData);
+
+        // Setup expected element.
+        List<String> domainList = new ArrayList<>();
+        domainList.add(TEST_DOMAIN_NAME1);
+        domainList.add(TEST_DOMAIN_NAME2);
+        DomainNameElement expectedElement = new DomainNameElement(domainList);
+
+        assertEquals(expectedElement, DomainNameElement.parse(buffer));
+    }
+}
diff --git a/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/HSConnectionCapabilityElementTest.java b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/HSConnectionCapabilityElementTest.java
new file mode 100644
index 000000000..aef2b86d1
--- /dev/null
+++ b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/HSConnectionCapabilityElementTest.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wifi.hotspot2.anqp;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.junit.Test;
+
+import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Unit tests for {@link com.android.server.wifi.hotspot2.anqp.HSConnectionCapabilityElement}.
+ */
+@SmallTest
+public class HSConnectionCapabilityElementTest {
+    private static final ProtocolPortTuple TEST_TUPLE1 =
+            new ProtocolPortTuple(1, 2, ProtocolPortTuple.PROTO_STATUS_CLOSED);
+    private static final ProtocolPortTuple TEST_TUPLE2 =
+            new ProtocolPortTuple(3, 4, ProtocolPortTuple.PROTO_STATUS_OPEN);
+
+    /**
+     * Helper function for writing a ProtocolPortTuple into a buffer.
+     *
+     * @param buffer The buffer to write to
+     * @param tuple The tuple to write
+     */
+    private void appendProtocolPortTuple(ByteBuffer buffer, ProtocolPortTuple tuple) {
+        buffer.put((byte) tuple.getProtocol());
+        buffer.putShort((short) tuple.getPort());
+        buffer.put((byte) tuple.getStatus());
+    }
+
+    /**
+     * Helper function for generating a buffer with test data.
+     *
+     * @param tuples Tuples to put in the buffer
+     * @return {@link ByteBuffer}
+     */
+    private ByteBuffer getTestBuffer(ProtocolPortTuple[] tuples) {
+        ByteBuffer buffer = ByteBuffer.allocate(tuples.length * ProtocolPortTuple.RAW_BYTE_SIZE)
+                .order(ByteOrder.LITTLE_ENDIAN);
+        for (ProtocolPortTuple tuple : tuples) {
+            appendProtocolPortTuple(buffer, tuple);
+        }
+        buffer.position(0);
+        return buffer;
+    }
+
+    /**
+     * Verify that a HSConnectionCapabilityElement with an empty status list will be returned
+     * when parsing an empty buffer.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void parseEmptyBuffer() throws Exception {
+        HSConnectionCapabilityElement element =
+                HSConnectionCapabilityElement.parse(ByteBuffer.allocate(0));
+        assertTrue(element.getStatusList().isEmpty());
+    }
+
+    /**
+     * Verify that BufferUnderflowException will be thrown when parsing a buffer without
+     * the complete tuple data (missing status field).
+     *
+     * @throws Exception
+     */
+    @Test(expected = BufferUnderflowException.class)
+    public void parseBufferWithLessThanMinimumSize() throws Exception {
+        ByteBuffer buffer = ByteBuffer.allocate(ProtocolPortTuple.RAW_BYTE_SIZE - 1);
+        buffer.put(new byte[ProtocolPortTuple.RAW_BYTE_SIZE - 1]);
+        buffer.position(0);
+        HSConnectionCapabilityElement.parse(buffer);
+    }
+
+    /**
+     * Verify that BufferUnderflowException will be thrown when parsing a buffer that contained
+     * incomplete bytes for a tuple.
+     *
+     * @throws Exception
+     */
+    @Test(expected = BufferUnderflowException.class)
+    public void parseBufferWithIncompleteTupleBytes() throws Exception {
+        // Construct a buffer which will contained a tuple and an extra byte at the end.
+        ByteBuffer buffer = ByteBuffer.allocate(ProtocolPortTuple.RAW_BYTE_SIZE + 1);
+        appendProtocolPortTuple(buffer, TEST_TUPLE1);
+        buffer.put((byte) 0);
+        buffer.position(0);
+        HSConnectionCapabilityElement.parse(buffer);
+    }
+
+    /**
+     * Verify that the expected HSConnectionCapabilityElement is returned when parsing
+     * a buffer containing the test data.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void parseBufferWithTestData() throws Exception {
+        ByteBuffer buffer = getTestBuffer(new ProtocolPortTuple[] {TEST_TUPLE1, TEST_TUPLE2});
+
+        // Setup expected element.
+        List<ProtocolPortTuple> tupleList = new ArrayList<>();
+        tupleList.add(TEST_TUPLE1);
+        tupleList.add(TEST_TUPLE2);
+        HSConnectionCapabilityElement expected = new HSConnectionCapabilityElement(tupleList);
+
+        assertEquals(expected, HSConnectionCapabilityElement.parse(buffer));
+    }
+}
diff --git a/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/HSWanMetricsElementTest.java b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/HSWanMetricsElementTest.java
new file mode 100644
index 000000000..8c53fe3a7
--- /dev/null
+++ b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/HSWanMetricsElementTest.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wifi.hotspot2.anqp;
+
+import static org.junit.Assert.assertEquals;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.junit.Test;
+
+import java.net.ProtocolException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Unit tests for {@link com.android.server.wifi.hotspot2.anqp.HSWanMetricsElement}.
+ */
+@SmallTest
+public class HSWanMetricsElementTest {
+    private static final int TEST_LINK_STATUS = HSWanMetricsElement.LINK_STATUS_UP;
+    private static final boolean TEST_SYMMETRIC_LINK = true;
+    private static final boolean TEST_AT_CAPACITY = true;
+    private static final long TEST_DOWNLINK_SPEED = 0x1234556L;
+    private static final long TEST_UPLINK_SPEED = 0x342343L;
+    private static final int TEST_DOWNLINK_LOAD = 0x23;
+    private static final int TEST_UPLINK_LOAD = 0x45;
+    private static final int TEST_LMD = 0x2132;
+
+    /**
+     * Helper function for generating a ByteBuffer with the test data.
+     *
+     * @return {@link ByteBuffer}
+     */
+    private ByteBuffer getTestBuffer() {
+        ByteBuffer buffer = ByteBuffer.allocate(HSWanMetricsElement.EXPECTED_BUFFER_SIZE)
+                .order(ByteOrder.LITTLE_ENDIAN);
+        int wanInfo = TEST_LINK_STATUS & HSWanMetricsElement.LINK_STATUS_MASK;
+        if (TEST_SYMMETRIC_LINK) wanInfo |= HSWanMetricsElement.SYMMETRIC_LINK_MASK;
+        if (TEST_AT_CAPACITY) wanInfo |= HSWanMetricsElement.AT_CAPACITY_MASK;
+        buffer.put((byte) wanInfo);
+        buffer.putInt((int) (TEST_DOWNLINK_SPEED & 0xFFFFFFFFL));
+        buffer.putInt((int) (TEST_UPLINK_SPEED & 0xFFFFFFFFL));
+        buffer.put((byte) (TEST_DOWNLINK_LOAD & 0xFF));
+        buffer.put((byte) (TEST_UPLINK_LOAD & 0xFF));
+        buffer.putShort((short) (TEST_LMD & 0xFFFF));
+        buffer.position(0);
+        return buffer;
+    }
+
+    /**
+     * Verify that ProtocolException will be thrown when parsing an empty buffer.
+     *
+     * @throws Exception
+     */
+    @Test(expected = ProtocolException.class)
+    public void parseEmptyBuffer() throws Exception {
+        HSWanMetricsElement.parse(ByteBuffer.allocate(0));
+    }
+
+    /**
+     * Verify that ProtocolException will be thrown when a buffer with size less than the
+     * expected.
+     *
+     * @throws Exception
+     */
+    @Test(expected = ProtocolException.class)
+    public void parseBufferWithLessThanExpectedSize() throws Exception {
+        ByteBuffer buffer = ByteBuffer.allocate(HSWanMetricsElement.EXPECTED_BUFFER_SIZE - 1);
+        buffer.put(new byte[HSWanMetricsElement.EXPECTED_BUFFER_SIZE - 1]);
+        buffer.position(0);
+        HSWanMetricsElement.parse(buffer);
+    }
+
+    /**
+     * Verify that ProtocolException will be thrown when a buffer with size more than the
+     * expected.
+     *
+     * @throws Exception
+     */
+    @Test(expected = ProtocolException.class)
+    public void parseBufferWithMoreThanExpectedSize() throws Exception {
+        ByteBuffer buffer = ByteBuffer.allocate(HSWanMetricsElement.EXPECTED_BUFFER_SIZE + 1);
+        buffer.put(new byte[HSWanMetricsElement.EXPECTED_BUFFER_SIZE + 1]);
+        buffer.position(0);
+        HSWanMetricsElement.parse(buffer);
+    }
+
+    /**
+     * Verify that the expected HSWanMetricsElement is returned when parsing
+     * a buffer containing the test data.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void parseBufferWithTestData() throws Exception {
+        ByteBuffer buffer = getTestBuffer();
+        HSWanMetricsElement expectedElement = new HSWanMetricsElement(
+                TEST_LINK_STATUS, TEST_SYMMETRIC_LINK, TEST_AT_CAPACITY,
+                TEST_DOWNLINK_SPEED, TEST_UPLINK_SPEED, TEST_DOWNLINK_LOAD,
+                TEST_UPLINK_LOAD, TEST_LMD);
+        assertEquals(expectedElement, HSWanMetricsElement.parse(buffer));
+    }
+}
diff --git a/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/ProtocolPortTupleTest.java b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/ProtocolPortTupleTest.java
new file mode 100644
index 000000000..b4bfaf1c5
--- /dev/null
+++ b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/ProtocolPortTupleTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wifi.hotspot2.anqp;
+
+import static org.junit.Assert.assertEquals;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.junit.Test;
+
+import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Unit tests for {@link com.android.server.wifi.hotspot2.anqp.ProtocolPortTuple}.
+ */
+@SmallTest
+public class ProtocolPortTupleTest {
+    private static final int TEST_PROTOCOL = 1;
+    private static final int TEST_PORT = 2;
+    private static final int TEST_STATUS = ProtocolPortTuple.PROTO_STATUS_CLOSED;
+
+    /**
+     * Helper function for generating a buffer with test data.
+     *
+     * @param protocol Protocol value
+     * @param port Port value
+     * @param status Status value
+     * @return {@link ByteBuffer}
+     */
+    private ByteBuffer getTestBuffer(int protocol, int port, int status) {
+        ByteBuffer buffer = ByteBuffer.allocate(ProtocolPortTuple.RAW_BYTE_SIZE)
+                .order(ByteOrder.LITTLE_ENDIAN);
+        buffer.put((byte) protocol);
+        buffer.putShort((short) port);
+        buffer.put((byte) status);
+        buffer.position(0);
+        return buffer;
+    }
+
+    /**
+     * Verify that BufferUnderflowException will be thrown when parsing an empty buffer.
+     *
+     * @throws Exception
+     */
+    @Test(expected = BufferUnderflowException.class)
+    public void parseEmptyBuffer() throws Exception {
+        ProtocolPortTuple.parse(ByteBuffer.allocate(0));
+    }
+
+    /**
+     * Verify that BufferUnderflowException will be thrown when parsing a buffer without
+     * the complete tuple data (missing status field).
+     *
+     * @throws Exception
+     */
+    @Test(expected = BufferUnderflowException.class)
+    public void parseBufferWithIncompleteData() throws Exception {
+        ByteBuffer buffer = ByteBuffer.allocate(ProtocolPortTuple.RAW_BYTE_SIZE - 1);
+        buffer.put(new byte[ProtocolPortTuple.RAW_BYTE_SIZE - 1]);
+        buffer.position(0);
+        ProtocolPortTuple.parse(buffer);
+    }
+
+    /**
+     * Verify that the expected ProtocolPortTuple is returned when parsing a buffer contained
+     * the test data.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void parseBufferWithTestData() throws Exception {
+        ByteBuffer buffer = getTestBuffer(TEST_PROTOCOL, TEST_PORT, TEST_STATUS);
+        ProtocolPortTuple expected = new ProtocolPortTuple(TEST_PROTOCOL, TEST_PORT, TEST_STATUS);
+        assertEquals(expected, ProtocolPortTuple.parse(buffer));
+    }
+}
diff --git a/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/RawByteElementTest.java b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/RawByteElementTest.java
new file mode 100644
index 000000000..e61797a87
--- /dev/null
+++ b/tests/wifitests/src/com/android/server/wifi/hotspot2/anqp/RawByteElementTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wifi.hotspot2.anqp;
+
+import static org.junit.Assert.assertEquals;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.junit.Test;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Unit tests for {@link com.android.server.wifi.hotspot2.anqp.RawByteElement}.
+ */
+@SmallTest
+public class RawByteElementTest {
+    private static final Constants.ANQPElementType TEST_ELEMENT_ID =
+            Constants.ANQPElementType.HSOSUProviders;
+
+    /**
+     * Verify that a RawByteElement with an empty payload will be returned when parsing
+     * an empty buffer.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void parseEmptyBuffer() throws Exception {
+        byte[] data = new byte[0];
+        RawByteElement actual = RawByteElement.parse(TEST_ELEMENT_ID, ByteBuffer.wrap(data));
+        RawByteElement expected = new RawByteElement(TEST_ELEMENT_ID, data);
+        assertEquals(expected, actual);
+    }
+
+    /**
+     * Verify that the expected RawByteElement will be returned when parsing a non-empty
+     * buffer.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void parseNonEmptyBuffer() throws Exception {
+        byte[] data = new byte[10];
+        RawByteElement actual = RawByteElement.parse(TEST_ELEMENT_ID, ByteBuffer.wrap(data));
+        RawByteElement expected = new RawByteElement(TEST_ELEMENT_ID, data);
+        assertEquals(expected, actual);
+    }
+}