| /* |
| * Copyright (C) 2015 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.databinding; |
| |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.test.AndroidTestCase; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.Closeable; |
| import java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.io.Serializable; |
| import java.util.UUID; |
| |
| public class ObservableParcelTest extends AndroidTestCase { |
| public void testParcelInt() { |
| ObservableInt observableInt = new ObservableInt(); |
| observableInt.set(Integer.MAX_VALUE - 1); |
| ObservableInt read = parcelAndUnparcel(observableInt, ObservableInt.class); |
| assertEquals(Integer.MAX_VALUE - 1, read.get()); |
| } |
| |
| public void testParcelBoolean() { |
| ObservableBoolean obj = new ObservableBoolean(false); |
| ObservableBoolean read = parcelAndUnparcel(obj, ObservableBoolean.class); |
| assertFalse(read.get()); |
| |
| ObservableBoolean obj2 = new ObservableBoolean(true); |
| ObservableBoolean read2 = parcelAndUnparcel(obj2, ObservableBoolean.class); |
| assertTrue(read2.get()); |
| } |
| |
| public void testParcelByte() { |
| ObservableByte obj = new ObservableByte((byte) 7); |
| ObservableByte read = parcelAndUnparcel(obj, ObservableByte.class); |
| assertEquals((byte) 7, read.get()); |
| } |
| |
| public void testParcelChar() { |
| ObservableChar obj = new ObservableChar('y'); |
| ObservableChar read = parcelAndUnparcel(obj, ObservableChar.class); |
| assertEquals('y', read.get()); |
| } |
| |
| public void testParcelDouble() { |
| ObservableDouble obj = new ObservableDouble(Double.MAX_VALUE); |
| ObservableDouble read = parcelAndUnparcel(obj, ObservableDouble.class); |
| assertEquals(Double.MAX_VALUE, read.get()); |
| } |
| |
| public void testParcelFloat() { |
| ObservableFloat obj = new ObservableFloat(Float.MIN_VALUE); |
| ObservableFloat read = parcelAndUnparcel(obj, ObservableFloat.class); |
| assertEquals(Float.MIN_VALUE, read.get()); |
| } |
| |
| public void testParcelParcel() { |
| MyParcelable myParcelable = new MyParcelable(5, "foo"); |
| ObservableParcelable<MyParcelable> obj = new ObservableParcelable<>(myParcelable); |
| ObservableParcelable read = parcelAndUnparcel(obj, |
| ObservableParcelable.class); |
| assertEquals(myParcelable, read.get()); |
| } |
| |
| public void testParcelLong() { |
| ObservableLong obj = new ObservableLong(Long.MAX_VALUE - 1); |
| ObservableLong read = parcelAndUnparcel(obj, ObservableLong.class); |
| assertEquals(Long.MAX_VALUE - 1, read.get()); |
| } |
| |
| public void testParcelShort() { |
| ObservableShort obj = new ObservableShort(Short.MIN_VALUE); |
| ObservableShort read = parcelAndUnparcel(obj, ObservableShort.class); |
| assertEquals(Short.MIN_VALUE, read.get()); |
| } |
| |
| public void testSerializeInt() throws IOException, ClassNotFoundException { |
| ObservableInt observableInt = new ObservableInt(); |
| observableInt.set(Integer.MAX_VALUE - 1); |
| ObservableInt read = serializeAndDeserialize(observableInt, ObservableInt.class); |
| assertEquals(Integer.MAX_VALUE - 1, read.get()); |
| } |
| |
| public void testSerializeBoolean() throws IOException, ClassNotFoundException { |
| ObservableBoolean obj = new ObservableBoolean(false); |
| ObservableBoolean read = serializeAndDeserialize(obj, ObservableBoolean.class); |
| assertFalse(read.get()); |
| ObservableBoolean obj2 = new ObservableBoolean(true); |
| ObservableBoolean read2 = serializeAndDeserialize(obj2, ObservableBoolean.class); |
| assertTrue(read2.get()); |
| } |
| |
| public void testSerializeByte() throws IOException, ClassNotFoundException { |
| ObservableByte obj = new ObservableByte((byte) 7); |
| ObservableByte read = serializeAndDeserialize(obj, ObservableByte.class); |
| assertEquals((byte) 7, read.get()); |
| } |
| |
| public void testSerializeChar() throws IOException, ClassNotFoundException { |
| ObservableChar obj = new ObservableChar('y'); |
| ObservableChar read = serializeAndDeserialize(obj, ObservableChar.class); |
| assertEquals('y', read.get()); |
| } |
| |
| public void testSerializeDouble() throws IOException, ClassNotFoundException { |
| ObservableDouble obj = new ObservableDouble(Double.MAX_VALUE); |
| ObservableDouble read = serializeAndDeserialize(obj, ObservableDouble.class); |
| assertEquals(Double.MAX_VALUE, read.get()); |
| } |
| |
| public void testSerializeFloat() throws IOException, ClassNotFoundException { |
| ObservableFloat obj = new ObservableFloat(Float.MIN_VALUE); |
| ObservableFloat read = serializeAndDeserialize(obj, ObservableFloat.class); |
| assertEquals(Float.MIN_VALUE, read.get()); |
| } |
| |
| public void testSerializeParcel() throws IOException, ClassNotFoundException { |
| MyParcelable myParcelable = new MyParcelable(5, "foo"); |
| ObservableParcelable<MyParcelable> obj = new ObservableParcelable<>(myParcelable); |
| ObservableParcelable read = serializeAndDeserialize(obj, |
| ObservableParcelable.class); |
| assertEquals(myParcelable, read.get()); |
| } |
| |
| public void testSerializeField() throws IOException, ClassNotFoundException { |
| MyParcelable myParcelable = new MyParcelable(5, "foo"); |
| ObservableField<MyParcelable> obj = new ObservableField<>(myParcelable); |
| ObservableField read = serializeAndDeserialize(obj, ObservableField.class); |
| assertEquals(myParcelable, read.get()); |
| } |
| |
| public void testSerializeLong() throws IOException, ClassNotFoundException { |
| ObservableLong obj = new ObservableLong(Long.MAX_VALUE - 1); |
| ObservableLong read = serializeAndDeserialize(obj, ObservableLong.class); |
| assertEquals(Long.MAX_VALUE - 1, read.get()); |
| } |
| |
| public void testSerializeShort() throws IOException, ClassNotFoundException { |
| ObservableShort obj = new ObservableShort(Short.MIN_VALUE); |
| ObservableShort read = serializeAndDeserialize(obj, ObservableShort.class); |
| assertEquals(Short.MIN_VALUE, read.get()); |
| } |
| |
| private <T extends Parcelable> T parcelAndUnparcel(T t, Class<T> klass) { |
| Parcel parcel = Parcel.obtain(); |
| parcel.writeParcelable(t, 0); |
| // we append a suffix to the parcelable to test out of bounds |
| String parcelSuffix = UUID.randomUUID().toString(); |
| parcel.writeString(parcelSuffix); |
| // get ready to read |
| parcel.setDataPosition(0); |
| Parcelable parcelable = parcel.readParcelable(getClass().getClassLoader()); |
| assertNotNull(parcelable); |
| assertEquals(klass, parcelable.getClass()); |
| assertEquals(parcelSuffix, parcel.readString()); |
| return (T) parcelable; |
| } |
| |
| private <T> T serializeAndDeserialize(T t, Class<T> klass) |
| throws IOException, ClassNotFoundException { |
| ObjectOutputStream oos = null; |
| ByteArrayOutputStream bos = null; |
| String suffix = UUID.randomUUID().toString(); |
| try { |
| bos = new ByteArrayOutputStream(); |
| oos = new ObjectOutputStream(bos); |
| oos.writeObject(t); |
| oos.writeObject(suffix); |
| } finally { |
| closeQuietly(bos); |
| closeQuietly(oos); |
| } |
| ByteArrayInputStream bis = null; |
| ObjectInputStream ois = null; |
| try { |
| bis = new ByteArrayInputStream(bos.toByteArray()); |
| ois = new ObjectInputStream(bis); |
| Object o = ois.readObject(); |
| assertEquals(klass, o.getClass()); |
| assertEquals(suffix, ois.readObject()); |
| return (T) o; |
| } finally { |
| closeQuietly(bis); |
| closeQuietly(ois); |
| } |
| } |
| |
| private static void closeQuietly(Closeable closeable) { |
| try { |
| if (closeable != null) { |
| closeable.close(); |
| } |
| } catch (IOException ignored) { |
| } |
| } |
| |
| public static class MyParcelable implements Parcelable, Serializable { |
| int x; |
| String y; |
| |
| public MyParcelable() { |
| } |
| |
| public MyParcelable(int x, String y) { |
| this.x = x; |
| this.y = y; |
| } |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(Parcel dest, int flags) { |
| dest.writeInt(x); |
| dest.writeString(y); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) { |
| return true; |
| } |
| if (o == null || getClass() != o.getClass()) { |
| return false; |
| } |
| |
| MyParcelable that = (MyParcelable) o; |
| |
| if (x != that.x) { |
| return false; |
| } |
| if (y != null ? !y.equals(that.y) : that.y != null) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| @Override |
| public int hashCode() { |
| int result = x; |
| result = 31 * result + (y != null ? y.hashCode() : 0); |
| return result; |
| } |
| |
| public static final Parcelable.Creator<MyParcelable> CREATOR |
| = new Parcelable.Creator<MyParcelable>() { |
| |
| @Override |
| public MyParcelable createFromParcel(Parcel source) { |
| return new MyParcelable(source.readInt(), source.readString()); |
| } |
| |
| @Override |
| public MyParcelable[] newArray(int size) { |
| return new MyParcelable[size]; |
| } |
| }; |
| } |
| } |