// ========================================================================
// Copyright (c) 2004-2009 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
package org.eclipse.jetty.util;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import org.junit.Assume;
import org.junit.Test;
/**
* Tests for LazyList utility class.
*/
public class LazyListTest
{
public static final boolean STRICT = false;
/**
* Tests for {@link LazyList#add(Object, Object)}
*/
@Test
public void testAddObjectObject_NullInput_NullItem()
{
Object list = LazyList.add(null, null);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(1,LazyList.size(list));
}
/**
* Tests for {@link LazyList#add(Object, Object)}
*/
@Test
public void testAddObjectObject_NullInput_NonListItem()
{
String item = "a";
Object list = LazyList.add(null, item);
assertNotNull(list);
if(STRICT) {
assertTrue(list instanceof List);
}
assertEquals(1,LazyList.size(list));
}
/**
* Tests for {@link LazyList#add(Object, Object)}
*/
@Test
public void testAddObjectObject_NullInput_LazyListItem()
{
Object item = LazyList.add(null, "x");
item = LazyList.add(item,"y");
item = LazyList.add(item,"z");
Object list = LazyList.add(null, item);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(1,LazyList.size(list));
Object val = LazyList.get(list, 0);
assertTrue(val instanceof List);
}
/**
* Tests for {@link LazyList#add(Object, Object)}
*/
@Test
public void testAddObjectObject_NonListInput()
{
String input = "a";
Object list = LazyList.add(input, "b");
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(2,LazyList.size(list));
}
/**
* Tests for {@link LazyList#add(Object, Object)}
*/
@Test
public void testAddObjectObject_LazyListInput()
{
Object input = LazyList.add(null, "a");
Object list = LazyList.add(input, "b");
assertEquals(2,LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
list=LazyList.add(list, "c");
assertEquals(3,LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
assertEquals("b",LazyList.get(list,1));
assertEquals("c",LazyList.get(list,2));
}
/**
* Tests for {@link LazyList#add(Object, Object)}
*/
@Test
public void testAddObjectObject_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
Object list = LazyList.add(input, "b");
assertEquals(2,LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
list=LazyList.add(list, "c");
assertEquals(3,LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
assertEquals("b",LazyList.get(list,1));
assertEquals("c",LazyList.get(list,2));
}
/**
* Tests for {@link LazyList#add(Object, Object)}
*/
@Test
public void testAddObjectObject_AddNull()
{
Object list=null;
list=LazyList.add(list, null);
assertEquals(1,LazyList.size(list));
assertEquals(null,LazyList.get(list,0));
list="a";
list=LazyList.add(list, null);
assertEquals(2,LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
assertEquals(null,LazyList.get(list,1));
list=LazyList.add(list, null);
assertEquals(3,LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
assertEquals(null,LazyList.get(list,1));
assertEquals(null,LazyList.get(list,2));
}
/**
* Test for {@link LazyList#add(Object, int, Object)}
*/
@Test
public void testAddObjectIntObject_NullInput_NullItem()
{
Object list = LazyList.add(null, 0, null);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(1,LazyList.size(list));
}
/**
* Test for {@link LazyList#add(Object, int, Object)}
*/
@Test
public void testAddObjectIntObject_NullInput_NonListItem()
{
String item = "a";
Object list = LazyList.add(null, 0, item);
assertNotNull(list);
if(STRICT) {
assertTrue(list instanceof List);
}
assertEquals(1,LazyList.size(list));
}
/**
* Test for {@link LazyList#add(Object, int, Object)}
*/
@Test
public void testAddObjectIntObject_NullInput_NonListItem2()
{
Assume.assumeTrue(STRICT); // Only run in STRICT mode.
String item = "a";
// Test branch of logic "index>0"
Object list = LazyList.add(null, 1, item); // Always throws exception?
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(1,LazyList.size(list));
}
/**
* Test for {@link LazyList#add(Object, int, Object)}
*/
@Test
public void testAddObjectIntObject_NullInput_LazyListItem()
{
Object item = LazyList.add(null, "x");
item = LazyList.add(item,"y");
item = LazyList.add(item,"z");
Object list = LazyList.add(null, 0, item);
assertNotNull(list);
assertEquals(1,LazyList.size(list));
Object val = LazyList.get(list, 0);
assertTrue(val instanceof List);
}
/**
* Test for {@link LazyList#add(Object, int, Object)}
*/
@Test
public void testAddObjectIntObject_NullInput_GenericListItem()
{
List<String> item = new ArrayList<String>();
item.add("a");
Object list = LazyList.add(null, 0, item);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(1,LazyList.size(list));
}
/**
* Test for {@link LazyList#add(Object, int, Object)}
*/
@Test
public void testAddObjectIntObject_NonListInput_NullItem()
{
String input = "a";
Object list = LazyList.add(input, 0, null);
assertNotNull(list);
assertEquals(2,LazyList.size(list));
assertEquals(null, LazyList.get(list,0));
assertEquals("a", LazyList.get(list,1));
}
/**
* Test for {@link LazyList#add(Object, int, Object)}
*/
@Test
public void testAddObjectIntObject_NonListInput_NonListItem()
{
String input = "a";
String item = "b";
Object list = LazyList.add(input, 0, item);
assertNotNull(list);
assertEquals(2, LazyList.size(list));
assertEquals("b", LazyList.get(list,0));
assertEquals("a", LazyList.get(list,1));
}
/**
* Test for {@link LazyList#add(Object, int, Object)}
*/
@Test
public void testAddObjectIntObject_LazyListInput()
{
Object list = LazyList.add(null, "c"); // [c]
list=LazyList.add(list,0,"a"); // [a, c]
list=LazyList.add(list,1,"b"); // [a, b, c]
list=LazyList.add(list,3,"d"); // [a, b, c, d]
assertEquals(4,LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
assertEquals("b",LazyList.get(list,1));
assertEquals("c",LazyList.get(list,2));
assertEquals("d",LazyList.get(list,3));
}
/**
* Test for {@link LazyList#addCollection(Object, java.util.Collection)}
*/
@Test
public void testAddCollection_NullInput()
{
Collection<?> coll = Arrays.asList("a","b","c");
Object list = LazyList.addCollection(null,coll);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
assertEquals("b",LazyList.get(list,1));
assertEquals("c",LazyList.get(list,2));
}
/**
* Test for {@link LazyList#addCollection(Object, java.util.Collection)}
*/
@Test
public void testAddCollection_NonListInput()
{
Collection<?> coll = Arrays.asList("a","b","c");
String input = "z";
Object list = LazyList.addCollection(input,coll);
assertTrue(list instanceof List);
assertEquals(4, LazyList.size(list));
assertEquals("z",LazyList.get(list,0));
assertEquals("a",LazyList.get(list,1));
assertEquals("b",LazyList.get(list,2));
assertEquals("c",LazyList.get(list,3));
}
/**
* Test for {@link LazyList#addCollection(Object, java.util.Collection)}
*/
@Test
public void testAddCollection_LazyListInput()
{
Collection<?> coll = Arrays.asList("a","b","c");
Object input = LazyList.add(null, "x");
input = LazyList.add(input, "y");
input = LazyList.add(input, "z");
Object list = LazyList.addCollection(input,coll);
assertTrue(list instanceof List);
assertEquals(6, LazyList.size(list));
assertEquals("x",LazyList.get(list,0));
assertEquals("y",LazyList.get(list,1));
assertEquals("z",LazyList.get(list,2));
assertEquals("a",LazyList.get(list,3));
assertEquals("b",LazyList.get(list,4));
assertEquals("c",LazyList.get(list,5));
}
/**
* Test for {@link LazyList#addCollection(Object, java.util.Collection)}
*/
@Test
public void testAddCollection_GenricListInput()
{
Collection<?> coll = Arrays.asList("a","b","c");
List<String> input = new ArrayList<String>();
input.add("x");
input.add("y");
input.add("z");
Object list = LazyList.addCollection(input,coll);
assertTrue(list instanceof List);
assertEquals(6, LazyList.size(list));
assertEquals("x",LazyList.get(list,0));
assertEquals("y",LazyList.get(list,1));
assertEquals("z",LazyList.get(list,2));
assertEquals("a",LazyList.get(list,3));
assertEquals("b",LazyList.get(list,4));
assertEquals("c",LazyList.get(list,5));
}
/**
* Test for {@link LazyList#addCollection(Object, java.util.Collection)}
*/
@Test
public void testAddCollection_Sequential()
{
Collection<?> coll = Arrays.asList("a","b");
Object list = null;
list = LazyList.addCollection(list,coll);
list = LazyList.addCollection(list,coll);
assertEquals(4,LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
assertEquals("b",LazyList.get(list,1));
assertEquals("a",LazyList.get(list,2));
assertEquals("b",LazyList.get(list,3));
}
/**
* Test for {@link LazyList#addCollection(Object, java.util.Collection)}
*/
@Test
public void testAddCollection_GenericListInput()
{
List<String> l=new ArrayList<String>();
l.add("a");
l.add("b");
Object list=null;
list=LazyList.addCollection(list,l);
list=LazyList.addCollection(list,l);
assertEquals(4,LazyList.size(list));
assertEquals("a",LazyList.get(list,0));
assertEquals("b",LazyList.get(list,1));
assertEquals("a",LazyList.get(list,2));
assertEquals("b",LazyList.get(list,3));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_NullInput_NullArray()
{
String arr[] = null;
Object list = LazyList.addArray(null,arr);
assertNull(list);
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_NullInput_EmptyArray()
{
String arr[] = new String[0];
Object list = LazyList.addArray(null,arr);
if(STRICT) {
assertNotNull(list);
assertTrue(list instanceof List);
}
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_NullInput_SingleArray()
{
String arr[] = new String[] { "a" };
Object list = LazyList.addArray(null,arr);
assertNotNull(list);
if(STRICT) {
assertTrue(list instanceof List);
}
assertEquals(1, LazyList.size(list));
assertEquals("a", LazyList.get(list,0));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_NullInput_Array()
{
String arr[] = new String[] { "a", "b", "c" };
Object list = LazyList.addArray(null,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("a", LazyList.get(list,0));
assertEquals("b", LazyList.get(list,1));
assertEquals("c", LazyList.get(list,2));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_NonListInput_NullArray()
{
String input = "z";
String arr[] = null;
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
if(STRICT) {
assertTrue(list instanceof List);
}
assertEquals(1, LazyList.size(list));
assertEquals("z", LazyList.get(list,0));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_NonListInput_EmptyArray()
{
String input = "z";
String arr[] = new String[0];
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
if(STRICT) {
assertTrue(list instanceof List);
}
assertEquals(1, LazyList.size(list));
assertEquals("z", LazyList.get(list,0));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_NonListInput_SingleArray()
{
String input = "z";
String arr[] = new String[] { "a" };
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(2, LazyList.size(list));
assertEquals("z", LazyList.get(list,0));
assertEquals("a", LazyList.get(list,1));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_NonListInput_Array()
{
String input = "z";
String arr[] = new String[] { "a", "b", "c" };
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(4, LazyList.size(list));
assertEquals("z", LazyList.get(list,0));
assertEquals("a", LazyList.get(list,1));
assertEquals("b", LazyList.get(list,2));
assertEquals("c", LazyList.get(list,3));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_LazyListInput_NullArray()
{
Object input = LazyList.add(null,"x");
input = LazyList.add(input,"y");
input = LazyList.add(input,"z");
String arr[] = null;
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("x", LazyList.get(list,0));
assertEquals("y", LazyList.get(list,1));
assertEquals("z", LazyList.get(list,2));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_LazyListInput_EmptyArray()
{
Object input = LazyList.add(null,"x");
input = LazyList.add(input,"y");
input = LazyList.add(input,"z");
String arr[] = new String[0];
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("x", LazyList.get(list,0));
assertEquals("y", LazyList.get(list,1));
assertEquals("z", LazyList.get(list,2));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_LazyListInput_SingleArray()
{
Object input = LazyList.add(null,"x");
input = LazyList.add(input,"y");
input = LazyList.add(input,"z");
String arr[] = new String[] { "a" };
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(4, LazyList.size(list));
assertEquals("x", LazyList.get(list,0));
assertEquals("y", LazyList.get(list,1));
assertEquals("z", LazyList.get(list,2));
assertEquals("a", LazyList.get(list,3));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_LazyListInput_Array()
{
Object input = LazyList.add(null,"x");
input = LazyList.add(input,"y");
input = LazyList.add(input,"z");
String arr[] = new String[] { "a", "b", "c" };
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(6, LazyList.size(list));
assertEquals("x", LazyList.get(list,0));
assertEquals("y", LazyList.get(list,1));
assertEquals("z", LazyList.get(list,2));
assertEquals("a", LazyList.get(list,3));
assertEquals("b", LazyList.get(list,4));
assertEquals("c", LazyList.get(list,5));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_GenericListInput_NullArray()
{
List<String> input = new ArrayList<String>();
input.add("x");
input.add("y");
input.add("z");
String arr[] = null;
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("x", LazyList.get(list,0));
assertEquals("y", LazyList.get(list,1));
assertEquals("z", LazyList.get(list,2));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_GenericListInput_EmptyArray()
{
List<String> input = new ArrayList<String>();
input.add("x");
input.add("y");
input.add("z");
String arr[] = new String[0];
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("x", LazyList.get(list,0));
assertEquals("y", LazyList.get(list,1));
assertEquals("z", LazyList.get(list,2));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_GenericListInput_SingleArray()
{
List<String> input = new ArrayList<String>();
input.add("x");
input.add("y");
input.add("z");
String arr[] = new String[] { "a" };
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(4, LazyList.size(list));
assertEquals("x", LazyList.get(list,0));
assertEquals("y", LazyList.get(list,1));
assertEquals("z", LazyList.get(list,2));
assertEquals("a", LazyList.get(list,3));
}
/**
* Tests for {@link LazyList#addArray(Object, Object[])}
*/
@Test
public void testAddArray_GenericListInput_Array()
{
List<String> input = new ArrayList<String>();
input.add("x");
input.add("y");
input.add("z");
String arr[] = new String[] { "a", "b", "c" };
Object list = LazyList.addArray(input,arr);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(6, LazyList.size(list));
assertEquals("x", LazyList.get(list,0));
assertEquals("y", LazyList.get(list,1));
assertEquals("z", LazyList.get(list,2));
assertEquals("a", LazyList.get(list,3));
assertEquals("b", LazyList.get(list,4));
assertEquals("c", LazyList.get(list,5));
}
/**
* Tests for {@link LazyList#ensureSize(Object, int)}
*/
@Test
public void testEnsureSize_NullInput()
{
Object list = LazyList.ensureSize(null,10);
assertNotNull(list);
assertTrue(list instanceof List);
// Not possible to test for List capacity value.
}
/**
* Tests for {@link LazyList#ensureSize(Object, int)}
*/
@Test
public void testEnsureSize_NonListInput()
{
String input = "a";
Object list = LazyList.ensureSize(input,10);
assertNotNull(list);
assertTrue(list instanceof List);
// Not possible to test for List capacity value.
assertEquals(1, LazyList.size(list));
assertEquals("a", LazyList.get(list,0));
}
/**
* Tests for {@link LazyList#ensureSize(Object, int)}
*/
@Test
public void testEnsureSize_LazyListInput()
{
Object input = LazyList.add(null, "a");
input = LazyList.add(input,"b");
Object list = LazyList.ensureSize(input,10);
assertNotNull(list);
assertTrue(list instanceof List);
// Not possible to test for List capacity value.
assertEquals(2, LazyList.size(list));
assertEquals("a", LazyList.get(list,0));
assertEquals("b", LazyList.get(list,1));
}
/**
* Tests for {@link LazyList#ensureSize(Object, int)}
*/
@Test
public void testEnsureSize_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
input.add("b");
Object list = LazyList.ensureSize(input,10);
assertNotNull(list);
assertTrue(list instanceof List);
// Not possible to test for List capacity value.
assertEquals(2, LazyList.size(list));
assertEquals("a", LazyList.get(list,0));
assertEquals("b", LazyList.get(list,1));
}
/**
* Tests for {@link LazyList#ensureSize(Object, int)}
*/
@Test
public void testEnsureSize_GenericListInput_LinkedList()
{
Assume.assumeTrue(STRICT); // Only run in STRICT mode.
// Using LinkedList concrete type as LazyList internal
// implementation does not look for this specifically.
List<String> input = new LinkedList<String>();
input.add("a");
input.add("b");
Object list = LazyList.ensureSize(input,10);
assertNotNull(list);
assertTrue(list instanceof List);
// Not possible to test for List capacity value.
assertEquals(2, LazyList.size(list));
assertEquals("a", LazyList.get(list,0));
assertEquals("b", LazyList.get(list,1));
}
/**
* Tests for {@link LazyList#ensureSize(Object, int)}
*/
@Test
public void testEnsureSize_Growth()
{
List<String> l = new ArrayList<String>();
l.add("a");
l.add("b");
l.add("c");
// NOTE: Testing for object equality might be viewed as
// fragile by most developers, however, for this
// specific implementation, we don't want the
// provided list to change if the size requirements
// have been met.
// Trigger growth
Object ret = LazyList.ensureSize(l,10);
assertTrue("Should have returned a new list object", ret != l);
// Growth not neeed.
ret = LazyList.ensureSize(l,1);
assertTrue("Should have returned same list object", ret == l);
}
/**
* Tests for {@link LazyList#ensureSize(Object, int)}
*/
@Test
public void testEnsureSize_Growth_LinkedList()
{
Assume.assumeTrue(STRICT); // Only run in STRICT mode.
// Using LinkedList concrete type as LazyList internal
// implementation has not historically looked for this
// specifically.
List<String> l = new LinkedList<String>();
l.add("a");
l.add("b");
l.add("c");
// NOTE: Testing for object equality might be viewed as
// fragile by most developers, however, for this
// specific implementation, we don't want the
// provided list to change if the size requirements
// have been met.
// Trigger growth
Object ret = LazyList.ensureSize(l,10);
assertTrue("Should have returned a new list object", ret != l);
// Growth not neeed.
ret = LazyList.ensureSize(l,1);
assertTrue("Should have returned same list object", ret == l);
}
/**
* Test for {@link LazyList#remove(Object, Object)}
*/
@Test
public void testRemoveObjectObject_NullInput()
{
Object input = null;
assertNull(LazyList.remove(input,null));
assertNull(LazyList.remove(input,"a"));
assertNull(LazyList.remove(input,new ArrayList<Object>()));
assertNull(LazyList.remove(input,Integer.valueOf(42)));
}
/**
* Test for {@link LazyList#remove(Object, Object)}
*/
@Test
public void testRemoveObjectObject_NonListInput()
{
String input = "a";
// Remove null item
Object list = LazyList.remove(input, null);
assertNotNull(list);
if(STRICT) {
assertTrue(list instanceof List);
}
assertEquals(1, LazyList.size(list));
// Remove item that doesn't exist
list = LazyList.remove(input, "b");
assertNotNull(list);
if(STRICT) {
assertTrue(list instanceof List);
}
assertEquals(1, LazyList.size(list));
// Remove item that exists
list = LazyList.remove(input, "a");
// TODO: should this be null? or an empty list?
assertNull(list); // nothing left in list
assertEquals(0, LazyList.size(list));
}
/**
* Test for {@link LazyList#remove(Object, Object)}
*/
@Test
public void testRemoveObjectObject_LazyListInput()
{
Object input = LazyList.add(null, "a");
input = LazyList.add(input, "b");
input = LazyList.add(input, "c");
// Remove null item
Object list = LazyList.remove(input, null);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
// Attempt to remove something that doesn't exist
list = LazyList.remove(input, "z");
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
// Remove something that exists in input
list = LazyList.remove(input, "b");
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(2, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("c", LazyList.get(list, 1));
}
/**
* Test for {@link LazyList#remove(Object, Object)}
*/
@Test
public void testRemoveObjectObject_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
input.add("b");
input.add("c");
// Remove null item
Object list = LazyList.remove(input, null);
assertNotNull(list);
assertTrue(list instanceof List);
assertTrue("Should not have recreated list obj", input == list);
assertEquals(3, LazyList.size(list));
// Attempt to remove something that doesn't exist
list = LazyList.remove(input, "z");
assertNotNull(list);
assertTrue(list instanceof List);
assertTrue("Should not have recreated list obj", input == list);
assertEquals(3, LazyList.size(list));
// Remove something that exists in input
list = LazyList.remove(input, "b");
assertNotNull(list);
assertTrue(list instanceof List);
assertTrue("Should not have recreated list obj", input == list);
assertEquals(2, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("c", LazyList.get(list, 1));
// Try to remove the rest.
list = LazyList.remove(list,"a");
list = LazyList.remove(list,"c");
assertNull(list);
}
/**
* Test for {@link LazyList#remove(Object, Object)}
*/
@Test
public void testRemoveObjectObject_LinkedListInput()
{
// Should be able to use any collection object.
List<String> input = new LinkedList<String>();
input.add("a");
input.add("b");
input.add("c");
// Remove null item
Object list = LazyList.remove(input, null);
assertNotNull(list);
assertTrue(list instanceof List);
assertTrue("Should not have recreated list obj", input == list);
assertEquals(3, LazyList.size(list));
// Attempt to remove something that doesn't exist
list = LazyList.remove(input, "z");
assertNotNull(list);
assertTrue(list instanceof List);
assertTrue("Should not have recreated list obj", input == list);
assertEquals(3, LazyList.size(list));
// Remove something that exists in input
list = LazyList.remove(input, "b");
assertNotNull(list);
assertTrue(list instanceof List);
assertTrue("Should not have recreated list obj", input == list);
assertEquals(2, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("c", LazyList.get(list, 1));
}
/**
* Tests for {@link LazyList#remove(Object, int)}
*/
@Test
public void testRemoveObjectInt_NullInput()
{
Object input = null;
assertNull(LazyList.remove(input,0));
assertNull(LazyList.remove(input,2));
assertNull(LazyList.remove(input,-2));
}
/**
* Tests for {@link LazyList#remove(Object, int)}
*/
@Test
public void testRemoveObjectInt_NonListInput()
{
String input = "a";
// Invalid index
Object list = LazyList.remove(input, 1);
assertNotNull(list);
if(STRICT) {
assertTrue(list instanceof List);
}
assertEquals(1, LazyList.size(list));
// Valid index
list = LazyList.remove(input, 0);
// TODO: should this be null? or an empty list?
assertNull(list); // nothing left in list
assertEquals(0, LazyList.size(list));
}
/**
* Tests for {@link LazyList#remove(Object, int)}
*/
@Test
public void testRemoveObjectInt_LazyListInput()
{
Object input = LazyList.add(null, "a");
input = LazyList.add(input, "b");
input = LazyList.add(input, "c");
Object list = null;
if (STRICT)
{
// Invalid index
// Shouldn't cause a IndexOutOfBoundsException as this is not the
// same behavior you experience in testRemoveObjectInt_NonListInput and
// testRemoveObjectInt_NullInput when using invalid indexes.
list = LazyList.remove(input,5);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
}
// Valid index
list = LazyList.remove(input, 1); // remove the 'b'
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(2, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("c", LazyList.get(list, 1));
}
/**
* Tests for {@link LazyList#remove(Object, int)}
*/
@Test
public void testRemoveObjectInt_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
input.add("b");
input.add("c");
Object list = null;
if (STRICT)
{
// Invalid index
// Shouldn't cause a IndexOutOfBoundsException as this is not the
// same behavior you experience in testRemoveObjectInt_NonListInput and
// testRemoveObjectInt_NullInput when using invalid indexes.
list = LazyList.remove(input,5);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
}
// Valid index
list = LazyList.remove(input, 1); // remove the 'b'
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(2, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("c", LazyList.get(list, 1));
// Remove the rest
list = LazyList.remove(list, 0); // the 'a'
list = LazyList.remove(list, 0); // the 'c'
assertNull(list);
}
/**
* Test for {@link LazyList#getList(Object)}
*/
@Test
public void testGetListObject_NullInput()
{
Object input = null;
Object list = LazyList.getList(input);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(0, LazyList.size(list));
}
/**
* Test for {@link LazyList#getList(Object)}
*/
@Test
public void testGetListObject_NonListInput()
{
String input = "a";
Object list = LazyList.getList(input);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(1, LazyList.size(list));
}
/**
* Test for {@link LazyList#getList(Object)}
*/
@Test
public void testGetListObject_LazyListInput()
{
Object input = LazyList.add(null, "a");
input = LazyList.add(input, "b");
input = LazyList.add(input, "c");
Object list = LazyList.getList(input);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("b", LazyList.get(list, 1));
assertEquals("c", LazyList.get(list, 2));
}
/**
* Test for {@link LazyList#getList(Object)}
*/
@Test
public void testGetListObject_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
input.add("b");
input.add("c");
Object list = LazyList.getList(input);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("b", LazyList.get(list, 1));
assertEquals("c", LazyList.get(list, 2));
}
/**
* Test for {@link LazyList#getList(Object)}
*/
@Test
public void testGetListObject_LinkedListInput()
{
List<String> input = new LinkedList<String>();
input.add("a");
input.add("b");
input.add("c");
Object list = LazyList.getList(input);
assertNotNull(list);
assertTrue(list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("b", LazyList.get(list, 1));
assertEquals("c", LazyList.get(list, 2));
}
/**
* Test for {@link LazyList#getList(Object)}
*/
@Test
public void testGetListObject_NullForEmpty()
{
assertNull(LazyList.getList(null, true));
assertNotNull(LazyList.getList(null, false));
}
/**
* Tests for {@link LazyList#toStringArray(Object)}
*/
@Test
@SuppressWarnings("unchecked")
public void testToStringArray()
{
assertEquals(0,LazyList.toStringArray(null).length);
assertEquals(1,LazyList.toStringArray("a").length);
assertEquals("a",LazyList.toStringArray("a")[0]);
@SuppressWarnings("rawtypes")
ArrayList l=new ArrayList();
l.add("a");
l.add(null);
l.add(new Integer(2));
String[] a=LazyList.toStringArray(l);
assertEquals(3,a.length);
assertEquals("a",a[0]);
assertEquals(null,a[1]);
assertEquals("2",a[2]);
}
/**
* Tests for {@link LazyList#toArray(Object, Class)}
*/
@Test
public void testToArray_NullInput_Object() {
Object input = null;
Object arr = LazyList.toArray(input,Object.class);
assertNotNull(arr);
assertTrue(arr.getClass().isArray());
}
/**
* Tests for {@link LazyList#toArray(Object, Class)}
*/
@Test
public void testToArray_NullInput_String() {
String input = null;
Object arr = LazyList.toArray(input,String.class);
assertNotNull(arr);
assertTrue(arr.getClass().isArray());
assertTrue(arr instanceof String[]);
}
/**
* Tests for {@link LazyList#toArray(Object, Class)}
*/
@Test
public void testToArray_NonListInput() {
String input = "a";
Object arr = LazyList.toArray(input,String.class);
assertNotNull(arr);
assertTrue(arr.getClass().isArray());
assertTrue(arr instanceof String[]);
String strs[] = (String[])arr;
assertEquals(1, strs.length);
assertEquals("a", strs[0]);
}
/**
* Tests for {@link LazyList#toArray(Object, Class)}
*/
@Test
public void testToArray_LazyListInput() {
Object input = LazyList.add(null, "a");
input = LazyList.add(input, "b");
input = LazyList.add(input, "c");
Object arr = LazyList.toArray(input,String.class);
assertNotNull(arr);
assertTrue(arr.getClass().isArray());
assertTrue(arr instanceof String[]);
String strs[] = (String[])arr;
assertEquals(3, strs.length);
assertEquals("a", strs[0]);
assertEquals("b", strs[1]);
assertEquals("c", strs[2]);
}
/**
* Tests for {@link LazyList#toArray(Object, Class)}
*/
@Test
public void testToArray_LazyListInput_Primitives() {
Object input = LazyList.add(null, 22);
input = LazyList.add(input, 333);
input = LazyList.add(input, 4444);
input = LazyList.add(input, 55555);
Object arr = LazyList.toArray(input,int.class);
assertNotNull(arr);
assertTrue(arr.getClass().isArray());
assertTrue(arr instanceof int[]);
int nums[] = (int[])arr;
assertEquals(4, nums.length);
assertEquals(22, nums[0]);
assertEquals(333, nums[1]);
assertEquals(4444, nums[2]);
assertEquals(55555, nums[3]);
}
/**
* Tests for {@link LazyList#toArray(Object, Class)}
*/
@Test
public void testToArray_GenericListInput() {
List<String> input = new ArrayList<String>();
input.add("a");
input.add("b");
input.add("c");
Object arr = LazyList.toArray(input,String.class);
assertNotNull(arr);
assertTrue(arr.getClass().isArray());
assertTrue(arr instanceof String[]);
String strs[] = (String[])arr;
assertEquals(3, strs.length);
assertEquals("a", strs[0]);
assertEquals("b", strs[1]);
assertEquals("c", strs[2]);
}
/**
* Tests for {@link LazyList#size(Object)}
*/
@Test
public void testSize_NullInput()
{
assertEquals(0, LazyList.size(null));
}
/**
* Tests for {@link LazyList#size(Object)}
*/
@Test
public void testSize_NonListInput()
{
String input = "a";
assertEquals(1, LazyList.size(input));
}
/**
* Tests for {@link LazyList#size(Object)}
*/
@Test
public void testSize_LazyListInput()
{
Object input = LazyList.add(null,"a");
input = LazyList.add(input,"b");
assertEquals(2, LazyList.size(input));
input = LazyList.add(input,"c");
assertEquals(3, LazyList.size(input));
}
/**
* Tests for {@link LazyList#size(Object)}
*/
@Test
public void testSize_GenericListInput()
{
List<String> input = new ArrayList<String>();
assertEquals(0, LazyList.size(input));
input.add("a");
input.add("b");
assertEquals(2, LazyList.size(input));
input.add("c");
assertEquals(3, LazyList.size(input));
}
/**
* Tests for bad input on {@link LazyList#get(Object, int)}
*/
@Test(expected=IndexOutOfBoundsException.class)
public void testGet_OutOfBounds_NullInput()
{
LazyList.get(null,0); // Should Fail due to null input
}
/**
* Tests for bad input on {@link LazyList#get(Object, int)}
*/
@Test(expected=IndexOutOfBoundsException.class)
public void testGet_OutOfBounds_NonListInput()
{
String input = "a";
LazyList.get(input,1); // Should Fail
}
/**
* Tests for bad input on {@link LazyList#get(Object, int)}
*/
@Test(expected=IndexOutOfBoundsException.class)
public void testGet_OutOfBounds_LazyListInput()
{
Object input = LazyList.add(null,"a");
LazyList.get(input,1); // Should Fail
}
/**
* Tests for bad input on {@link LazyList#get(Object, int)}
*/
@Test(expected=IndexOutOfBoundsException.class)
public void testGet_OutOfBounds_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
LazyList.get(input,1); // Should Fail
}
/**
* Tests for non-list input on {@link LazyList#get(Object, int)}
*/
@Test
public void testGet_NonListInput()
{
String input = "a";
assertEquals("a",LazyList.get(input,0));
}
/**
* Tests for list input on {@link LazyList#get(Object, int)}
*/
@Test
public void testGet_LazyListInput()
{
Object input = LazyList.add(null,"a");
assertEquals("a",LazyList.get(input,0));
}
/**
* Tests for list input on {@link LazyList#get(Object, int)}
*/
@Test
public void testGet_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
assertEquals("a",LazyList.get(input,0));
List<URI> uris = new ArrayList<URI>();
uris.add(URI.create("http://www.mortbay.org/"));
uris.add(URI.create("http://jetty.codehaus.org/jetty/"));
uris.add(URI.create("http://www.intalio.com/jetty/"));
uris.add(URI.create("http://www.eclipse.org/jetty/"));
// Make sure that Generics pass through the 'get' routine safely.
// We should be able to call this without casting the result to URI
URI eclipseUri = LazyList.get(uris, 3);
assertEquals("http://www.eclipse.org/jetty/", eclipseUri.toASCIIString());
}
/**
* Tests for {@link LazyList#contains(Object, Object)}
*/
@Test
public void testContains_NullInput()
{
assertFalse(LazyList.contains(null, "z"));
}
/**
* Tests for {@link LazyList#contains(Object, Object)}
*/
@Test
public void testContains_NonListInput()
{
String input = "a";
assertFalse(LazyList.contains(input, "z"));
assertTrue(LazyList.contains(input, "a"));
}
/**
* Tests for {@link LazyList#contains(Object, Object)}
*/
@Test
public void testContains_LazyListInput()
{
Object input = LazyList.add(null,"a");
input = LazyList.add(input,"b");
input = LazyList.add(input,"c");
assertFalse(LazyList.contains(input, "z"));
assertTrue(LazyList.contains(input, "a"));
assertTrue(LazyList.contains(input, "b"));
}
/**
* Tests for {@link LazyList#contains(Object, Object)}
*/
@Test
public void testContains_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
input.add("b");
input.add("c");
assertFalse(LazyList.contains(input, "z"));
assertTrue(LazyList.contains(input, "a"));
assertTrue(LazyList.contains(input, "b"));
}
/**
* Tests for {@link LazyList#clone(Object)}
*/
@Test
public void testClone_NullInput()
{
Object input = null;
Object list = LazyList.clone(input);
assertNull(list);
}
/**
* Tests for {@link LazyList#clone(Object)}
*/
@Test
public void testClone_NonListInput()
{
String input = "a";
Object list = LazyList.clone(input);
assertNotNull(list);
assertTrue("Should be the same object", input == list);
}
/**
* Tests for {@link LazyList#clone(Object)}
*/
@Test
public void testClone_LazyListInput()
{
Object input = LazyList.add(null,"a");
input = LazyList.add(input,"b");
input = LazyList.add(input,"c");
Object list = LazyList.clone(input);
assertNotNull(list);
assertTrue("Should be a List object", list instanceof List);
assertFalse("Should NOT be the same object", input == list);
assertEquals(3, LazyList.size(list));
assertEquals("a", LazyList.get(list,0));
assertEquals("b", LazyList.get(list,1));
assertEquals("c", LazyList.get(list,2));
}
/**
* Tests for {@link LazyList#clone(Object)}
*/
@Test
public void testClone_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
input.add("b");
input.add("c");
// TODO: decorate the .clone(Object) method to return
// the same generic object element type
Object list = LazyList.clone(input);
assertNotNull(list);
assertTrue("Should be a List object", list instanceof List);
assertFalse("Should NOT be the same object", input == list);
assertEquals(3, LazyList.size(list));
assertEquals("a", LazyList.get(list,0));
assertEquals("b", LazyList.get(list,1));
assertEquals("c", LazyList.get(list,2));
}
/**
* Tests for {@link LazyList#toString(Object)}
*/
@Test
public void testToString_NullInput()
{
Object input = null;
assertEquals("[]", LazyList.toString(input));
}
/**
* Tests for {@link LazyList#toString(Object)}
*/
@Test
public void testToString_NonListInput()
{
String input = "a";
assertEquals("[a]", LazyList.toString(input));
}
/**
* Tests for {@link LazyList#toString(Object)}
*/
@Test
public void testToString_LazyListInput()
{
Object input = LazyList.add(null,"a");
assertEquals("[a]", LazyList.toString(input));
input = LazyList.add(input,"b");
input = LazyList.add(input,"c");
assertEquals("[a, b, c]", LazyList.toString(input));
}
/**
* Tests for {@link LazyList#toString(Object)}
*/
@Test
public void testToString_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
assertEquals("[a]", LazyList.toString(input));
input.add("b");
input.add("c");
assertEquals("[a, b, c]", LazyList.toString(input));
}
/**
* Tests for {@link LazyList#iterator(Object)}
*/
@Test
public void testIterator_NullInput()
{
Iterator<?> iter = LazyList.iterator(null);
assertNotNull(iter);
assertFalse(iter.hasNext());
}
/**
* Tests for {@link LazyList#iterator(Object)}
*/
@Test
public void testIterator_NonListInput()
{
String input = "a";
Iterator<?> iter = LazyList.iterator(input);
assertNotNull(iter);
assertTrue(iter.hasNext());
assertEquals("a", iter.next());
assertFalse(iter.hasNext());
}
/**
* Tests for {@link LazyList#iterator(Object)}
*/
@Test
public void testIterator_LazyListInput()
{
Object input = LazyList.add(null,"a");
input = LazyList.add(input,"b");
input = LazyList.add(input,"c");
Iterator<?> iter = LazyList.iterator(input);
assertNotNull(iter);
assertTrue(iter.hasNext());
assertEquals("a", iter.next());
assertEquals("b", iter.next());
assertEquals("c", iter.next());
assertFalse(iter.hasNext());
}
/**
* Tests for {@link LazyList#iterator(Object)}
*/
@Test
public void testIterator_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
input.add("b");
input.add("c");
Iterator<String> iter = LazyList.iterator(input);
assertNotNull(iter);
assertTrue(iter.hasNext());
assertEquals("a", iter.next());
assertEquals("b", iter.next());
assertEquals("c", iter.next());
assertFalse(iter.hasNext());
}
/**
* Tests for {@link LazyList#listIterator(Object)}
*/
@Test
public void testListIterator_NullInput()
{
ListIterator<?> iter = LazyList.listIterator(null);
assertNotNull(iter);
assertFalse(iter.hasNext());
assertFalse(iter.hasPrevious());
}
/**
* Tests for {@link LazyList#listIterator(Object)}
*/
@Test
public void testListIterator_NonListInput()
{
String input = "a";
ListIterator<?> iter = LazyList.listIterator(input);
assertNotNull(iter);
assertTrue(iter.hasNext());
assertFalse(iter.hasPrevious());
assertEquals("a", iter.next());
assertFalse(iter.hasNext());
assertTrue(iter.hasPrevious());
}
/**
* Tests for {@link LazyList#listIterator(Object)}
*/
@Test
public void testListIterator_LazyListInput()
{
Object input = LazyList.add(null,"a");
input = LazyList.add(input,"b");
input = LazyList.add(input,"c");
ListIterator<?> iter = LazyList.listIterator(input);
assertNotNull(iter);
assertTrue(iter.hasNext());
assertFalse(iter.hasPrevious());
assertEquals("a", iter.next());
assertEquals("b", iter.next());
assertEquals("c", iter.next());
assertFalse(iter.hasNext());
assertTrue(iter.hasPrevious());
assertEquals("c", iter.previous());
assertEquals("b", iter.previous());
assertEquals("a", iter.previous());
assertFalse(iter.hasPrevious());
}
/**
* Tests for {@link LazyList#listIterator(Object)}
*/
@Test
public void testListIterator_GenericListInput()
{
List<String> input = new ArrayList<String>();
input.add("a");
input.add("b");
input.add("c");
ListIterator<?> iter = LazyList.listIterator(input);
assertNotNull(iter);
assertTrue(iter.hasNext());
assertFalse(iter.hasPrevious());
assertEquals("a", iter.next());
assertEquals("b", iter.next());
assertEquals("c", iter.next());
assertFalse(iter.hasNext());
assertTrue(iter.hasPrevious());
assertEquals("c", iter.previous());
assertEquals("b", iter.previous());
assertEquals("a", iter.previous());
assertFalse(iter.hasPrevious());
}
/**
* Tests for {@link LazyList#array2List(Object[])}
*/
@Test
public void testArray2List_NullInput()
{
Object input[] = null;
Object list = LazyList.array2List(input);
assertNotNull(list);
assertTrue("Should be a List object", list instanceof List);
assertEquals(0, LazyList.size(list));
}
/**
* Tests for {@link LazyList#array2List(Object[])}
*/
@Test
public void testArray2List_EmptyInput()
{
String input[] = new String[0];
Object list = LazyList.array2List(input);
assertNotNull(list);
assertTrue("Should be a List object", list instanceof List);
assertEquals(0, LazyList.size(list));
}
/**
* Tests for {@link LazyList#array2List(Object[])}
*/
@Test
public void testArray2List_SingleInput()
{
String input[] = new String[] { "a" };
Object list = LazyList.array2List(input);
assertNotNull(list);
assertTrue("Should be a List object", list instanceof List);
assertEquals(1, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
}
/**
* Tests for {@link LazyList#array2List(Object[])}
*/
@Test
public void testArray2List_MultiInput()
{
String input[] = new String[] { "a", "b", "c" };
Object list = LazyList.array2List(input);
assertNotNull(list);
assertTrue("Should be a List object", list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("b", LazyList.get(list, 1));
assertEquals("c", LazyList.get(list, 2));
}
/**
* Tests for {@link LazyList#array2List(Object[])}
*/
@Test
public void testArray2List_GenericsInput()
{
String input[] = new String[] { "a", "b", "c" };
// Test the Generics definitions for array2List
List<String> list = LazyList.array2List(input);
assertNotNull(list);
assertTrue("Should be a List object", list instanceof List);
assertEquals(3, LazyList.size(list));
assertEquals("a", LazyList.get(list, 0));
assertEquals("b", LazyList.get(list, 1));
assertEquals("c", LazyList.get(list, 2));
}
/**
* Tests for {@link LazyList#addToArray(Object[], Object, Class)}
*/
@Test
public void testAddToArray_NullInput_NullItem()
{
Object input[] = null;
Object arr[] = LazyList.addToArray(input,null,Object.class);
assertNotNull(arr);
if(STRICT) {
// Adding null item to array should result in nothing added?
assertEquals(0, arr.length);
} else {
assertEquals(1, arr.length);
}
}
/**
* Tests for {@link LazyList#addToArray(Object[], Object, Class)}
*/
@Test
public void testAddToArray_NullNullNull()
{
// NPE if item && type are both null.
Assume.assumeTrue(STRICT);
// Harsh test case.
Object input[] = null;
Object arr[] = LazyList.addToArray(input,null,null);
assertNotNull(arr);
if(STRICT) {
// Adding null item to array should result in nothing added?
assertEquals(0, arr.length);
} else {
assertEquals(1, arr.length);
}
}
/**
* Tests for {@link LazyList#addToArray(Object[], Object, Class)}
*/
@Test
public void testAddToArray_NullInput_SimpleItem()
{
Object input[] = null;
Object arr[] = LazyList.addToArray(input,"a",String.class);
assertNotNull(arr);
assertEquals(1, arr.length);
assertEquals("a", arr[0]);
// Same test, but with an undefined type
arr = LazyList.addToArray(input,"b",null);
assertNotNull(arr);
assertEquals(1, arr.length);
assertEquals("b", arr[0]);
}
/**
* Tests for {@link LazyList#addToArray(Object[], Object, Class)}
*/
@Test
public void testAddToArray_EmptyInput_NullItem()
{
String input[] = new String[0];
String arr[] = LazyList.addToArray(input,null,Object.class);
assertNotNull(arr);
if(STRICT) {
// Adding null item to array should result in nothing added?
assertEquals(0, arr.length);
} else {
assertEquals(1, arr.length);
}
}
/**
* Tests for {@link LazyList#addToArray(Object[], Object, Class)}
*/
@Test
public void testAddToArray_EmptyInput_SimpleItem()
{
String input[] = new String[0];
String arr[] = LazyList.addToArray(input,"a",String.class);
assertNotNull(arr);
assertEquals(1, arr.length);
assertEquals("a", arr[0]);
}
/**
* Tests for {@link LazyList#addToArray(Object[], Object, Class)}
*/
@Test
public void testAddToArray_SingleInput_NullItem()
{
String input[] = new String[] { "z" };
String arr[] = LazyList.addToArray(input,null,Object.class);
assertNotNull(arr);
if(STRICT) {
// Should a null item be added to an array?
assertEquals(1, arr.length);
} else {
assertEquals(2, arr.length);
assertEquals("z", arr[0]);
assertEquals(null, arr[1]);
}
}
/**
* Tests for {@link LazyList#addToArray(Object[], Object, Class)}
*/
@Test
public void testAddToArray_SingleInput_SimpleItem()
{
String input[] = new String[] { "z" };
String arr[] = LazyList.addToArray(input,"a",String.class);
assertNotNull(arr);
assertEquals(2, arr.length);
assertEquals("z", arr[0]);
assertEquals("a", arr[1]);
}
/**
* Tests for {@link LazyList#removeFromArray(Object[], Object)}
*/
@Test
public void testRemoveFromArray_NullInput_NullItem() {
Object input[] = null;
Object arr[] = LazyList.removeFromArray(input,null);
assertNull(arr);
}
/**
* Tests for {@link LazyList#removeFromArray(Object[], Object)}
*/
@Test
public void testRemoveFromArray_NullInput_SimpleItem() {
Object input[] = null;
Object arr[] = LazyList.removeFromArray(input,"a");
assertNull(arr);
}
/**
* Tests for {@link LazyList#removeFromArray(Object[], Object)}
*/
@Test
public void testRemoveFromArray_EmptyInput_NullItem() {
String input[] = new String[0];
String arr[] = LazyList.removeFromArray(input,null);
assertNotNull("Should not be null", arr);
assertEquals(0, arr.length);
}
/**
* Tests for {@link LazyList#removeFromArray(Object[], Object)}
*/
@Test
public void testRemoveFromArray_EmptyInput_SimpleItem() {
String input[] = new String[0];
String arr[] = LazyList.removeFromArray(input,"a");
assertNotNull("Should not be null", arr);
assertEquals(0, arr.length);
}
/**
* Tests for {@link LazyList#removeFromArray(Object[], Object)}
*/
@Test
public void testRemoveFromArray_SingleInput() {
String input[] = new String[] { "a" };
String arr[] = LazyList.removeFromArray(input,null);
assertNotNull("Should not be null", arr);
assertEquals(1, arr.length);
assertEquals("a", arr[0]);
// Remove actual item
arr = LazyList.removeFromArray(input,"a");
assertNotNull("Should not be null", arr);
assertEquals(0, arr.length);
}
/**
* Tests for {@link LazyList#removeFromArray(Object[], Object)}
*/
@Test
public void testRemoveFromArray_MultiInput() {
String input[] = new String[] { "a", "b", "c" };
String arr[] = LazyList.removeFromArray(input,null);
assertNotNull("Should not be null", arr);
assertEquals(3, arr.length);
assertEquals("a", arr[0]);
assertEquals("b", arr[1]);
assertEquals("c", arr[2]);
// Remove an actual item
arr = LazyList.removeFromArray(input,"b");
assertNotNull("Should not be null", arr);
assertEquals(2, arr.length);
assertEquals("a", arr[0]);
assertEquals("c", arr[1]);
}
}