| /* |
| * 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.luni.tests.java.lang; |
| |
| import dalvik.annotation.KnownFailure; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargetClass; |
| |
| @TestTargetClass(StringBuffer.class) |
| public class StringBuffer2Test extends junit.framework.TestCase { |
| |
| StringBuffer testBuffer; |
| |
| /** |
| * @tests java.lang.StringBuffer#StringBuffer() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "StringBuffer", |
| args = {} |
| ) |
| public void test_Constructor() { |
| // Test for method java.lang.StringBuffer() |
| new StringBuffer(); |
| assertTrue("Invalid buffer created", true); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#StringBuffer(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "StringBuffer", |
| args = {int.class} |
| ) |
| public void test_ConstructorI() { |
| // Test for method java.lang.StringBuffer(int) |
| StringBuffer sb = new StringBuffer(8); |
| assertEquals("Newly constructed buffer is of incorrect length", 0, sb |
| .length()); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#StringBuffer(java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "StringBuffer", |
| args = {java.lang.String.class} |
| ) |
| public void test_ConstructorLjava_lang_String() { |
| // Test for method java.lang.StringBuffer(java.lang.String) |
| |
| StringBuffer sb = new StringBuffer("HelloWorld"); |
| |
| assertTrue("Invalid buffer created", sb.length() == 10 |
| && (sb.toString().equals("HelloWorld"))); |
| |
| boolean pass = false; |
| try { |
| new StringBuffer(null); |
| } catch (NullPointerException e) { |
| pass = true; |
| } |
| assertTrue("Should throw NullPointerException", pass); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(char[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "append", |
| args = {char[].class} |
| ) |
| public void test_append$C() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(char []) |
| char buf[] = new char[4]; |
| "char".getChars(0, 4, buf, 0); |
| testBuffer.append(buf); |
| assertEquals("Append of char[] failed", |
| "This is a test bufferchar", testBuffer.toString()); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(char[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "append", |
| args = {char[].class, int.class, int.class} |
| ) |
| public void test_append$CII() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(char [], int, int) |
| StringBuffer sb = new StringBuffer(); |
| char[] buf1 = { 'H', 'e', 'l', 'l', 'o' }; |
| char[] buf2 = { 'W', 'o', 'r', 'l', 'd' }; |
| sb.append(buf1, 0, buf1.length); |
| assertEquals("Buffer is invalid length after append", 5, sb.length()); |
| sb.append(buf2, 0, buf2.length); |
| assertEquals("Buffer is invalid length after append", 10, sb.length()); |
| assertTrue("Buffer contains invalid chars", (sb.toString() |
| .equals("HelloWorld"))); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(char) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "append", |
| args = {char.class} |
| ) |
| public void test_appendC() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(char) |
| StringBuffer sb = new StringBuffer(); |
| char buf1 = 'H'; |
| char buf2 = 'W'; |
| sb.append(buf1); |
| assertEquals("Buffer is invalid length after append", 1, sb.length()); |
| sb.append(buf2); |
| assertEquals("Buffer is invalid length after append", 2, sb.length()); |
| assertTrue("Buffer contains invalid chars", |
| (sb.toString().equals("HW"))); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(double) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "append", |
| args = {double.class} |
| ) |
| public void test_appendD() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(double) |
| StringBuffer sb = new StringBuffer(); |
| sb.append(Double.MAX_VALUE); |
| assertEquals("Buffer is invalid length after append", 22, sb.length()); |
| assertEquals("Buffer contains invalid characters", |
| "1.7976931348623157E308", sb.toString()); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(float) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "append", |
| args = {float.class} |
| ) |
| public void test_appendF() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(float) |
| StringBuffer sb = new StringBuffer(); |
| final float floatNum = 900.87654F; |
| sb.append(floatNum); |
| assertTrue("Buffer is invalid length after append: " + sb.length(), sb |
| .length() == String.valueOf(floatNum).length()); |
| assertTrue("Buffer contains invalid characters", sb.toString().equals( |
| String.valueOf(floatNum))); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "append", |
| args = {int.class} |
| ) |
| public void test_appendI() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(int) |
| StringBuffer sb = new StringBuffer(); |
| sb.append(9000); |
| assertEquals("Buffer is invalid length after append", 4, sb.length()); |
| sb.append(1000); |
| assertEquals("Buffer is invalid length after append", 8, sb.length()); |
| assertEquals("Buffer contains invalid characters", |
| "90001000", sb.toString()); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(long) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "append", |
| args = {long.class} |
| ) |
| public void test_appendJ() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(long) |
| |
| StringBuffer sb = new StringBuffer(); |
| long t = 927654321098L; |
| sb.append(t); |
| assertEquals("Buffer is of invlaid length", 12, sb.length()); |
| assertEquals("Buffer contains invalid characters", |
| "927654321098", sb.toString()); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(java.lang.Object) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "append", |
| args = {java.lang.Object.class} |
| ) |
| public void test_appendLjava_lang_Object() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(java.lang.Object) |
| StringBuffer sb = new StringBuffer(); |
| Object obj1 = new Object(); |
| Object obj2 = new Object(); |
| sb.append(obj1); |
| sb.append(obj2); |
| assertTrue("Buffer contains invalid characters", sb.toString().equals( |
| obj1.toString() + obj2.toString())); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "append", |
| args = {java.lang.String.class} |
| ) |
| public void test_appendLjava_lang_String() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(java.lang.String) |
| StringBuffer sb = new StringBuffer(); |
| String buf1 = "Hello"; |
| String buf2 = "World"; |
| sb.append(buf1); |
| assertEquals("Buffer is invalid length after append", 5, sb.length()); |
| sb.append(buf2); |
| assertEquals("Buffer is invalid length after append", 10, sb.length()); |
| assertTrue("Buffer contains invalid chars", (sb.toString() |
| .equals("HelloWorld"))); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#append(boolean) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "append", |
| args = {boolean.class} |
| ) |
| public void test_appendZ() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.append(boolean) |
| StringBuffer sb = new StringBuffer(); |
| sb.append(false); |
| assertEquals("Buffer is invalid length after append", 5, sb.length()); |
| sb.append(true); |
| assertEquals("Buffer is invalid length after append", 9, sb.length()); |
| assertTrue("Buffer is invalid length after append", (sb.toString() |
| .equals("falsetrue"))); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#capacity() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "capacity", |
| args = {} |
| ) |
| public void test_capacity() { |
| // Test for method int java.lang.StringBuffer.capacity() |
| StringBuffer sb = new StringBuffer(10); |
| assertEquals("Returned incorrect capacity", 10, sb.capacity()); |
| sb.ensureCapacity(100); |
| assertTrue("Returned incorrect capacity", sb.capacity() >= 100); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#charAt(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "charAt", |
| args = {int.class} |
| ) |
| public void test_charAtI() { |
| // Test for method char java.lang.StringBuffer.charAt(int) |
| assertEquals("Returned incorrect char", 's', testBuffer.charAt(3)); |
| |
| // Test for StringIndexOutOfBoundsException |
| boolean exception = false; |
| try { |
| testBuffer.charAt(-1); |
| } catch (StringIndexOutOfBoundsException e) { |
| exception = true; |
| } catch (ArrayIndexOutOfBoundsException e) { |
| } |
| assertTrue("Should throw StringIndexOutOfBoundsException", exception); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#delete(int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "delete", |
| args = {int.class, int.class} |
| ) |
| public void test_deleteII() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.delete(int, int) |
| testBuffer.delete(7, 7); |
| assertEquals("Deleted chars when start == end", "This is a test buffer", testBuffer.toString() |
| ); |
| testBuffer.delete(4, 14); |
| assertEquals("Deleted incorrect chars", |
| "This buffer", testBuffer.toString()); |
| |
| testBuffer = new StringBuffer("This is a test buffer"); |
| String sharedStr = testBuffer.toString(); |
| testBuffer.delete(0, testBuffer.length()); |
| assertEquals("Didn't clone shared buffer", "This is a test buffer", sharedStr |
| ); |
| assertTrue("Deleted incorrect chars", testBuffer.toString().equals("")); |
| testBuffer.append("more stuff"); |
| assertEquals("Didn't clone shared buffer 2", "This is a test buffer", sharedStr |
| ); |
| assertEquals("Wrong contents", "more stuff", testBuffer.toString()); |
| try { |
| testBuffer.delete(-5, 2); |
| } catch (IndexOutOfBoundsException e) { |
| } |
| assertEquals("Wrong contents 2", |
| "more stuff", testBuffer.toString()); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#deleteCharAt(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "deleteCharAt", |
| args = {int.class} |
| ) |
| public void test_deleteCharAtI() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.deleteCharAt(int) |
| testBuffer.deleteCharAt(3); |
| assertEquals("Deleted incorrect char", |
| "Thi is a test buffer", testBuffer.toString()); |
| try { |
| testBuffer.deleteCharAt(testBuffer.length() + 1); |
| fail("StringIndexOutOfBoundsException was not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.deleteCharAt(-1); |
| fail("StringIndexOutOfBoundsException was not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#ensureCapacity(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "ensureCapacity", |
| args = {int.class} |
| ) |
| public void test_ensureCapacityI() { |
| // Test for method void java.lang.StringBuffer.ensureCapacity(int) |
| StringBuffer sb = new StringBuffer(10); |
| |
| sb.ensureCapacity(-2); |
| assertEquals("Failed to increase capacity.", 10, sb.capacity()); |
| |
| sb.ensureCapacity(100); |
| assertTrue("Failed to increase capacity", sb.capacity() >= 100); |
| |
| try { |
| sb.ensureCapacity(Integer.MAX_VALUE); |
| fail("OutOfMemoryError should be thrown."); |
| } catch(java.lang.OutOfMemoryError oome) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#getChars(int, int, char[], int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't check exceptions.", |
| method = "getChars", |
| args = {int.class, int.class, char[].class, int.class} |
| ) |
| public void test_getCharsII$CI() { |
| // Test for method void java.lang.StringBuffer.getChars(int, int, char |
| // [], int) |
| |
| char[] buf = new char[10]; |
| testBuffer.getChars(4, 8, buf, 2); |
| assertTrue("Returned incorrect chars", new String(buf, 2, 4) |
| .equals(testBuffer.toString().substring(4, 8))); |
| |
| StringBuffer buf2 = new StringBuffer(""); |
| try { |
| buf2.getChars(-1, 0, new char[5], 2); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch (IndexOutOfBoundsException e) { |
| //expected |
| } |
| |
| try { |
| buf2.getChars(0, -1, new char[5], 2); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch (IndexOutOfBoundsException e) { |
| //expected |
| } |
| |
| try { |
| buf2.getChars(0, -1, new char[5], 2); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch (IndexOutOfBoundsException e) { |
| //expected |
| } |
| |
| try { |
| buf2.getChars(2, 1, new char[5], 2); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch (IndexOutOfBoundsException e) { |
| //expected |
| } |
| |
| try { |
| buf2.getChars(0, 6, new char[5], 2); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch (IndexOutOfBoundsException e) { |
| //expected |
| } |
| |
| try { |
| buf2.getChars(0, 6, new char[10], 5); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch (IndexOutOfBoundsException e) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, char[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "insert", |
| args = {int.class, char[].class} |
| ) |
| public void test_insertI$C() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, char []) |
| char buf[] = new char[4]; |
| "char".getChars(0, 4, buf, 0); |
| testBuffer.insert(15, buf); |
| assertEquals("Insert test failed", |
| "This is a test charbuffer", testBuffer.toString()); |
| |
| boolean exception = false; |
| StringBuffer buf1 = new StringBuffer("abcd"); |
| try { |
| buf1.insert(-1, (char[]) null); |
| } catch (StringIndexOutOfBoundsException e) { |
| exception = true; |
| } catch (NullPointerException e) { |
| } |
| assertTrue("Should throw StringIndexOutOfBoundsException", exception); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, char[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "insert", |
| args = {int.class, char[].class, int.class, int.class} |
| ) |
| public void test_insertI$CII() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, char [], int, int) |
| char[] c = new char[] { 'n', 'o', 't', ' ' }; |
| testBuffer.insert(8, c, 0, 4); |
| assertEquals("This is not a test buffer", testBuffer.toString()); |
| |
| StringBuffer buf1 = new StringBuffer("abcd"); |
| try { |
| buf1.insert(-1, (char[]) null, 0, 0); |
| fail("Should throw StringIndexOutOfBoundsException"); |
| } catch (StringIndexOutOfBoundsException e) { |
| //expected |
| } |
| |
| try { |
| testBuffer.insert(testBuffer.length() - 1, c, -1, 1); |
| } catch (StringIndexOutOfBoundsException e) { |
| //expected |
| } |
| |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, char) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "IndexOutOfBoundsException is not verified.", |
| method = "insert", |
| args = {int.class, char.class} |
| ) |
| public void test_insertIC() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, char) |
| testBuffer.insert(15, 'T'); |
| assertEquals("Insert test failed", |
| "This is a test Tbuffer", testBuffer.toString()); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, double) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "insert", |
| args = {int.class, double.class} |
| ) |
| public void test_insertID() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, double) |
| testBuffer.insert(15, Double.MAX_VALUE); |
| assertTrue("Insert test failed", testBuffer.toString().equals( |
| "This is a test " + Double.MAX_VALUE + "buffer")); |
| try { |
| testBuffer.insert(-1, Double.MAX_VALUE); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.insert(testBuffer.length() + 1, Double.MAX_VALUE); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, float) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "insert", |
| args = {int.class, float.class} |
| ) |
| public void test_insertIF() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, float) |
| testBuffer.insert(15, Float.MAX_VALUE); |
| String testBufferString = testBuffer.toString(); |
| String expectedResult = "This is a test " |
| + String.valueOf(Float.MAX_VALUE) + "buffer"; |
| assertTrue("Insert test failed, got: " + "\'" + testBufferString + "\'" |
| + " but wanted: " + "\'" + expectedResult + "\'", |
| testBufferString.equals(expectedResult)); |
| |
| try { |
| testBuffer.insert(-1, Float.MAX_VALUE); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.insert(testBuffer.length() + 1, Float.MAX_VALUE); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "insert", |
| args = {int.class, int.class} |
| ) |
| public void test_insertII() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, int) |
| testBuffer.insert(15, 100); |
| assertEquals("Insert test failed", |
| "This is a test 100buffer", testBuffer.toString()); |
| |
| try { |
| testBuffer.insert(-1, Integer.MAX_VALUE); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.insert(testBuffer.length() + 1, Integer.MAX_VALUE); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, long) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "insert", |
| args = {int.class, long.class} |
| ) |
| public void test_insertIJ() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, long) |
| testBuffer.insert(15, 88888888888888888L); |
| assertEquals("Insert test failed", |
| "This is a test 88888888888888888buffer", testBuffer.toString()); |
| |
| try { |
| testBuffer.insert(-1, Long.MAX_VALUE); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.insert(testBuffer.length() + 1, Long.MAX_VALUE); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, java.lang.Object) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "insert", |
| args = {int.class, java.lang.Object.class} |
| ) |
| public void test_insertILjava_lang_Object() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, java.lang.Object) |
| Object obj1 = new Object(); |
| testBuffer.insert(15, obj1); |
| assertTrue("Insert test failed", testBuffer.toString().equals( |
| "This is a test " + obj1.toString() + "buffer")); |
| |
| try { |
| testBuffer.insert(-1, obj1); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.insert(testBuffer.length() + 1, obj1); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "insert", |
| args = {int.class, java.lang.String.class} |
| ) |
| public void test_insertILjava_lang_String() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, java.lang.String) |
| |
| testBuffer.insert(15, "STRING "); |
| assertEquals("Insert test failed", |
| "This is a test STRING buffer", testBuffer.toString()); |
| |
| try { |
| testBuffer.insert(-1, ""); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.insert(testBuffer.length() + 1, ""); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#insert(int, boolean) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "insert", |
| args = {int.class, boolean.class} |
| ) |
| public void test_insertIZ() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.insert(int, boolean) |
| testBuffer.insert(15, true); |
| assertEquals("Insert test failed", |
| "This is a test truebuffer", testBuffer.toString()); |
| try { |
| testBuffer.insert(testBuffer.length() + 1, true); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.insert(-1, true); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#length() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "length", |
| args = {} |
| ) |
| public void test_length() { |
| // Test for method int java.lang.StringBuffer.length() |
| assertEquals("Incorrect length returned", 21, testBuffer.length()); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#replace(int, int, java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "replace", |
| args = {int.class, int.class, java.lang.String.class} |
| ) |
| public void test_replaceIILjava_lang_String() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.replace(int, int, java.lang.String) |
| testBuffer.replace(5, 9, "is a replaced"); |
| assertTrue("Replace failed, wanted: " + "\'" |
| + "This is a replaced test buffer" + "\'" + " but got: " + "\'" |
| + testBuffer.toString() + "\'", testBuffer.toString().equals( |
| "This is a replaced test buffer")); |
| assertEquals("insert1", "text", new StringBuffer().replace(0, 0, "text") |
| .toString()); |
| assertEquals("insert2", "123text", new StringBuffer("123").replace(3, 3, "text") |
| .toString()); |
| assertEquals("insert2", "1text23", new StringBuffer("123").replace(1, 1, "text") |
| .toString()); |
| |
| try { |
| testBuffer.replace(-1, 0, "text"); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.replace(0, -1, "text"); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.replace(2, 1, "text"); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.replace(testBuffer.length() + 1, testBuffer.length() + 1, |
| "text"); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException sioobe) { |
| //expected |
| } |
| } |
| |
| private String writeString(String in) { |
| StringBuffer result = new StringBuffer(); |
| result.append("\""); |
| for (int i = 0; i < in.length(); i++) { |
| result.append(" 0x" + Integer.toHexString(in.charAt(i))); |
| } |
| result.append("\""); |
| return result.toString(); |
| } |
| |
| private void reverseTest(String id, String org, String rev, String back) { |
| // create non-shared StringBuffer |
| StringBuffer sb = new StringBuffer(org); |
| sb.reverse(); |
| String reversed = sb.toString(); |
| assertTrue("reversed surrogate " + id + ": " + writeString(reversed), |
| reversed.equals(rev)); |
| // create non-shared StringBuffer |
| sb = new StringBuffer(reversed); |
| sb.reverse(); |
| reversed = sb.toString(); |
| assertTrue("reversed surrogate " + id + "a: " + writeString(reversed), |
| reversed.equals(back)); |
| |
| // test algorithm when StringBuffer is shared |
| sb = new StringBuffer(org); |
| String copy = sb.toString(); |
| assertEquals(org, copy); |
| sb.reverse(); |
| reversed = sb.toString(); |
| assertTrue("reversed surrogate " + id + ": " + writeString(reversed), |
| reversed.equals(rev)); |
| sb = new StringBuffer(reversed); |
| copy = sb.toString(); |
| assertEquals(rev, copy); |
| sb.reverse(); |
| reversed = sb.toString(); |
| assertTrue("reversed surrogate " + id + "a: " + writeString(reversed), |
| reversed.equals(back)); |
| |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#reverse() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "reverse", |
| args = {} |
| ) |
| public void test_reverse() { |
| // Test for method java.lang.StringBuffer |
| // java.lang.StringBuffer.reverse() |
| String org; |
| org = "a"; |
| reverseTest("0", org, org, org); |
| |
| org = "ab"; |
| reverseTest("1", org, "ba", org); |
| |
| org = "abcdef"; |
| reverseTest("2", org, "fedcba", org); |
| |
| org = "abcdefg"; |
| reverseTest("3", org, "gfedcba", org); |
| |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#setCharAt(int, char) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setCharAt", |
| args = {int.class, char.class} |
| ) |
| public void test_setCharAtIC() { |
| // Test for method void java.lang.StringBuffer.setCharAt(int, char) |
| StringBuffer s = new StringBuffer("HelloWorld"); |
| s.setCharAt(4, 'Z'); |
| assertEquals("Returned incorrect char", 'Z', s.charAt(4)); |
| |
| try { |
| s.setCharAt(-1, 'Z'); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| try { |
| s.setCharAt(s.length() + 1, 'Z'); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#setLength(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "IndexOutOfBoundsException is not verified.", |
| method = "setLength", |
| args = {int.class} |
| ) |
| public void test_setLengthI() { |
| // Test for method void java.lang.StringBuffer.setLength(int) |
| testBuffer.setLength(1000); |
| assertEquals("Failed to increase length", 1000, testBuffer.length()); |
| assertTrue("Increase in length trashed buffer", testBuffer.toString() |
| .startsWith("This is a test buffer")); |
| testBuffer.setLength(2); |
| assertEquals("Failed to decrease length", 2, testBuffer.length()); |
| assertEquals("Decrease in length failed", |
| "Th", testBuffer.toString()); |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#substring(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "substring", |
| args = {int.class} |
| ) |
| public void test_substringI() { |
| // Test for method java.lang.String |
| // java.lang.StringBuffer.substring(int) |
| assertEquals("Returned incorrect substring", "is a test buffer", |
| testBuffer.substring(5)); |
| |
| try { |
| testBuffer.substring(testBuffer.length() + 1); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException oobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.substring(-1); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException oobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#substring(int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "substring", |
| args = {int.class, int.class} |
| ) |
| public void test_substringII() { |
| // Test for method java.lang.String |
| // java.lang.StringBuffer.substring(int, int) |
| assertEquals("Returned incorrect substring", "is", |
| testBuffer.substring(5, 7)); |
| |
| try { |
| testBuffer.substring(-1, testBuffer.length()); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException oobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.substring(0, -1); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException oobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.substring(2, 1); |
| fail("StringIndexOutOfBoundsException is not thrown."); |
| } catch(StringIndexOutOfBoundsException oobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.StringBuffer#toString() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "toString", |
| args = {} |
| ) |
| public void test_toString() { |
| // Test for method java.lang.String java.lang.StringBuffer.toString() |
| assertEquals("Incorrect string value returned", "This is a test buffer", testBuffer.toString() |
| ); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "subSequence", |
| args = {int.class, int.class} |
| ) |
| public void test_subSequence() { |
| |
| assertEquals("Incorrect substring returned", " is", |
| testBuffer.subSequence(4, 7)); |
| assertEquals("Incorrect substring returned", "test buffer", |
| testBuffer.subSequence(10, 21)); |
| assertEquals("not identical", "This is a test buffer", |
| testBuffer.subSequence(0, testBuffer.length())); |
| |
| try { |
| testBuffer.subSequence(0, Integer.MAX_VALUE); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.subSequence(Integer.MAX_VALUE, testBuffer.length()); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| testBuffer.subSequence(-1, testBuffer.length()); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| } |
| |
| @Override |
| protected void setUp() { |
| testBuffer = new StringBuffer("This is a test buffer"); |
| } |
| } |
