1 /*
2  * Copyright 2022 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.bluetooth;
18 
19 import static com.google.common.truth.Truth.assertThat;
20 import static com.google.common.truth.Truth.assertWithMessage;
21 
22 import androidx.test.filters.SmallTest;
23 import androidx.test.runner.AndroidJUnit4;
24 
25 import com.android.obex.HeaderSet;
26 
27 import org.junit.Test;
28 import org.junit.runner.RunWith;
29 
30 import java.nio.ByteBuffer;
31 import java.util.Arrays;
32 
33 @SmallTest
34 @RunWith(AndroidJUnit4.class)
35 public class ObexAppParametersTest {
36 
37     private static final byte KEY = 0x12;
38 
39     @Test
constructorWithByteArrays_withOneInvalidElement()40     public void constructorWithByteArrays_withOneInvalidElement() {
41         final int length = 4;
42 
43         byte[] byteArray =
44                 new byte[] {
45                     KEY, length, 0x12, 0x34, 0x56, 0x78, 0x66
46                 }; // Last one is invalid. It will be filtered out.
47 
48         ObexAppParameters params = new ObexAppParameters(byteArray);
49         assertThat(params.exists(KEY)).isTrue();
50 
51         byte[] expected = Arrays.copyOfRange(byteArray, 2, 6);
52         assertThat(params.getByteArray(KEY)).isEqualTo(expected);
53     }
54 
55     @Test
constructorWithByteArrays_withTwoInvalidElements()56     public void constructorWithByteArrays_withTwoInvalidElements() {
57         final int length = 4;
58         byte[] byteArray =
59                 new byte[] {
60                     KEY, length, 0x12, 0x34, 0x56, 0x78, 0x66, 0x77
61                 }; // Last two are invalid. It will be filtered out.
62 
63         ObexAppParameters params = new ObexAppParameters(byteArray);
64         assertThat(params.exists(KEY)).isTrue();
65 
66         byte[] expected = Arrays.copyOfRange(byteArray, 2, 6);
67         assertThat(params.getByteArray(KEY)).isEqualTo(expected);
68     }
69 
70     @Test
fromHeaderSet()71     public void fromHeaderSet() {
72         final int length = 4;
73         byte[] byteArray = new byte[] {KEY, length, 0x12, 0x34, 0x56, 0x78};
74 
75         HeaderSet headerSet = new HeaderSet();
76         headerSet.setHeader(HeaderSet.APPLICATION_PARAMETER, byteArray);
77 
78         ObexAppParameters params = ObexAppParameters.fromHeaderSet(headerSet);
79         assertThat(params).isNotNull();
80 
81         byte[] expected = Arrays.copyOfRange(byteArray, 2, 6);
82         assertThat(params.getByteArray(KEY)).isEqualTo(expected);
83     }
84 
85     @Test
addToHeaderSet()86     public void addToHeaderSet() throws Exception {
87         final int length = 4;
88         byte[] byteArray = new byte[] {KEY, length, 0x12, 0x34, 0x56, 0x78};
89 
90         HeaderSet headerSet = new HeaderSet();
91         ObexAppParameters params = new ObexAppParameters(byteArray);
92         params.addToHeaderSet(headerSet);
93 
94         assertThat(byteArray).isEqualTo(headerSet.getHeader(HeaderSet.APPLICATION_PARAMETER));
95     }
96 
97     @Test
add_byte()98     public void add_byte() {
99         ObexAppParameters params = new ObexAppParameters();
100         final byte value = 0x34;
101         params.add(KEY, value);
102 
103         assertThat(params.getByte(KEY)).isEqualTo(value);
104     }
105 
106     @Test
add_short()107     public void add_short() {
108         ObexAppParameters params = new ObexAppParameters();
109         final short value = 0x99; // More than max byte value
110         params.add(KEY, value);
111 
112         assertThat(params.getShort(KEY)).isEqualTo(value);
113     }
114 
115     @Test
add_int()116     public void add_int() {
117         ObexAppParameters params = new ObexAppParameters();
118         final int value = 12345678; // More than max short value
119         params.add(KEY, value);
120 
121         assertThat(params.getInt(KEY)).isEqualTo(value);
122     }
123 
124     @Test
add_long()125     public void add_long() {
126         ObexAppParameters params = new ObexAppParameters();
127         final long value = 1234567890123456L; // More than max integer value
128         params.add(KEY, value);
129 
130         // Note: getLong() does not exist
131         byte[] byteArray = params.getByteArray(KEY);
132         assertThat(ByteBuffer.wrap(byteArray).getLong()).isEqualTo(value);
133     }
134 
135     @Test
add_string()136     public void add_string() {
137         ObexAppParameters params = new ObexAppParameters();
138         final String value = "Some string value";
139         params.add(KEY, value);
140 
141         assertThat(params.getString(KEY)).isEqualTo(value);
142     }
143 
144     @Test
add_byteArray()145     public void add_byteArray() {
146         ObexAppParameters params = new ObexAppParameters();
147         final byte[] value = new byte[] {0x00, 0x01, 0x02, 0x03};
148         params.add(KEY, value);
149 
150         assertThat(params.getByteArray(KEY)).isEqualTo(value);
151     }
152 
153     @Test
get_errorCases()154     public void get_errorCases() {
155         ObexAppParameters emptyParams = new ObexAppParameters();
156 
157         assertThat(emptyParams.getByte(KEY)).isEqualTo(0);
158         assertThat(emptyParams.getShort(KEY)).isEqualTo(0);
159         assertThat(emptyParams.getInt(KEY)).isEqualTo(0);
160         // Note: getLong() does not exist
161         assertThat(emptyParams.getString(KEY)).isNull();
162         assertThat(emptyParams.getByteArray(KEY)).isNull();
163     }
164 
165     @Test
toString_isNotNull()166     public void toString_isNotNull() {
167         ObexAppParameters params = new ObexAppParameters();
168         assertThat(params.toString()).isNotNull();
169     }
170 
171     @Test
getHeader_withTwoEntries()172     public void getHeader_withTwoEntries() {
173         ObexAppParameters params = new ObexAppParameters();
174 
175         final byte key1 = 0x01;
176         final int value1 = 12345;
177         params.add(key1, value1);
178 
179         final byte key2 = 0x02;
180         final int value2 = 56789;
181         params.add(key2, value2);
182 
183         ByteBuffer result = ByteBuffer.wrap(params.getHeader());
184         final byte firstKey = result.get();
185 
186         final int sizeOfInt = 4;
187         if (firstKey == key1) {
188             assertThat(result.get()).isEqualTo(sizeOfInt);
189             assertThat(result.getInt()).isEqualTo(value1);
190 
191             assertThat(result.get()).isEqualTo(key2);
192             assertThat(result.get()).isEqualTo(sizeOfInt);
193             assertThat(result.getInt()).isEqualTo(value2);
194         } else if (firstKey == key2) {
195             assertThat(result.get()).isEqualTo(sizeOfInt);
196             assertThat(result.getInt()).isEqualTo(value2);
197 
198             assertThat(result.get()).isEqualTo(key1);
199             assertThat(result.get()).isEqualTo(sizeOfInt);
200             assertThat(result.getInt()).isEqualTo(value1);
201         } else {
202             assertWithMessage("Key should be one of two keys").fail();
203         }
204     }
205 }
206