public void testCOLLECTIONS_474_nonNullValues () {

        Object key1 = new Object();

        Object key2 = new Object();

        HashMap hmap = new HashMap();

        hmap.put(key1, "1");

        hmap.put(key2, "2");

        assertEquals("Should have two elements", 2, hmap.size());

        ListOrderedMap listMap = new ListOrderedMap();

        listMap.put(key1, "3");

        listMap.put(key2, "4");

        assertEquals("Should have two elements", 2, listMap.size());

        listMap.putAll(2, hmap);

    }

        this(ComparatorUtils.NATURAL_COMPARATOR, true);

    }

    public NullComparator(final Comparator nonNullComparator, final boolean nullsAreHigh) {

        this.nonNullComparator = nonNullComparator;

        this.nullsAreHigh = nullsAreHigh;

        if (nonNullComparator == null) {

    }

        if(o1 == o2) { return 0; }

        if(o1 == null) { return this.nullsAreHigh ? 1 : -1; }

        if(o2 == null) { return this.nullsAreHigh ? -1 : 1; }

        return this.nonNullComparator.compare(o1, o2);

    protected AbstractMapDecorator(final Map map) {

        if (map == null) {

        this.map = map;

    }

        return map;

        return decorated().size();

public abstract class AbstractIterableMap implements IterableMap {

    private final List insertOrder = new ArrayList();

        this(new HashMap());

    }

        super(map);

        insertOrder.addAll(decorated().keySet());

    }

        if (decorated().containsKey(key)) {

            final V result = decorated().put(key, value);

            insertOrder.add(key);

            return result;

        for (final Map.Entry entry : map.entrySet()) {

            final V old = put(index, entry.getKey(), entry.getValue());

            if (old == null) {

                index++;

                index = indexOf(entry.getKey()) + 1;

        }

    }

        return insertOrder.indexOf(key);

        final Map m = decorated();

        if (m.containsKey(key)) {

            final V result = m.remove(key);

            final int pos = insertOrder.indexOf(key);

            insertOrder.remove(pos);

            if (pos < index) {

                index--;

            insertOrder.add(index, key);

            m.put(key, value);

            return result;

    public static final ComparableComparator INSTANCE = new ComparableComparator();

        return (ComparableComparator) INSTANCE;

        super();

    }

        return obj1.compareTo(obj2);

    public static final Comparator NATURAL_COMPARATOR = ComparableComparator.comparableComparator();