@Test public void Deque_addFirst_AddsTwo() { deque.addFirst("firstString"); deque.addFirst("secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 2); }
@Test(expected = NoSuchElementException.class) public void Deque_addLast_removeFirst_throwsIfEmpty() { deque.addFirst("firstString"); deque.addFirst("secondString"); deque.removeLast(); deque.removeLast(); deque.removeFirst(); }
public static void main(String[] args) { Deque<Integer> ints = new Deque<Integer>(); assert ints.size() == 0; assert ints.isEmpty(); ints.addFirst(1); assert ints.size() == 1; assert !ints.isEmpty(); int val = ints.removeFirst(); assert val == 1; assert ints.size() == 0; assert ints.isEmpty(); ints.addFirst(2); assert ints.size() == 1; assert !ints.isEmpty(); val = ints.removeLast(); assert val == 2; assert ints.size() == 0; assert ints.isEmpty(); ints.addFirst(3); ints.addFirst(2); ints.addFirst(1); ints.addLast(4); ints.addLast(5); ints.addLast(6); assert ints.size() == 6; assert !ints.isEmpty(); for (int value : ints) { StdOut.print(value + " "); } StdOut.println(); while (!ints.isEmpty()) { StdOut.println(ints.removeLast()); } assert ints.size() == 0; assert ints.isEmpty(); for (int i = 0; i < 10; ++i) { ints.addFirst(i); } for (int i = 0; i < 10; ++i) { assert ints.size() == 10 - i; ints.removeLast(); } assert ints.size() == 0; }
@Test public void testAddition() { Deque<String> deque = new Deque<String>(); deque.addFirst(new String("test")); assertFalse(deque.isEmpty()); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); assertEquals(deque.size(), 3); }
@Test(expected = NoSuchElementException.class) public void Deque_iterator_throwsNoSuchElement() { deque.addFirst("firstString"); deque.addFirst("secondString"); Iterator<String> dequeIterator = deque.iterator(); dequeIterator.next(); dequeIterator.next(); dequeIterator.next(); }
@Test public void Deque_iterator_hasNextIsFalse() { deque.addFirst("firstString"); deque.addFirst("secondString"); Iterator<String> dequeIterator = deque.iterator(); dequeIterator.next(); dequeIterator.next(); assertFalse(dequeIterator.hasNext()); }
/** * @param namedElement named element * @return ancestors of the named element, beginning with the root namespace and ending with the * named element itself, skipping local scopes */ public static Iterable<? extends INamedElement> ancestors(final INamedElement namedElement) { final Deque<INamedElement> ancestors = new LinkedList<>(); INamedElement ancestor = namedElement; while (membership(ancestor) != ScopeMembership.Root) { ancestors.addFirst(ancestor); ancestor = parentNamedElementOfScope(ancestor.parent()); } ancestors.addFirst(ancestor); return ancestors; }
@Test public void Deque_iterator_iterates() { deque.addFirst("firstString"); deque.addFirst("secondString"); deque.addLast("thirdString"); Iterator<String> dequeIterator = deque.iterator(); assertEquals(dequeIterator.next(), "secondString"); assertEquals(dequeIterator.next(), "firstString"); assertEquals(dequeIterator.next(), "thirdString"); }
@Test(expected = UnsupportedOperationException.class) public void testRemoveFromIterator() { Deque<String> deque = new Deque<String>(); deque.addFirst("middle"); deque.addLast("last"); deque.addFirst("first"); Iterator<String> i = deque.iterator(); i.next(); i.remove(); // should throw exception }
public static boolean dfsIterative(TreeNode root, int val) { Deque<TreeNode> s = new LinkedList<>(); s.push(root); while (!s.isEmpty()) { TreeNode curr = s.removeFirst(); if (curr.value == val) return true; if (curr.left != null) s.addFirst(curr.left); if (curr.right != null) s.addFirst(curr.right); } return false; }
@Test public void testRemove() { Deque<String> deque = new Deque<String>(); deque.addFirst(new String("test")); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); deque.removeLast(); deque.removeFirst(); assertTrue(deque.size() == 1); deque.removeLast(); assertTrue(deque.size() == 0); }
public static void main(String[] args) { Deque<String> d = new Deque<String>(); d.addFirst("1"); d.addFirst("2"); d.addFirst("3"); d.addLast("7"); d.removeFirst(); d.removeFirst(); for (String s : d) { System.out.println(s); } }
public static void main(String[] args) { Deque<String> myDeque = new Deque<String>(); String[] str = new String[] {"Jrui", "Long", "Jason"}; myDeque.addFirst(str[0]); myDeque.addLast(str[2]); myDeque.addFirst(str[1]); Iterator<String> test = myDeque.iterator(); while (test.hasNext()) { String s = test.next(); StdOut.println(s); } }
@Test public void testAddFirstAndRemoveFirstAll() { deque.addFirst("1"); deque.addFirst("2"); deque.addFirst("3"); deque.addFirst("4"); deque.addFirst("5"); assertEquals(deque.removeFirst(), "5"); assertEquals(deque.removeFirst(), "4"); assertEquals(deque.removeFirst(), "3"); assertEquals(deque.removeFirst(), "2"); assertEquals(deque.removeFirst(), "1"); }
public static void main(String[] args) { // unit testing Deque<String> d = new Deque<String>(); d.addFirst("sant"); d.addLast("prakash"); d.addFirst("sid"); for (String s : d) StdOut.println(s); StdOut.println("removing last"); StdOut.println(d.removeLast()); StdOut.println("resulting list"); for (String s : d) StdOut.println(s); StdOut.println("removing fist"); StdOut.println(d.removeFirst()); StdOut.println("resulting list"); for (String s : d) StdOut.println(s); }
@Test public void Deque_addFirst_removeFirst_AddsRemovesTwo() { deque.addFirst("firstString"); deque.addFirst("secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 2); String returnedString = deque.removeFirst(); assertEquals(returnedString, "secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 1); returnedString = deque.removeFirst(); assertEquals(returnedString, "firstString"); assertTrue(deque.isEmpty()); assertEquals(deque.size(), 0); }
private List<List<Integer>> help1(TreeNode root) { List<List<Integer>> res = new ArrayList<List<Integer>>(); if (root == null) { return res; } Deque<TreeNode> current = new LinkedList<>(); Deque<TreeNode> next = new LinkedList<>(); boolean isOdd = true; current.add(root); while (!current.isEmpty()) { int size = current.size(); List<Integer> level = new LinkedList<Integer>(); if (isOdd) { for (int i = 0; i < size; i++) { TreeNode top = current.removeFirst(); level.add(top.val); if (top.left != null) { next.addLast(top.left); } if (top.right != null) { next.addLast(top.right); } } } else { for (int i = 0; i < size; i++) { TreeNode top = current.removeLast(); level.add(top.val); if (top.right != null) { next.addFirst(top.right); } if (top.left != null) { next.addFirst(top.left); } } } isOdd = !isOdd; current = next; res.add(level); } return res; }
@Test public void testOneEmptyOne() { deque.addFirst("1"); assertEquals(deque.removeFirst(), "1"); deque.addLast("2"); }
@Test public void test10() { deque = new Deque<String>(); deque.addFirst("1"); deque.addFirst("2"); deque.addFirst("3"); deque.addFirst("4"); assertEquals(deque.removeLast(), "1"); assertEquals(deque.removeFirst(), "4"); deque.addLast("7"); assertEquals(deque.removeLast(), "7"); assertEquals(deque.removeLast(), "2"); assertEquals(deque.removeLast(), "3"); assertEquals(deque.size(), 0); }
@Test public void testIsEmpty() { Deque<String> deque = new Deque<String>(); assertTrue(deque.isEmpty()); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); deque.addLast(new String("test last")); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); assertFalse(deque.isEmpty()); deque.removeFirst(); deque.removeFirst(); deque.removeFirst(); deque.removeLast(); deque.removeLast(); assertTrue(deque.isEmpty()); }
@Test(expected = NoSuchElementException.class) public void testNextFromEmptyIterator() { Deque<String> deque = new Deque<String>(); deque.addLast("last"); deque.addFirst("first"); Iterator<String> i = deque.iterator(); i.next(); i.next(); i.next(); // should throw exception }
@Test public void testAdditionOrdered() { Deque<Integer> deque = new Deque<Integer>(); for (int i = 0; i < 10; i++) { deque.addFirst(i); } for (int i = 0; i < 10; i++) { assertEquals(deque.removeLast(), new Integer(i)); } }
@Test public void testAddLastAndAddFirstWithRemoveLast() { deque.addLast("4"); deque.addLast("5"); deque.addLast("6"); deque.addLast("7"); deque.addFirst("3"); deque.addFirst("2"); deque.addFirst("1"); assertEquals(deque.removeLast(), "7"); assertEquals(deque.removeLast(), "6"); assertEquals(deque.removeLast(), "5"); assertEquals(deque.removeLast(), "4"); assertEquals(deque.removeLast(), "3"); assertEquals(deque.removeLast(), "2"); assertEquals(deque.removeLast(), "1"); }
public boolean getNextBlock() throws IOException { if (curRangeIndex < 0 || curRangeIndex >= indexes.size()) return false; /* seek to the correct offset to the data, and calculate the data size */ IndexHelper.IndexInfo curColPosition = indexes.get(curRangeIndex); /* see if this read is really necessary. */ if (reversed) { if ((finishColumn.length > 0 && comparator.compare(finishColumn, curColPosition.lastName) > 0) || (startColumn.length > 0 && comparator.compare(startColumn, curColPosition.firstName) < 0)) return false; } else { if ((startColumn.length > 0 && comparator.compare(startColumn, curColPosition.lastName) > 0) || (finishColumn.length > 0 && comparator.compare(finishColumn, curColPosition.firstName) < 0)) return false; } boolean outOfBounds = false; // seek to current block // curIndexInfo.offset is the relative offset from the first block file.seek(firstBlockPos + curColPosition.offset); // read all columns of current block into memory! DataInputStream blockIn = ColumnFamily.serializer() .getBlockInputStream(file, curColPosition.sizeOnDisk, compressContext); try { int size = 0; while ((size < curColPosition.width) && !outOfBounds) { IColumn column = emptyColumnFamily.getColumnSerializer().deserialize(blockIn); size += column.serializedSize(); if (reversed) blockColumns.addFirst(column); else blockColumns.addLast(column); /* see if we can stop seeking. */ if (!reversed && finishColumn.length > 0) outOfBounds = comparator.compare(column.name(), finishColumn) >= 0; else if (reversed && startColumn.length > 0) outOfBounds = comparator.compare(column.name(), startColumn) >= 0; if (outOfBounds) break; } } catch (IOException e) { logger.error(e.toString()); throw e; } finally { ColumnFamily.serializer().releaseBlockInputStream(blockIn, compressContext); } if (reversed) curRangeIndex--; else curRangeIndex++; return true; }
@Test public void testIterator() { deque.addFirst("1"); deque.addFirst("2"); deque.addFirst("3"); deque.addFirst("4"); deque.addFirst("5"); deque.removeFirst(); Iterator<String> iterator = deque.iterator(); int i = 4; while (iterator.hasNext()) { String s = iterator.next(); assertEquals(s, "" + i); i--; } }
@Test(expected = NoSuchElementException.class) public void testRemoveFirstFromEmptyDeque() { Deque<Integer> deque = new Deque<Integer>(); int count = 10; for (int i = 0; i < count; i++) { deque.addFirst(10); } for (int i = 0; i < count; i++) { deque.removeFirst(); } deque.removeFirst(); // should throw exception }
// unit testing public static void main(String[] args) { Deque<Integer> deq = new Deque<Integer>(); boolean res; res = deq.isEmpty(); res = deq.isEmpty(); res = deq.isEmpty(); deq.addFirst(3); // deq.addFirst(5); int a = deq.removeFirst(); for (int i : deq) { StdOut.println(i); } }
public static void main(String args[]) { Deque<Integer> d = new Deque<Integer>(); Iterator<Integer> a = d.iterator(); while (a.hasNext()) { StdOut.println(a.next()); } for (int i = 0; i < 10; i++) { d.addFirst(i); } for (int i = 0; i < 10; i++) { StdOut.println(d.removeFirst()); } }
public boolean getNextBlock() throws IOException { if (curRangeIndex < 0 || curRangeIndex >= indexes.size()) return false; /* seek to the correct offset to the data, and calculate the data size */ IndexHelper.IndexInfo curColPosition = indexes.get(curRangeIndex); /* see if this read is really necessary. */ if (reversed) { if ((finishColumn.length > 0 && comparator.compare(finishColumn, curColPosition.lastName) > 0) || (startColumn.length > 0 && comparator.compare(startColumn, curColPosition.firstName) < 0)) return false; } else { if ((startColumn.length > 0 && comparator.compare(startColumn, curColPosition.lastName) > 0) || (finishColumn.length > 0 && comparator.compare(finishColumn, curColPosition.firstName) < 0)) return false; } boolean outOfBounds = false; file.reset(); long curOffset = file.skipBytes((int) curColPosition.offset); assert curOffset == curColPosition.offset; while (file.bytesPastMark() < curColPosition.offset + curColPosition.width && !outOfBounds) { IColumn column = emptyColumnFamily.getColumnSerializer().deserialize(file); if (reversed) blockColumns.addFirst(column); else blockColumns.addLast(column); /* see if we can stop seeking. */ if (!reversed && finishColumn.length > 0) outOfBounds = comparator.compare(column.name(), finishColumn) >= 0; else if (reversed && startColumn.length > 0) outOfBounds = comparator.compare(column.name(), startColumn) >= 0; if (outOfBounds) break; } if (reversed) curRangeIndex--; else curRangeIndex++; return true; }
@Test(expected = NullPointerException.class) public void testAddNullFirstNullPointerException() { Deque<String> deque = new Deque<String>(); deque.addFirst(null); }