libcore/luni/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectByteBufferTest.java

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  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 package org.apache.harmony.nio.tests.java.nio;
  17
  18 import dalvik.annotation.TestLevel;
  19 import dalvik.annotation.TestTargetNew;
  20 import dalvik.annotation.TestTargetClass;
  21
  22 import java.nio.ByteBuffer;
  23
  24 @TestTargetClass(ByteBuffer.class)
  25 public class DirectByteBufferTest extends ByteBufferTest {
  26
  27     protected void setUp() throws Exception {
  28         capacity = BUFFER_LENGTH;
  29         buf = ByteBuffer.allocateDirect(BUFFER_LENGTH);
  30         loadTestData1(buf);
  31         baseBuf = buf;
  32     }
  33
  34     protected void tearDown() throws Exception {
  35         buf = null;
  36         baseBuf = null;
  37     }
  38
  39     /**
  40      * @tests java.nio.ByteBuffer#allocateDirect(int)
  41      *
  42      */
  43     @TestTargetNew(
  44         level = TestLevel.PARTIAL_COMPLETE,
  45         notes = "Verifies IllegalArgumentException.",
  46         method = "allocateDirect",
  47         args = {int.class}
  48     )
  49     public void testAllocatedByteBuffer_IllegalArg() {
  50         try {
  51             ByteBuffer.allocateDirect(-1);
  52             fail("Should throw Exception");
  53         } catch (IllegalArgumentException e) {
  54             // expected
  55         }
  56     }
  57
  58     @TestTargetNew(
  59         level = TestLevel.PARTIAL_COMPLETE,
  60         notes = "",
  61         method = "array",
  62         args = {}
  63     )
  64     public void testArray() {
  65         try {
  66             buf.array();
  67             fail("Should throw UnsupportedOperationException");
  68         } catch (UnsupportedOperationException e) {
  69             // expected
  70         }
  71     }
  72
  73     @TestTargetNew(
  74         level = TestLevel.PARTIAL_COMPLETE,
  75         notes = "",
  76         method = "arrayOffset",
  77         args = {}
  78     )
  79     public void testArrayOffset() {
  80         try {
  81             buf.arrayOffset();
  82             fail("Should throw UnsupportedOperationException");
  83         } catch (UnsupportedOperationException e) {
  84             // expected
  85         }
  86     }
  87
  88     @TestTargetNew(
  89         level = TestLevel.PARTIAL_COMPLETE,
  90         notes = "Verifies isDirect method for direct ByteBuffer.",
  91         method = "isDirect",
  92         args = {}
  93     )
  94     public void testIsDirect() {
  95         assertTrue(buf.isDirect());
  96     }
  97
  98     @TestTargetNew(
  99         level = TestLevel.PARTIAL_COMPLETE,
 100         notes = "Verifies hasArray method for direct ByteBuffer.",
 101         method = "hasArray",
 102         args = {}
 103     )
 104     public void testHasArray() {
 105         assertFalse(buf.hasArray());
 106         try {
 107             buf.array();
 108             fail("Should throw Exception");
 109         } catch (UnsupportedOperationException e) {
 110             // expected
 111         }
 112     }
 113 }