1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.harmony.tests.java.nio;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;
public class DirectByteBufferTest extends ByteBufferTest {
protected void setUp() throws Exception {
super.setUp();
buf = ByteBuffer.allocateDirect(BUFFER_LENGTH);
baseBuf = buf;
}
protected void tearDown() throws Exception {
super.tearDown();
buf = null;
baseBuf = null;
}
/**
* @tests java.nio.ByteBuffer#allocateDirect(int)
*
*/
public void testAllocatedByteBuffer_IllegalArg() {
try {
ByteBuffer.allocateDirect(-1);
fail("Should throw Exception"); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
// expected
}
}
public void testIsDirect() {
assertTrue(buf.isDirect());
}
public void testHasArray() {
// Android direct byte buffers have backing arrays.
assertTrue(buf.hasArray());
// assertFalse(buf.hasArray());
}
public void testIsReadOnly() {
assertFalse(buf.isReadOnly());
}
// http://b/19692084
// http://b/21491780
public void testUnalignedReadsAndWrites() {
// We guarantee that the first byte of the buffer is 8 byte aligned.
ByteBuffer buf = ByteBuffer.allocateDirect(23);
// Native order is always little endian, so this forces swaps.
buf.order(ByteOrder.BIG_ENDIAN);
for (int i = 0; i < 8; ++i) {
buf.position(i);
// 2 byte swaps.
ShortBuffer shortBuf = buf.asShortBuffer();
short[] shortArray = new short[] { 42, 24 };
// Write.
shortBuf.put(shortArray);
// Read
shortBuf.flip();
shortBuf.get(shortArray);
// Assert Equality
assertEquals(42, shortArray[0]);
assertEquals(24, shortArray[1]);
buf.position(i);
// 4 byte swaps.
IntBuffer intBuf = buf.asIntBuffer();
int[] intArray = new int[] { 967, 1983 };
// Write.
intBuf.put(intArray);
// Read
intBuf.flip();
intBuf.get(intArray);
// Assert Equality
assertEquals(967, intArray[0]);
assertEquals(1983, intArray[1]);
buf.position(i);
// 8 byte swaps.
LongBuffer longBuf = buf.asLongBuffer();
long[] longArray = new long[] { 2147484614L, 2147485823L };
// Write.
longBuf.put(longArray);
// Read
longBuf.flip();
longBuf.get(longArray);
// Assert Equality
assertEquals(2147484614L, longArray[0]);
assertEquals(2147485823L, longArray[1]);
}
}
}
|
