Home | History | Annotate | Download | only in nio 
      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.tests.java.nio;
     17 
     18 import java.nio.ReadOnlyBufferException;
     19 import java.nio.ShortBuffer;
     20 
     21 public class ReadOnlyShortBufferTest extends ShortBufferTest {
     22     protected void setUp() throws Exception {
     23         super.setUp();
     24         buf = buf.asReadOnlyBuffer();
     25         baseBuf = buf;
     26     }
     27 
     28     protected void tearDown() throws Exception {
     29         super.tearDown();
     30     }
     31 
     32     public void testIsReadOnly() {
     33         assertTrue(buf.isReadOnly());
     34     }
     35 
     36     public void testHasArray() {
     37         assertFalse(buf.hasArray());
     38     }
     39 
     40     public void testArray() {
     41         try {
     42             buf.array();
     43             fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
     44         } catch (ReadOnlyBufferException e) {
     45             //expected
     46         }
     47     }
     48 
     49     public void testHashCode() {
     50         ShortBuffer duplicate = buf.duplicate();
     51         assertEquals(buf.hashCode(), duplicate.hashCode());
     52     }
     53 
     54     public void testArrayOffset() {
     55         try {
     56             buf.arrayOffset();
     57             fail("Should throw Exception"); //$NON-NLS-1$
     58         } catch (UnsupportedOperationException e) {
     59             //expected
     60         }
     61     }
     62 
     63     public void testCompact() {
     64         try {
     65             buf.compact();
     66             fail("Should throw Exception"); //$NON-NLS-1$
     67         } catch (ReadOnlyBufferException e) {
     68             // expected
     69         }
     70     }
     71 
     72     public void testPutshort() {
     73         try {
     74             buf.put((short)0);
     75             fail("Should throw Exception"); //$NON-NLS-1$
     76         } catch (ReadOnlyBufferException e) {
     77             // expected
     78         }
     79     }
     80 
     81     public void testPutshortArray() {
     82         short array[] = new short[1];
     83         try {
     84             buf.put(array);
     85             fail("Should throw Exception"); //$NON-NLS-1$
     86         } catch (ReadOnlyBufferException e) {
     87             // expected
     88         }
     89         try {
     90             buf.put((short[]) null);
     91             fail("Should throw Exception"); //$NON-NLS-1$
     92         } catch (NullPointerException e) {
     93             // expected
     94         }
     95     }
     96 
     97     public void testPutshortArrayintint() {
     98         short array[] = new short[1];
     99         try {
    100             buf.put(array, 0, array.length);
    101             fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
    102         } catch (ReadOnlyBufferException e) {
    103             // expected
    104         }
    105         try {
    106             buf.put((short[]) null, 0, 1);
    107             fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
    108         } catch (ReadOnlyBufferException e) {
    109             // expected
    110         }
    111         try {
    112             buf.put(new short[buf.capacity() + 1], 0, buf.capacity() + 1);
    113             fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
    114         } catch (ReadOnlyBufferException e) {
    115             // expected
    116         }
    117         try {
    118             buf.put(array, -1, array.length);
    119             fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
    120         } catch (ReadOnlyBufferException e) {
    121             // expected
    122         }
    123     }
    124 
    125     public void testPutShortBuffer() {
    126         ShortBuffer other = ShortBuffer.allocate(1);
    127         try {
    128             buf.put(other);
    129             fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
    130         } catch (ReadOnlyBufferException e) {
    131             // expected
    132         }
    133         try {
    134             buf.put((ShortBuffer) null);
    135             fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
    136         } catch (ReadOnlyBufferException e) {
    137             // expected
    138         }
    139         try {
    140             buf.put(buf);
    141             fail("Should throw IllegalArgumentException"); //$NON-NLS-1$
    142         } catch (IllegalArgumentException e) {
    143             // expected
    144         }
    145     }
    146 
    147     public void testPutintshort() {
    148         try {
    149             buf.put(0, (short) 0);
    150             fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
    151         } catch (ReadOnlyBufferException e) {
    152             // expected
    153         }
    154         try {
    155             buf.put(-1, (short) 0);
    156             fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
    157         } catch (ReadOnlyBufferException e) {
    158             // expected
    159         }
    160     }
    161 }
    162