src/test/java/org/apache/james/mime4j/TestCharArrayBuffer.java

   1 /****************************************************************
   2  * Licensed to the Apache Software Foundation (ASF) under one   *
   3  * or more contributor license agreements.  See the NOTICE file *
   4  * distributed with this work for additional information        *
   5  * regarding copyright ownership.  The ASF licenses this file   *
   6  * to you under the Apache License, Version 2.0 (the            *
   7  * "License"); you may not use this file except in compliance   *
   8  * with the License.  You may obtain a copy of the License at   *
   9  *                                                              *
  10  *   http://www.apache.org/licenses/LICENSE-2.0                 *
  11  *                                                              *
  12  * Unless required by applicable law or agreed to in writing,   *
  13  * software distributed under the License is distributed on an  *
  14  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
  15  * KIND, either express or implied.  See the License for the    *
  16  * specific language governing permissions and limitations      *
  17  * under the License.                                           *
  18  ****************************************************************/
  19
  20 package org.apache.james.mime4j;
  21
  22 import junit.framework.Test;
  23 import junit.framework.TestCase;
  24 import junit.framework.TestSuite;
  25
  26 /**
  27  * Unit tests for {@link CharArrayBuffer}.
  28  */
  29 public class TestCharArrayBuffer extends TestCase {
  30
  31     public TestCharArrayBuffer(String testName) {
  32         super(testName);
  33     }
  34
  35     public static void main(String args[]) {
  36         String[] testCaseName = { TestCharArrayBuffer.class.getName() };
  37         junit.textui.TestRunner.main(testCaseName);
  38     }
  39
  40     public static Test suite() {
  41         return new TestSuite(TestCharArrayBuffer.class);
  42     }
  43
  44     public void testConstructor() throws Exception {
  45         CharArrayBuffer buffer = new CharArrayBuffer(16);
  46         assertEquals(16, buffer.capacity());
  47         assertEquals(0, buffer.length());
  48         assertNotNull(buffer.buffer());
  49         assertEquals(16, buffer.buffer().length);
  50         try {
  51             new CharArrayBuffer(-1);
  52             fail("IllegalArgumentException should have been thrown");
  53         } catch (IllegalArgumentException ex) {
  54             // expected
  55         }
  56     }
  57
  58     public void testSimpleAppend() throws Exception {
  59         CharArrayBuffer buffer = new CharArrayBuffer(16);
  60         assertEquals(16, buffer.capacity());
  61         assertEquals(0, buffer.length());
  62         char[] b1 = buffer.toCharArray();
  63         assertNotNull(b1);
  64         assertEquals(0, b1.length);
  65         assertTrue(buffer.isEmpty());
  66         assertFalse(buffer.isFull());
  67
  68         char[] tmp = new char[] { '1', '2', '3', '4'};
  69         buffer.append(tmp, 0, tmp.length);
  70         assertEquals(16, buffer.capacity());
  71         assertEquals(4, buffer.length());
  72         assertFalse(buffer.isEmpty());
  73         assertFalse(buffer.isFull());
  74
  75         char[] b2 = buffer.toCharArray();
  76         assertNotNull(b2);
  77         assertEquals(4, b2.length);
  78         for (int i = 0; i < tmp.length; i++) {
  79             assertEquals(tmp[i], b2[i]);
  80             assertEquals(tmp[i], buffer.charAt(i));
  81         }
  82         assertEquals("1234", buffer.toString());
  83
  84         buffer.clear();
  85         assertEquals(16, buffer.capacity());
  86         assertEquals(0, buffer.length());
  87         assertTrue(buffer.isEmpty());
  88         assertFalse(buffer.isFull());
  89     }
  90
  91     public void testExpandAppend() throws Exception {
  92         CharArrayBuffer buffer = new CharArrayBuffer(4);
  93         assertEquals(4, buffer.capacity());
  94
  95         char[] tmp = new char[] { '1', '2', '3', '4'};
  96         buffer.append(tmp, 0, 2);
  97         buffer.append(tmp, 0, 4);
  98         buffer.append(tmp, 0, 0);
  99
 100         assertEquals(8, buffer.capacity());
 101         assertEquals(6, buffer.length());
 102
 103         buffer.append(tmp, 0, 4);
 104
 105         assertEquals(16, buffer.capacity());
 106         assertEquals(10, buffer.length());
 107
 108         assertEquals("1212341234", buffer.toString());
 109     }
 110
 111     public void testAppendString() throws Exception {
 112         CharArrayBuffer buffer = new CharArrayBuffer(8);
 113         buffer.append("stuff");
 114         buffer.append(" and more stuff");
 115         assertEquals("stuff and more stuff", buffer.toString());
 116     }
 117
 118     public void testAppendNullString() throws Exception {
 119         CharArrayBuffer buffer = new CharArrayBuffer(8);
 120         buffer.append((String)null);
 121         assertEquals("null", buffer.toString());
 122     }
 123
 124     public void testAppendCharArrayBuffer() throws Exception {
 125         CharArrayBuffer buffer1 = new CharArrayBuffer(8);
 126         buffer1.append(" and more stuff");
 127         CharArrayBuffer buffer2 = new CharArrayBuffer(8);
 128         buffer2.append("stuff");
 129         buffer2.append(buffer1);
 130         assertEquals("stuff and more stuff", buffer2.toString());
 131     }
 132
 133     public void testAppendNullCharArrayBuffer() throws Exception {
 134         CharArrayBuffer buffer = new CharArrayBuffer(8);
 135         buffer.append((CharArrayBuffer)null);
 136         buffer.append((CharArrayBuffer)null, 0, 0);
 137         assertEquals("", buffer.toString());
 138     }
 139
 140     public void testAppendSingleChar() throws Exception {
 141         CharArrayBuffer buffer = new CharArrayBuffer(4);
 142         buffer.append('1');
 143         buffer.append('2');
 144         buffer.append('3');
 145         buffer.append('4');
 146         buffer.append('5');
 147         buffer.append('6');
 148         assertEquals("123456", buffer.toString());
 149     }
 150
 151     public void testInvalidCharArrayAppend() throws Exception {
 152         CharArrayBuffer buffer = new CharArrayBuffer(4);
 153         buffer.append((char[])null, 0, 0);
 154
 155         char[] tmp = new char[] { '1', '2', '3', '4'};
 156         try {
 157             buffer.append(tmp, -1, 0);
 158             fail("IndexOutOfBoundsException should have been thrown");
 159         } catch (IndexOutOfBoundsException ex) {
 160             // expected
 161         }
 162         try {
 163             buffer.append(tmp, 0, -1);
 164             fail("IndexOutOfBoundsException should have been thrown");
 165         } catch (IndexOutOfBoundsException ex) {
 166             // expected
 167         }
 168         try {
 169             buffer.append(tmp, 0, 8);
 170             fail("IndexOutOfBoundsException should have been thrown");
 171         } catch (IndexOutOfBoundsException ex) {
 172             // expected
 173         }
 174         try {
 175             buffer.append(tmp, 10, Integer.MAX_VALUE);
 176             fail("IndexOutOfBoundsException should have been thrown");
 177         } catch (IndexOutOfBoundsException ex) {
 178             // expected
 179         }
 180         try {
 181             buffer.append(tmp, 2, 4);
 182             fail("IndexOutOfBoundsException should have been thrown");
 183         } catch (IndexOutOfBoundsException ex) {
 184             // expected
 185         }
 186     }
 187
 188     public void testSetLength() throws Exception {
 189         CharArrayBuffer buffer = new CharArrayBuffer(4);
 190         buffer.setLength(2);
 191         assertEquals(2, buffer.length());
 192     }
 193
 194     public void testSetInvalidLength() throws Exception {
 195         CharArrayBuffer buffer = new CharArrayBuffer(4);
 196         try {
 197             buffer.setLength(-2);
 198             fail("IndexOutOfBoundsException should have been thrown");
 199         } catch (IndexOutOfBoundsException ex) {
 200             // expected
 201         }
 202         try {
 203             buffer.setLength(200);
 204             fail("IndexOutOfBoundsException should have been thrown");
 205         } catch (IndexOutOfBoundsException ex) {
 206             // expected
 207         }
 208     }
 209
 210     public void testEnsureCapacity() throws Exception {
 211         CharArrayBuffer buffer = new CharArrayBuffer(4);
 212         buffer.ensureCapacity(2);
 213         assertEquals(4, buffer.capacity());
 214         buffer.ensureCapacity(8);
 215         assertEquals(8, buffer.capacity());
 216     }
 217
 218     public void testIndexOf() {
 219         CharArrayBuffer buffer = new CharArrayBuffer(16);
 220         buffer.append("name: value");
 221         assertEquals(4, buffer.indexOf(':'));
 222         assertEquals(-1, buffer.indexOf(','));
 223         assertEquals(4, buffer.indexOf(':', -1, 11));
 224         assertEquals(4, buffer.indexOf(':', 0, 1000));
 225         assertEquals(-1, buffer.indexOf(':', 2, 1));
 226     }
 227
 228     public void testSubstring() {
 229         CharArrayBuffer buffer = new CharArrayBuffer(16);
 230         buffer.append(" name:  value    ");
 231         assertEquals(5, buffer.indexOf(':'));
 232         assertEquals(" name", buffer.substring(0, 5));
 233         assertEquals("  value    ", buffer.substring(6, buffer.length()));
 234         assertEquals("name", buffer.substringTrimmed(0, 5));
 235         assertEquals("value", buffer.substringTrimmed(6, buffer.length()));
 236         assertEquals("", buffer.substringTrimmed(13, buffer.length()));
 237     }
 238
 239     public void testSubstringIndexOfOutBound() {
 240         CharArrayBuffer buffer = new CharArrayBuffer(16);
 241         buffer.append("stuff");
 242         try {
 243             buffer.substring(-2, 10);
 244             fail("IndexOutOfBoundsException should have been thrown");
 245         } catch (IndexOutOfBoundsException ex) {
 246             // expected
 247         }
 248         try {
 249             buffer.substringTrimmed(-2, 10);
 250             fail("IndexOutOfBoundsException should have been thrown");
 251         } catch (IndexOutOfBoundsException ex) {
 252             // expected
 253         }
 254         try {
 255             buffer.substring(12, 10);
 256             fail("IndexOutOfBoundsException should have been thrown");
 257         } catch (IndexOutOfBoundsException ex) {
 258             // expected
 259         }
 260         try {
 261             buffer.substringTrimmed(12, 10);
 262             fail("IndexOutOfBoundsException should have been thrown");
 263         } catch (IndexOutOfBoundsException ex) {
 264             // expected
 265         }
 266         try {
 267             buffer.substring(2, 1);
 268             fail("IndexOutOfBoundsException should have been thrown");
 269         } catch (IndexOutOfBoundsException ex) {
 270             // expected
 271         }
 272         try {
 273             buffer.substringTrimmed(2, 1);
 274             fail("IndexOutOfBoundsException should have been thrown");
 275         } catch (IndexOutOfBoundsException ex) {
 276             // expected
 277         }
 278     }
 279
 280     public void testAppendAsciiByteArray() throws Exception {
 281         String s1 = "stuff";
 282         String s2 = " and more stuff";
 283         byte[] b1 = s1.getBytes("US-ASCII");
 284         byte[] b2 = s2.getBytes("US-ASCII");
 285
 286         CharArrayBuffer buffer = new CharArrayBuffer(8);
 287         buffer.append(b1, 0, b1.length);
 288         buffer.append(b2, 0, b2.length);
 289
 290         assertEquals("stuff and more stuff", buffer.toString());
 291     }
 292
 293     public void testAppendISOByteArray() throws Exception {
 294         byte[] b = new byte[] {0x00, 0x20, 0x7F, -0x80, -0x01};
 295
 296         CharArrayBuffer buffer = new CharArrayBuffer(8);
 297         buffer.append(b, 0, b.length);
 298         char[] ch = buffer.toCharArray();
 299         assertNotNull(ch);
 300         assertEquals(5, ch.length);
 301         assertEquals(0x00, ch[0]);
 302         assertEquals(0x20, ch[1]);
 303         assertEquals(0x7F, ch[2]);
 304         assertEquals(0x80, ch[3]);
 305         assertEquals(0xFF, ch[4]);
 306     }
 307
 308     public void testAppendNullByteArray() throws Exception {
 309         CharArrayBuffer buffer = new CharArrayBuffer(8);
 310         buffer.append((byte[])null, 0, 0);
 311         assertEquals("", buffer.toString());
 312     }
 313
 314     public void testAppendNullByteArrayBuffer() throws Exception {
 315         CharArrayBuffer buffer = new CharArrayBuffer(8);
 316         buffer.append((ByteArrayBuffer)null, 0, 0);
 317         assertEquals("", buffer.toString());
 318     }
 319
 320     public void testInvalidAppendAsciiByteArray() throws Exception {
 321         CharArrayBuffer buffer = new CharArrayBuffer(4);
 322         buffer.append((byte[])null, 0, 0);
 323
 324         byte[] tmp = new byte[] { '1', '2', '3', '4'};
 325         try {
 326             buffer.append(tmp, -1, 0);
 327             fail("IndexOutOfBoundsException should have been thrown");
 328         } catch (IndexOutOfBoundsException ex) {
 329             // expected
 330         }
 331         try {
 332             buffer.append(tmp, 0, -1);
 333             fail("IndexOutOfBoundsException should have been thrown");
 334         } catch (IndexOutOfBoundsException ex) {
 335             // expected
 336         }
 337         try {
 338             buffer.append(tmp, 0, 8);
 339             fail("IndexOutOfBoundsException should have been thrown");
 340         } catch (IndexOutOfBoundsException ex) {
 341             // expected
 342         }
 343         try {
 344             buffer.append(tmp, 10, Integer.MAX_VALUE);
 345             fail("IndexOutOfBoundsException should have been thrown");
 346         } catch (IndexOutOfBoundsException ex) {
 347             // expected
 348         }
 349         try {
 350             buffer.append(tmp, 2, 4);
 351             fail("IndexOutOfBoundsException should have been thrown");
 352         } catch (IndexOutOfBoundsException ex) {
 353             // expected
 354         }
 355     }
 356
 357 }