// Path: src/main/java/org/jheaps/DoubleEndedAddressableHeap.java
// public interface DoubleEndedAddressableHeap<K, V> extends AddressableHeap<K, V> {
// 
//     /**
//      * Insert a new element into the heap.
//      *
//      * @param key
//      *            the element's key
//      * @param value
//      *            the element's value
//      * 
//      * @return a handle for the newly added element
//      */
//     Handle<K, V> insert(K key, V value);
// 
//     /**
//      * Insert a new element into the heap with a null value.
//      *
//      * @param key
//      *            the element's key
//      * @return a handle for the newly added element
//      */
//     Handle<K, V> insert(K key);
// 
//     /**
//      * Find an element with the minimum key.
//      *
//      * @return a handle to an element with minimum key
//      */
//     Handle<K, V> findMin();
// 
//     /**
//      * Delete and return an element with the minimum key. If multiple such
//      * elements exists, only one of them will be deleted. After the element is
//      * deleted the handle is invalidated and only method {@link Handle#getKey()}
//      * and {@link Handle#getValue()} can be used.
//      * 
//      * @return a handle to the deleted element with minimum key
//      */
//     Handle<K, V> deleteMin();
// 
//     /**
//      * Find an element with the maximum key.
//      *
//      * @return an element with the maximum key
//      * @throws NoSuchElementException
//      *             if the heap is empty
//      */
//     Handle<K, V> findMax();
// 
//     /**
//      * Delete and return an element with the maximum key. If multiple such
//      * elements exists, only one of them will be deleted.
//      *
//      * @return the deleted element with the maximum key
//      * @throws NoSuchElementException
//      *             if the heap is empty
//      */
//     Handle<K, V> deleteMax();
// 
//     /**
//      * A double-ended heap element handle. Allows someone to address an element
//      * already in a heap and perform additional operations.
//      *
//      * @param <K>
//      *            the type of keys maintained by this heap
//      * @param <V>
//      *            the type of values maintained by this heap
//      */
//     interface Handle<K, V> extends AddressableHeap.Handle<K, V> {
// 
//         /**
//          * Increase the key of the element.
//          *
//          * @param newKey
//          *            the new key
//          * @throws IllegalArgumentException
//          *             if the new key is smaller than the old key according to
//          *             the comparator used when constructing the heap or the
//          *             natural ordering of the elements if no comparator was
//          *             used
//          */
//         void increaseKey(K newKey);
// 
//     }
// 
// }


import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.util.Comparator;
import java.util.NoSuchElementException;
import java.util.Random;
import org.jheaps.DoubleEndedAddressableHeap;
import org.junit.Test;
    public void testDeleteMaxDeleteTwice1() {
        DoubleEndedAddressableHeap<Integer, Void> h = createHeap();

        for (int i = 100; i < 200; i++) {
            h.insert(i);
        }

        h.deleteMax().delete();
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDeleteMaxDecreaseKey() {
        DoubleEndedAddressableHeap<Integer, Void> h = createHeap();

        for (int i = 100; i < 200; i++) {
            h.insert(i);
        }
        h.deleteMax().decreaseKey(0);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDeleteMaxIncreaseKey() {
        DoubleEndedAddressableHeap<Integer, Void> h = createHeap();

        for (int i = 100; i < 200; i++) {
            h.insert(i);
        }
        h.deleteMax().increaseKey(200);
    }

// Path: src/main/java/org/jheaps/DoubleEndedAddressableHeap.java
// public interface DoubleEndedAddressableHeap<K, V> extends AddressableHeap<K, V> {
// 
//     /**
//      * Insert a new element into the heap.
//      *
//      * @param key
//      *            the element's key
//      * @param value
//      *            the element's value
//      * 
//      * @return a handle for the newly added element
//      */
//     Handle<K, V> insert(K key, V value);
// 
//     /**
//      * Insert a new element into the heap with a null value.
//      *
//      * @param key
//      *            the element's key
//      * @return a handle for the newly added element
//      */
//     Handle<K, V> insert(K key);
// 
//     /**
//      * Find an element with the minimum key.
//      *
//      * @return a handle to an element with minimum key
//      */
//     Handle<K, V> findMin();
// 
//     /**
//      * Delete and return an element with the minimum key. If multiple such
//      * elements exists, only one of them will be deleted. After the element is
//      * deleted the handle is invalidated and only method {@link Handle#getKey()}
//      * and {@link Handle#getValue()} can be used.
//      * 
//      * @return a handle to the deleted element with minimum key
//      */
//     Handle<K, V> deleteMin();
// 
//     /**
//      * Find an element with the maximum key.
//      *
//      * @return an element with the maximum key
//      * @throws NoSuchElementException
//      *             if the heap is empty
//      */
//     Handle<K, V> findMax();
// 
//     /**
//      * Delete and return an element with the maximum key. If multiple such
//      * elements exists, only one of them will be deleted.
//      *
//      * @return the deleted element with the maximum key
//      * @throws NoSuchElementException
//      *             if the heap is empty
//      */
//     Handle<K, V> deleteMax();
// 
//     /**
//      * A double-ended heap element handle. Allows someone to address an element
//      * already in a heap and perform additional operations.
//      *
//      * @param <K>
//      *            the type of keys maintained by this heap
//      * @param <V>
//      *            the type of values maintained by this heap
//      */
//     interface Handle<K, V> extends AddressableHeap.Handle<K, V> {
// 
//         /**
//          * Increase the key of the element.
//          *
//          * @param newKey
//          *            the new key
//          * @throws IllegalArgumentException
//          *             if the new key is smaller than the old key according to
//          *             the comparator used when constructing the heap or the
//          *             natural ordering of the elements if no comparator was
//          *             used
//          */
//         void increaseKey(K newKey);
// 
//     }
// 
// }


// Path: src/test/java/org/jheaps/tree/AbstractDoubleEndedAddressableHeapTest.java
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.util.Comparator;
import java.util.NoSuchElementException;
import java.util.Random;
import org.jheaps.DoubleEndedAddressableHeap;
import org.junit.Test;

    public void testDeleteMaxDeleteTwice1() {
        DoubleEndedAddressableHeap<Integer, Void> h = createHeap();

        for (int i = 100; i < 200; i++) {
            h.insert(i);
        }

        h.deleteMax().delete();
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDeleteMaxDecreaseKey() {
        DoubleEndedAddressableHeap<Integer, Void> h = createHeap();

        for (int i = 100; i < 200; i++) {
            h.insert(i);
        }
        h.deleteMax().decreaseKey(0);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDeleteMaxIncreaseKey() {
        DoubleEndedAddressableHeap<Integer, Void> h = createHeap();

        for (int i = 100; i < 200; i++) {
            h.insert(i);
        }
        h.deleteMax().increaseKey(200);
    }

    @Test(expected = NoSuchElementException.class)