mockito-target-minus-junit4 \
frameworks-base-testutils \
-LOCAL_JAVA_LIBRARIES := \
- android.test.runner \
+LOCAL_JNI_SHARED_LIBRARIES += libframeworkslowpantestsjni
+LOCAL_JNI_SHARED_LIBRARIES += libandroid_net_lowpan
+LOCAL_JNI_SHARED_LIBRARIES += \
+ libbacktrace \
+ libbase \
+ libbinder \
+ libc++ \
+ libcutils \
+ liblog \
+ liblzma \
+ libnativehelper \
+ libnetdaidl \
+ libui \
+ libunwind \
+ libutils \
+ libvndksupport \
+ libcrypto \
+ libhidl-gen-utils \
+ libhidlbase \
+ libhidltransport \
+ libpackagelistparser \
+ libpcre2 \
+ libselinux \
+ libtinyxml2 \
+ libvintf \
+ libhwbinder \
+ android.hidl.token@1.0
+
+LOCAL_JAVA_LIBRARIES := android.test.runner
LOCAL_PACKAGE_NAME := FrameworksLowpanApiTests
LOCAL_COMPATIBILITY_SUITE := device-tests
LOCAL_CERTIFICATE := platform
LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
include $(BUILD_PACKAGE)
+
+#########################################################################
+# Build JNI Shared Library
+#########################################################################
+
+LOCAL_PATH:= $(LOCAL_PATH)/jni
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_CFLAGS := -Wall -Wextra -Werror
+
+LOCAL_SRC_FILES := $(call all-cpp-files-under)
+
+LOCAL_SHARED_LIBRARIES += libandroid_net_lowpan
+LOCAL_SHARED_LIBRARIES += libbinder
+LOCAL_SHARED_LIBRARIES += liblog
+
+LOCAL_MODULE := libframeworkslowpantestsjni
+
+include $(BUILD_SHARED_LIBRARY)
--- /dev/null
+/*
+ * Copyright (C) 2017 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 android.net.lowpan;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
+
+import android.os.Parcel;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class LowpanBeaconInfoTest {
+
+ static {
+ System.loadLibrary("frameworkslowpantestsjni");
+ }
+
+ private static native byte[] readAndWriteNative(byte[] inParcel);
+
+ public void testNativeParcelUnparcel(LowpanBeaconInfo original) {
+ byte[] inParcel = marshall(original);
+ byte[] outParcel = readAndWriteNative(inParcel);
+ LowpanBeaconInfo roundTrip = unmarshall(outParcel);
+
+ assertEquals(original, roundTrip);
+ assertArrayEquals(inParcel, outParcel);
+ }
+
+ @Test
+ public void testNativeParcelUnparcel() {
+ testNativeParcelUnparcel(
+ new LowpanBeaconInfo.Builder()
+ .setName("TestNet1")
+ .setPanid(0x1234)
+ .setXpanid(
+ new byte[] {
+ (byte) 0x00,
+ (byte) 0x11,
+ (byte) 0x22,
+ (byte) 0x33,
+ (byte) 0x44,
+ (byte) 0x55,
+ (byte) 0x66,
+ (byte) 0x77
+ })
+ .setType(LowpanInterface.NETWORK_TYPE_THREAD_V1)
+ .setChannel(15)
+ .setBeaconAddress(
+ new byte[] {
+ (byte) 0x88,
+ (byte) 0x99,
+ (byte) 0xaa,
+ (byte) 0xbb,
+ (byte) 0xcc,
+ (byte) 0xdd,
+ (byte) 0xee,
+ (byte) 0xff
+ })
+ .build());
+
+ testNativeParcelUnparcel(
+ new LowpanBeaconInfo.Builder()
+ .setName("TestNet2")
+ .setPanid(0x5678)
+ .setXpanid(
+ new byte[] {
+ (byte) 0x88,
+ (byte) 0x99,
+ (byte) 0xaa,
+ (byte) 0xbb,
+ (byte) 0xcc,
+ (byte) 0xdd,
+ (byte) 0xee,
+ (byte) 0xff
+ })
+ .setType("bork-bork-bork")
+ .setChannel(16)
+ .setBeaconAddress(
+ new byte[] {
+ (byte) 0x00,
+ (byte) 0x11,
+ (byte) 0x22,
+ (byte) 0x33,
+ (byte) 0x44,
+ (byte) 0x55,
+ (byte) 0x66,
+ (byte) 0x77
+ })
+ .setFlag(LowpanBeaconInfo.FLAG_CAN_ASSIST)
+ .build());
+ }
+
+ /**
+ * Write a {@link LowpanBeaconInfo} into an empty parcel and return the underlying data.
+ *
+ * @see unmarshall(byte[])
+ */
+ private static byte[] marshall(LowpanBeaconInfo addr) {
+ Parcel p = Parcel.obtain();
+ addr.writeToParcel(p, /* flags */ 0);
+ p.setDataPosition(0);
+ return p.marshall();
+ }
+
+ /**
+ * Read raw bytes into a parcel, and read a {@link LowpanBeaconInfo} back out of them.
+ *
+ * @see marshall(LowpanBeaconInfo)
+ */
+ private static LowpanBeaconInfo unmarshall(byte[] data) {
+ Parcel p = Parcel.obtain();
+ p.unmarshall(data, 0, data.length);
+ p.setDataPosition(0);
+ return LowpanBeaconInfo.CREATOR.createFromParcel(p);
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2017 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 android.net.lowpan;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
+
+import android.os.Parcel;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class LowpanChannelInfoTest {
+
+ static {
+ System.loadLibrary("frameworkslowpantestsjni");
+ }
+
+ private static native byte[] readAndWriteNative(byte[] inParcel);
+
+ public void testNativeParcelUnparcel(LowpanChannelInfo original) {
+ byte[] inParcel = marshall(original);
+ byte[] outParcel = readAndWriteNative(inParcel);
+ LowpanChannelInfo roundTrip = unmarshall(outParcel);
+
+ assertEquals(original, roundTrip);
+ assertArrayEquals(inParcel, outParcel);
+ }
+
+ @Test
+ public void testNativeParcelUnparcel() {
+ int i;
+ for (i = 1; i < 26; i++) {
+ testNativeParcelUnparcel(LowpanChannelInfo.getChannelInfoForIeee802154Page0(i));
+ }
+ }
+
+ /**
+ * Write a {@link LowpanChannelInfo} into an empty parcel and return the underlying data.
+ *
+ * @see unmarshall(byte[])
+ */
+ private static byte[] marshall(LowpanChannelInfo addr) {
+ Parcel p = Parcel.obtain();
+ addr.writeToParcel(p, /* flags */ 0);
+ p.setDataPosition(0);
+ return p.marshall();
+ }
+
+ /**
+ * Read raw bytes into a parcel, and read a {@link LowpanChannelInfo} back out of them.
+ *
+ * @see marshall(LowpanChannelInfo)
+ */
+ private static LowpanChannelInfo unmarshall(byte[] data) {
+ Parcel p = Parcel.obtain();
+ p.unmarshall(data, 0, data.length);
+ p.setDataPosition(0);
+ return LowpanChannelInfo.CREATOR.createFromParcel(p);
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2017 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 android.net.lowpan;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
+
+import android.os.Parcel;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class LowpanCredentialTest {
+
+ static {
+ System.loadLibrary("frameworkslowpantestsjni");
+ }
+
+ private static native byte[] readAndWriteNative(byte[] inParcel);
+
+ public void testNativeParcelUnparcel(LowpanCredential original) {
+ byte[] inParcel = marshall(original);
+ byte[] outParcel = readAndWriteNative(inParcel);
+ LowpanCredential roundTrip = unmarshall(outParcel);
+
+ assertEquals(original, roundTrip);
+ assertArrayEquals(inParcel, outParcel);
+ }
+
+ @Test
+ public void testNativeParcelUnparcel() {
+ testNativeParcelUnparcel(
+ LowpanCredential.createMasterKey(
+ new byte[] {
+ (byte) 0x88,
+ (byte) 0x99,
+ (byte) 0xaa,
+ (byte) 0xbb,
+ (byte) 0xcc,
+ (byte) 0xdd,
+ (byte) 0xee,
+ (byte) 0xff
+ }));
+ testNativeParcelUnparcel(
+ LowpanCredential.createMasterKey(
+ new byte[] {
+ (byte) 0x88, (byte) 0x99, (byte) 0xaa, (byte) 0xbb, (byte) 0xcc
+ },
+ 15));
+ }
+
+ /**
+ * Write a {@link LowpanCredential} into an empty parcel and return the underlying data.
+ *
+ * @see unmarshall(byte[])
+ */
+ private static byte[] marshall(LowpanCredential addr) {
+ Parcel p = Parcel.obtain();
+ addr.writeToParcel(p, /* flags */ 0);
+ p.setDataPosition(0);
+ return p.marshall();
+ }
+
+ /**
+ * Read raw bytes into a parcel, and read a {@link LowpanCredential} back out of them.
+ *
+ * @see marshall(LowpanCredential)
+ */
+ private static LowpanCredential unmarshall(byte[] data) {
+ Parcel p = Parcel.obtain();
+ p.unmarshall(data, 0, data.length);
+ p.setDataPosition(0);
+ return LowpanCredential.CREATOR.createFromParcel(p);
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2017 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 android.net.lowpan;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import android.os.Parcel;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class LowpanIdentityTest {
+
+ static {
+ System.loadLibrary("frameworkslowpantestsjni");
+ }
+
+ private static native byte[] readAndWriteNative(byte[] inParcel);
+
+ public void testNativeParcelUnparcel(LowpanIdentity original) {
+ byte[] inParcel = marshall(original);
+ byte[] outParcel = readAndWriteNative(inParcel);
+ LowpanIdentity roundTrip = unmarshall(outParcel);
+
+ assertEquals(original, roundTrip);
+ assertEquals(original.hashCode(), roundTrip.hashCode());
+ assertEquals(original.getName(), roundTrip.getName());
+ assertArrayEquals(inParcel, outParcel);
+ }
+
+ @Test
+ public void testNativeParcelUnparcel1() {
+ testNativeParcelUnparcel(
+ new LowpanIdentity.Builder()
+ .setName("TestNet1")
+ .setPanid(0x1234)
+ .setXpanid(
+ new byte[] {
+ (byte) 0x00,
+ (byte) 0x11,
+ (byte) 0x22,
+ (byte) 0x33,
+ (byte) 0x44,
+ (byte) 0x55,
+ (byte) 0x66,
+ (byte) 0x77
+ })
+ .setType(LowpanInterface.NETWORK_TYPE_THREAD_V1)
+ .setChannel(15)
+ .build());
+ }
+
+ @Test
+ public void testNativeParcelUnparcel2() {
+ testNativeParcelUnparcel(
+ new LowpanIdentity.Builder()
+ .setName("TestNet2")
+ .setPanid(0x5678)
+ .setXpanid(
+ new byte[] {
+ (byte) 0x88,
+ (byte) 0x99,
+ (byte) 0xaa,
+ (byte) 0xbb,
+ (byte) 0xcc,
+ (byte) 0xdd,
+ (byte) 0xee,
+ (byte) 0xff
+ })
+ .setType("bork-bork-bork")
+ .setChannel(16)
+ .build());
+ }
+
+ @Test
+ public void testNativeParcelUnparcel3() {
+ testNativeParcelUnparcel(new LowpanIdentity.Builder().setName("TestNet3").build());
+ }
+
+ @Test
+ public void testNativeParcelUnparcel4() {
+ testNativeParcelUnparcel(new LowpanIdentity.Builder().build());
+ }
+
+ @Test
+ public void testNativeParcelUnparcel5() {
+ testNativeParcelUnparcel(
+ new LowpanIdentity.Builder()
+ .setRawName(
+ new byte[] {
+ (byte) 0x66,
+ (byte) 0x6F,
+ (byte) 0x6F,
+ (byte) 0xC2,
+ (byte) 0xAD,
+ (byte) 0xCD,
+ (byte) 0x8F,
+ (byte) 0xE1,
+ (byte) 0xA0,
+ (byte) 0x86,
+ (byte) 0xE1,
+ (byte) 0xA0,
+ (byte) 0x8B
+ })
+ .build());
+ }
+
+ @Test
+ public void testStringPrep1() {
+ LowpanIdentity identity =
+ new LowpanIdentity.Builder()
+ .setRawName(
+ new byte[] {
+ (byte) 0x66,
+ (byte) 0x6F,
+ (byte) 0x6F,
+ (byte) 0x20,
+ (byte) 0xC2,
+ (byte) 0xAD,
+ (byte) 0xCD,
+ (byte) 0x8F,
+ (byte) 0xE1,
+ (byte) 0xA0,
+ (byte) 0x86,
+ (byte) 0xE1,
+ (byte) 0xA0,
+ (byte) 0x8B
+ })
+ .build();
+
+ assertFalse(identity.isNameValid());
+ }
+
+ @Test
+ public void testStringPrep2() {
+ LowpanIdentity identity =
+ new LowpanIdentity.Builder()
+ .setRawName(
+ new byte[] {
+ (byte) 0x66, (byte) 0x6F, (byte) 0x6F, (byte) 0x20, (byte) 0x6F
+ })
+ .build();
+
+ assertEquals("foo o", identity.getName());
+ assertTrue(identity.isNameValid());
+ }
+
+ @Test
+ public void testStringPrep3() {
+ LowpanIdentity identity = new LowpanIdentity.Builder().setName("foo o").build();
+
+ assertTrue(identity.isNameValid());
+ assertEquals("foo o", identity.getName());
+ }
+
+ /**
+ * Write a {@link LowpanIdentity} into an empty parcel and return the underlying data.
+ *
+ * @see unmarshall(byte[])
+ */
+ private static byte[] marshall(LowpanIdentity addr) {
+ Parcel p = Parcel.obtain();
+ addr.writeToParcel(p, /* flags */ 0);
+ p.setDataPosition(0);
+ return p.marshall();
+ }
+
+ /**
+ * Read raw bytes into a parcel, and read a {@link LowpanIdentity} back out of them.
+ *
+ * @see marshall(LowpanIdentity)
+ */
+ private static LowpanIdentity unmarshall(byte[] data) {
+ Parcel p = Parcel.obtain();
+ p.unmarshall(data, 0, data.length);
+ p.setDataPosition(0);
+ return LowpanIdentity.CREATOR.createFromParcel(p);
+ }
+}
package android.net.lowpan;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.*;
import android.content.Context;
import android.os.test.TestLooper;
import android.support.test.runner.AndroidJUnit4;
import android.test.suitebuilder.annotation.SmallTest;
+import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import java.util.Map;
-import java.util.HashMap;
/** Unit tests for android.net.lowpan.LowpanInterface. */
@RunWith(AndroidJUnit4.class)
when(mLowpanInterfaceService.getName()).thenReturn("wpan0");
when(mLowpanInterfaceService.asBinder()).thenReturn(mLowpanInterfaceBinder);
- mLowpanInterface = new LowpanInterface(mContext, mLowpanInterfaceService, mTestLooper.getLooper());
+ mLowpanInterface =
+ new LowpanInterface(mContext, mLowpanInterfaceService, mTestLooper.getLooper());
}
@Test
return listener instanceof ILowpanInterfaceListener;
}));
- // Build a changed property map
- Map<String, Object> changedProperties = new HashMap<>();
- LowpanProperties.KEY_INTERFACE_STATE.putInMap(changedProperties, LowpanInterface.STATE_OFFLINE);
-
// Change some properties
- mInterfaceListener.onPropertiesChanged(changedProperties);
+ mInterfaceListener.onStateChanged(LowpanInterface.STATE_OFFLINE);
mTestLooper.dispatchAll();
// Verify that the property was changed
package android.net.lowpan;
-import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.*;
import android.content.Context;
--- /dev/null
+/*
+ * Copyright (C) 2017 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 android.net.lowpan;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
+
+import android.os.Parcel;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class LowpanProvisionTest {
+
+ static {
+ System.loadLibrary("frameworkslowpantestsjni");
+ }
+
+ private static native byte[] readAndWriteNative(byte[] inParcel);
+
+ public void testNativeParcelUnparcel(LowpanProvision original) {
+ byte[] inParcel = marshall(original);
+ byte[] outParcel = readAndWriteNative(inParcel);
+ LowpanProvision roundTrip = unmarshall(outParcel);
+
+ assertEquals(original, roundTrip);
+ assertArrayEquals(inParcel, outParcel);
+ }
+
+ @Test
+ public void testNativeParcelUnparcel() {
+ testNativeParcelUnparcel(
+ new LowpanProvision.Builder()
+ .setLowpanIdentity(
+ new LowpanIdentity.Builder()
+ .setName("TestNet1")
+ .setPanid(0x1234)
+ .setXpanid(
+ new byte[] {
+ (byte) 0x00,
+ (byte) 0x11,
+ (byte) 0x22,
+ (byte) 0x33,
+ (byte) 0x44,
+ (byte) 0x55,
+ (byte) 0x66,
+ (byte) 0x77
+ })
+ .setType(LowpanInterface.NETWORK_TYPE_THREAD_V1)
+ .setChannel(15)
+ .build())
+ .build());
+ testNativeParcelUnparcel(
+ new LowpanProvision.Builder()
+ .setLowpanIdentity(
+ new LowpanIdentity.Builder()
+ .setName("TestNet2")
+ .setPanid(0x5678)
+ .setXpanid(
+ new byte[] {
+ (byte) 0x88,
+ (byte) 0x99,
+ (byte) 0xaa,
+ (byte) 0xbb,
+ (byte) 0xcc,
+ (byte) 0xdd,
+ (byte) 0xee,
+ (byte) 0xff
+ })
+ .setType("bork-bork-bork")
+ .setChannel(16)
+ .build())
+ .setLowpanCredential(
+ LowpanCredential.createMasterKey(
+ new byte[] {
+ (byte) 0x88,
+ (byte) 0x99,
+ (byte) 0xaa,
+ (byte) 0xbb,
+ (byte) 0xcc,
+ (byte) 0xdd,
+ (byte) 0xee,
+ (byte) 0xff
+ }))
+ .build());
+ }
+
+ /**
+ * Write a {@link LowpanProvision} into an empty parcel and return the underlying data.
+ *
+ * @see unmarshall(byte[])
+ */
+ private static byte[] marshall(LowpanProvision addr) {
+ Parcel p = Parcel.obtain();
+ addr.writeToParcel(p, /* flags */ 0);
+ p.setDataPosition(0);
+ return p.marshall();
+ }
+
+ /**
+ * Read raw bytes into a parcel, and read a {@link LowpanProvision} back out of them.
+ *
+ * @see marshall(LowpanProvision)
+ */
+ private static LowpanProvision unmarshall(byte[] data) {
+ Parcel p = Parcel.obtain();
+ p.unmarshall(data, 0, data.length);
+ p.setDataPosition(0);
+ return LowpanProvision.CREATOR.createFromParcel(p);
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include <memory>
+
+#include <binder/Parcel.h>
+
+#include "LowpanBeaconInfoTest.h"
+
+using android::net::lowpan::LowpanBeaconInfo;
+
+/**
+ * Reads exactly one LowpanBeaconInfo from 'parcelData' assuming that it is a Parcel. Any bytes afterward
+ * are ignored.
+ */
+static LowpanBeaconInfo unmarshall(JNIEnv* env, jbyteArray parcelData) {
+ const int length = env->GetArrayLength(parcelData);
+
+ std::unique_ptr<uint8_t> bytes(new uint8_t[length]);
+ env->GetByteArrayRegion(parcelData, 0, length, reinterpret_cast<jbyte*>(bytes.get()));
+
+ android::Parcel p;
+ p.setData(bytes.get(), length);
+
+ LowpanBeaconInfo value;
+ value.readFromParcel(&p);
+ return value;
+}
+
+/**
+ * Creates a Java byte[] array and writes the contents of 'addr' to it as a Parcel containing
+ * exactly one object.
+ *
+ * Every LowpanBeaconInfo maps to a unique parcel object, so both 'marshall(e, unmarshall(e, x))' and
+ * 'unmarshall(e, marshall(e, x))' should be fixed points.
+ */
+static jbyteArray marshall(JNIEnv* env, const LowpanBeaconInfo& addr) {
+ android::Parcel p;
+ addr.writeToParcel(&p);
+ const int length = p.dataSize();
+
+ jbyteArray parcelData = env->NewByteArray(length);
+ env->SetByteArrayRegion(parcelData, 0, length, reinterpret_cast<const jbyte*>(p.data()));
+
+ return parcelData;
+}
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanBeaconInfoTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel) {
+ const LowpanBeaconInfo value = unmarshall(env, inParcel);
+ return marshall(env, value);
+}
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef _ANDROID_NET_LOWPANBEACONINFOTEST_H_
+#define _ANDROID_NET_LOWPANBEACONINFOTEST_H_
+
+#include <jni.h>
+#include <android/net/lowpan/LowpanBeaconInfo.h>
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanBeaconInfoTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel);
+
+#endif // _ANDROID_NET_LOWPANBEACONINFOTEST_H_
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include <memory>
+
+#include <binder/Parcel.h>
+
+#include "LowpanChannelInfoTest.h"
+
+using android::net::lowpan::LowpanChannelInfo;
+
+/**
+ * Reads exactly one LowpanChannelInfo from 'parcelData' assuming that it is a Parcel. Any bytes afterward
+ * are ignored.
+ */
+static LowpanChannelInfo unmarshall(JNIEnv* env, jbyteArray parcelData) {
+ const int length = env->GetArrayLength(parcelData);
+
+ std::unique_ptr<uint8_t> bytes(new uint8_t[length]);
+ env->GetByteArrayRegion(parcelData, 0, length, reinterpret_cast<jbyte*>(bytes.get()));
+
+ android::Parcel p;
+ p.setData(bytes.get(), length);
+
+ LowpanChannelInfo value;
+ value.readFromParcel(&p);
+ return value;
+}
+
+/**
+ * Creates a Java byte[] array and writes the contents of 'addr' to it as a Parcel containing
+ * exactly one object.
+ *
+ * Every LowpanChannelInfo maps to a unique parcel object, so both 'marshall(e, unmarshall(e, x))' and
+ * 'unmarshall(e, marshall(e, x))' should be fixed points.
+ */
+static jbyteArray marshall(JNIEnv* env, const LowpanChannelInfo& addr) {
+ android::Parcel p;
+ addr.writeToParcel(&p);
+ const int length = p.dataSize();
+
+ jbyteArray parcelData = env->NewByteArray(length);
+ env->SetByteArrayRegion(parcelData, 0, length, reinterpret_cast<const jbyte*>(p.data()));
+
+ return parcelData;
+}
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanChannelInfoTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel) {
+ const LowpanChannelInfo value = unmarshall(env, inParcel);
+ return marshall(env, value);
+}
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef _ANDROID_NET_LOWPANCHANNELINFOTEST_H_
+#define _ANDROID_NET_LOWPANCHANNELINFOTEST_H_
+
+#include <jni.h>
+#include <android/net/lowpan/LowpanChannelInfo.h>
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanChannelInfoTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel);
+
+#endif // _ANDROID_NET_LOWPANCHANNELINFOTEST_H_
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include <memory>
+
+#include <binder/Parcel.h>
+
+#include "LowpanCredentialTest.h"
+
+using android::net::lowpan::LowpanCredential;
+
+/**
+ * Reads exactly one LowpanCredential from 'parcelData' assuming that it is a Parcel. Any bytes afterward
+ * are ignored.
+ */
+static LowpanCredential unmarshall(JNIEnv* env, jbyteArray parcelData) {
+ const int length = env->GetArrayLength(parcelData);
+
+ std::unique_ptr<uint8_t> bytes(new uint8_t[length]);
+ env->GetByteArrayRegion(parcelData, 0, length, reinterpret_cast<jbyte*>(bytes.get()));
+
+ android::Parcel p;
+ p.setData(bytes.get(), length);
+
+ LowpanCredential value;
+ value.readFromParcel(&p);
+ return value;
+}
+
+/**
+ * Creates a Java byte[] array and writes the contents of 'addr' to it as a Parcel containing
+ * exactly one object.
+ *
+ * Every LowpanCredential maps to a unique parcel object, so both 'marshall(e, unmarshall(e, x))' and
+ * 'unmarshall(e, marshall(e, x))' should be fixed points.
+ */
+static jbyteArray marshall(JNIEnv* env, const LowpanCredential& addr) {
+ android::Parcel p;
+ addr.writeToParcel(&p);
+ const int length = p.dataSize();
+
+ jbyteArray parcelData = env->NewByteArray(length);
+ env->SetByteArrayRegion(parcelData, 0, length, reinterpret_cast<const jbyte*>(p.data()));
+
+ return parcelData;
+}
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanCredentialTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel) {
+ const LowpanCredential value = unmarshall(env, inParcel);
+ return marshall(env, value);
+}
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef _ANDROID_NET_LOWPANCREDENTIALTEST_H_
+#define _ANDROID_NET_LOWPANCREDENTIALTEST_H_
+
+#include <jni.h>
+#include <android/net/lowpan/LowpanCredential.h>
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanCredentialTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel);
+
+#endif // _ANDROID_NET_LOWPANCREDENTIALTEST_H_
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include <memory>
+
+#include <binder/Parcel.h>
+
+#include "LowpanIdentityTest.h"
+
+using android::net::lowpan::LowpanIdentity;
+
+/**
+ * Reads exactly one LowpanIdentity from 'parcelData' assuming that it is a Parcel. Any bytes afterward
+ * are ignored.
+ */
+static LowpanIdentity unmarshall(JNIEnv* env, jbyteArray parcelData) {
+ const int length = env->GetArrayLength(parcelData);
+
+ std::unique_ptr<uint8_t> bytes(new uint8_t[length]);
+ env->GetByteArrayRegion(parcelData, 0, length, reinterpret_cast<jbyte*>(bytes.get()));
+
+ android::Parcel p;
+ p.setData(bytes.get(), length);
+
+ LowpanIdentity value;
+ value.readFromParcel(&p);
+ return value;
+}
+
+/**
+ * Creates a Java byte[] array and writes the contents of 'addr' to it as a Parcel containing
+ * exactly one object.
+ *
+ * Every LowpanIdentity maps to a unique parcel object, so both 'marshall(e, unmarshall(e, x))' and
+ * 'unmarshall(e, marshall(e, x))' should be fixed points.
+ */
+static jbyteArray marshall(JNIEnv* env, const LowpanIdentity& addr) {
+ android::Parcel p;
+ addr.writeToParcel(&p);
+ const int length = p.dataSize();
+
+ jbyteArray parcelData = env->NewByteArray(length);
+ env->SetByteArrayRegion(parcelData, 0, length, reinterpret_cast<const jbyte*>(p.data()));
+
+ return parcelData;
+}
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanIdentityTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel) {
+ const LowpanIdentity value = unmarshall(env, inParcel);
+ return marshall(env, value);
+}
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef _ANDROID_NET_LOWPANIDENTITYTEST_H_
+#define _ANDROID_NET_LOWPANIDENTITYTEST_H_
+
+#include <jni.h>
+#include <android/net/lowpan/LowpanIdentity.h>
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanIdentityTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel);
+
+#endif // _ANDROID_NET_LOWPANIDENTITYTEST_H_
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include <memory>
+
+#include <binder/Parcel.h>
+
+#include "LowpanProvisionTest.h"
+
+using android::net::lowpan::LowpanProvision;
+
+/**
+ * Reads exactly one LowpanProvision from 'parcelData' assuming that it is a Parcel. Any bytes afterward
+ * are ignored.
+ */
+static LowpanProvision unmarshall(JNIEnv* env, jbyteArray parcelData) {
+ const int length = env->GetArrayLength(parcelData);
+
+ std::unique_ptr<uint8_t> bytes(new uint8_t[length]);
+ env->GetByteArrayRegion(parcelData, 0, length, reinterpret_cast<jbyte*>(bytes.get()));
+
+ android::Parcel p;
+ p.setData(bytes.get(), length);
+
+ LowpanProvision value;
+ value.readFromParcel(&p);
+ return value;
+}
+
+/**
+ * Creates a Java byte[] array and writes the contents of 'addr' to it as a Parcel containing
+ * exactly one object.
+ *
+ * Every LowpanProvision maps to a unique parcel object, so both 'marshall(e, unmarshall(e, x))' and
+ * 'unmarshall(e, marshall(e, x))' should be fixed points.
+ */
+static jbyteArray marshall(JNIEnv* env, const LowpanProvision& addr) {
+ android::Parcel p;
+ addr.writeToParcel(&p);
+ const int length = p.dataSize();
+
+ jbyteArray parcelData = env->NewByteArray(length);
+ env->SetByteArrayRegion(parcelData, 0, length, reinterpret_cast<const jbyte*>(p.data()));
+
+ return parcelData;
+}
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanProvisionTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel) {
+ const LowpanProvision value = unmarshall(env, inParcel);
+ return marshall(env, value);
+}
--- /dev/null
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef _ANDROID_NET_LOWPANPROVISIONTEST_H_
+#define _ANDROID_NET_LOWPANPROVISIONTEST_H_
+
+#include <jni.h>
+#include <android/net/lowpan/LowpanProvision.h>
+
+extern "C"
+JNIEXPORT jbyteArray Java_android_net_lowpan_LowpanProvisionTest_readAndWriteNative(JNIEnv* env, jclass,
+ jbyteArray inParcel);
+
+#endif // _ANDROID_NET_LOWPANPROVISIONTEST_H_
OSDN Git Service
