/* 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 tests.api.java.util;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import java.util.AbstractQueue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Vector;
import junit.framework.TestCase;
@TestTargetClass(AbstractQueue.class)
public class AbstractQueueTest extends TestCase {
private MockAbstractQueue<Object> queue;
private class MockAbstractQueue<E> extends AbstractQueue<E> {
static final int CAPACITY = 10;
private int size = 0;
private Object[] elements = new Object[CAPACITY];
public Iterator<E> iterator() {
return new Iterator<E>() {
private int currentIndex = -1;
public boolean hasNext() {
return size > 0 && currentIndex < size;
}
public E next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
currentIndex++;
return (E) elements[currentIndex];
}
public void remove() {
if (-1 == currentIndex) {
throw new IllegalStateException();
}
for (int i = currentIndex; i < size - 1; i++) {
elements[i] = elements[i + 1];
}
size--;
}
};
}
public int size() {
return size;
}
public boolean offer(E o) {
if (null == o) {
throw new NullPointerException();
}
if (size >= CAPACITY) {
return false;
}
elements[size++] = o;
return true;
}
public E poll() {
if (isEmpty()) {
return null;
}
E e = (E) elements[0];
for (int i = 0; i < size - 1; i++) {
elements[i] = elements[i + 1];
}
size--;
return e;
}
public E peek() {
if (isEmpty()) {
return null;
}
return (E) elements[0];
}
}
/**
* @tests java.util.AbstractQueue.add(E)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NullPointerException.",
method = "add",
args = {java.lang.Object.class}
)
public void test_addLE_null() {
try {
queue.add(null);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
}
/**
* @tests java.util.AbstractQueue.add(E)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IllegalStateException.",
method = "add",
args = {java.lang.Object.class}
)
public void test_addLE_Full() {
Object o = new Object();
for(int i = 0; i < MockAbstractQueue.CAPACITY; i++ ) {
queue.add(o);
}
try {
queue.add(o);
fail("should throw IllegalStateException");
} catch (IllegalStateException e) {
//expected
}
}
/**
* @tests java.util.AbstractQueue#add(E)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't verify NullPointerException, IllegalStateException.",
method = "add",
args = {java.lang.Object.class}
)
public void test_addLE() {
Object o = new Object();
final int LAST_INDEX = 4;
for (int i = 0; i < LAST_INDEX; i++) {
queue.add(o);
}
Integer I = new Integer(123456);
queue.add(I);
assertTrue(queue.contains(I));
Iterator iter = queue.iterator();
for (int i = 0; i < LAST_INDEX; i++) {
iter.next();
}
assertTrue(I == iter.next());
}
/**
* @tests java.util.AbstractQueue#addAll(E)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NullPointerException.",
method = "addAll",
args = {java.util.Collection.class}
)
public void test_addAllLE_null() {
try {
queue.addAll(null);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
}
/**
* @tests java.util.AbstractQueue#addAll(E)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NullPointerException.",
method = "addAll",
args = {java.util.Collection.class}
)
public void test_addAllLE_with_null() {
List list = Arrays.asList("MYTESTSTRING", null, new Float(123.456));
try {
queue.addAll(list);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
}
/**
* @tests java.util.AbstractQueue#addAll(E)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IllegalStateException.",
method = "addAll",
args = {java.util.Collection.class}
)
public void test_addAllLE_full() {
List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
try {
queue.addAll(list);
fail("should throw IllegalStateException");
} catch (IllegalStateException e) {
// expected
}
}
/**
* @tests java.util.AbstractQueue#addAll(E)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Regression test. Doesn't verify returned true value.",
method = "addAll",
args = {java.util.Collection.class}
)
public void test_addAllLE_empty() {
// Regression test for HARMONY-1178
List list = new ArrayList<Object>(0);
assertFalse("Non modification to queue should return false", queue.addAll(list));
}
/**
* @tests java.util.AbstractQueue#addAll(E)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IllegalArgumentException.",
method = "addAll",
args = {java.util.Collection.class}
)
public void test_addAllLE_this() {
try {
queue.addAll(queue);
fail("should throw IllegalArgumentException ");
} catch (IllegalArgumentException e) {
// expected
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks functionality",
method = "addAll",
args = {java.util.Collection.class}
)
public void test_addAllLjava_lang_Object() {
Collection c = new Vector();
c.add(0);
c.add(1);
c.add(2);
c.add(3);
c.add(4);
c.add(5);
assertTrue(queue.addAll(c));
assertEquals(6, queue.size());
}
/**
* @tests java.util.AbstractQueue#clear()
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies clear method for empty queue.",
method = "clear",
args = {}
)
public void test_clear_empty() {
queue.clear();
assertTrue(queue.isEmpty());
assertNull(queue.peek());
}
/**
* @tests java.util.AbstractQueue#clear()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "clear",
args = {}
)
public void test_clear() {
List list = Arrays.asList(123.456, "MYTESTSTRING", new Object(), 'c');
queue.addAll(list);
queue.clear();
assertTrue(queue.isEmpty());
assertNull(queue.peek());
}
/**
* @tests java.util.AbstractQueue#AbstractQueue()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "AbstractQueue",
args = {}
)
public void test_Constructor() {
MockAbstractQueue queue = new MockAbstractQueue();
assertNotNull(queue);
}
/**
* @tests java.util.AbstractQueue#remove()
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NoSuchElementException.",
method = "remove",
args = {}
)
public void test_remove_null() {
try {
queue.remove();
fail("should throw NoSuchElementException");
} catch (NoSuchElementException e) {
// expected
}
}
/**
* @tests java.util.AbstractQueue#remove()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Verifies positive functionality, NoSuchElementException.",
method = "remove",
args = {}
)
public void test_remove() {
char c = 'a';
queue.add(c);
c = 'b';
queue.add(c);
assertEquals('a', queue.remove());
assertEquals('b', queue.remove());
try {
queue.remove();
fail("should throw NoSuchElementException");
} catch (NoSuchElementException e) {
// expected
}
}
/**
* @tests java.util.AbstractQueue#element()
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NoSuchElementException.",
method = "element",
args = {}
)
public void test_element_empty() {
try {
queue.element();
fail("should throw NoSuchElementException");
} catch (NoSuchElementException e) {
// expected
}
}
/**
* @tests java.util.AbstractQueue#element()
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't verify NoSuchElementException.",
method = "element",
args = {}
)
public void test_element() {
String s = "MYTESTSTRING_ONE";
queue.add(s);
s = "MYTESTSTRING_TWO";
queue.add(s);
assertEquals("MYTESTSTRING_ONE", queue.element());
// still the first element
assertEquals("MYTESTSTRING_ONE", queue.element());
}
protected void setUp() throws Exception {
super.setUp();
queue = new MockAbstractQueue<Object>();
}
protected void tearDown() throws Exception {
super.tearDown();
queue = null;
}
}
|
