Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lowpan: Introduce new unit tests for data classes

Browse Source 
This change introduces new unit tests which confirm that
various data classes are being property marshalled
between their Java and C++ implementations.

Bug: b/63707448 b/63708348
Change-Id: I41d590b1e77dc41873c4b9e9bf1b7f1bf859f74e
Test: These tests both compile and pass
This commit is contained in:
Robert Quattlebaum
2017-07-14 12:05:29 -07:00
parent 80aca1e3b3
commit 93ea3ce9b8
18 changed files with 1152 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
lowpan/tests/Android.mk
View File

@@ -54,8 +54,35 @@ LOCAL_STATIC_JAVA_LIBRARIES := \
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
@@ -63,3 +90,25 @@ 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)

134
lowpan/tests/java/android/net/lowpan/LowpanBeaconInfoTest.java Normal file
View File

@@ -0,0 +1,134 @@
/*
* 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);
}
}

78
lowpan/tests/java/android/net/lowpan/LowpanChannelInfoTest.java Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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);
}
}

92
lowpan/tests/java/android/net/lowpan/LowpanCredentialTest.java Normal file
View File

@@ -0,0 +1,92 @@
/*
* 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);
}
}

199
lowpan/tests/java/android/net/lowpan/LowpanIdentityTest.java Normal file
View File

@@ -0,0 +1,199 @@
/*
* 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);
}
}

16
lowpan/tests/src/android/net/lowpan/LowpanInterfaceTest.java → lowpan/tests/java/android/net/lowpan/LowpanInterfaceTest.java
View File

@@ -16,10 +16,6 @@
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;
@@ -29,13 +25,12 @@ import android.os.IBinder;
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)
@@ -64,7 +59,8 @@ public class LowpanInterfaceTest {
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
@@ -81,12 +77,8 @@ public class LowpanInterfaceTest {
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

3
lowpan/tests/src/android/net/lowpan/LowpanManagerTest.java → lowpan/tests/java/android/net/lowpan/LowpanManagerTest.java
View File

@@ -16,10 +16,9 @@
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;

128
lowpan/tests/java/android/net/lowpan/LowpanProvisionTest.java Normal file
View File

@@ -0,0 +1,128 @@
/*
* 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);
}
}

66
lowpan/tests/jni/LowpanBeaconInfoTest.cpp Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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);
}

27
lowpan/tests/jni/LowpanBeaconInfoTest.h Normal file
View File

@@ -0,0 +1,27 @@
/*
* 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_

66
lowpan/tests/jni/LowpanChannelInfoTest.cpp Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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);
}

27
lowpan/tests/jni/LowpanChannelInfoTest.h Normal file
View File

@@ -0,0 +1,27 @@
/*
* 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_

66
lowpan/tests/jni/LowpanCredentialTest.cpp Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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);
}

27
lowpan/tests/jni/LowpanCredentialTest.h Normal file
View File

@@ -0,0 +1,27 @@
/*
* 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_

66
lowpan/tests/jni/LowpanIdentityTest.cpp Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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);
}

27
lowpan/tests/jni/LowpanIdentityTest.h Normal file
View File

@@ -0,0 +1,27 @@
/*
* 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_

66
lowpan/tests/jni/LowpanProvisionTest.cpp Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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);
}

27
lowpan/tests/jni/LowpanProvisionTest.h Normal file
View File

@@ -0,0 +1,27 @@
/*
* 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_