public void testUnmodifiableTrie() {

        Trie trie = TrieUtils.unmodifiableTrie(new PatriciaTrie

        assertTrue("Returned object should be an UnmodifiableTrie.",

            trie instanceof UnmodifiableTrie);

        try {

            TrieUtils.unmodifiableTrie(null);

            fail("Expecting IllegalArgumentException for null trie.");

        } catch (final IllegalArgumentException ex) {

            // expected

        }

    }

        return UnmodifiableTrie.unmodifiableTrie(trie);

    protected AbstractBitwiseTrie(final KeyAnalyzer keyAnalyzer) {

        if (keyAnalyzer == null) {

        this.keyAnalyzer = keyAnalyzer;

    }

        public BasicEntry(final K key, final V value) {

            this.key = key;

            this.value = value;

        }

public abstract class KeyAnalyzer implements Comparator, Serializable {

            super(key, value);

            this.bitIndex = bitIndex;

            this.parent = null;

            this.left = this;

            this.right = null;

            this.predecessor = this;

        }

public class StringKeyAnalyzer extends KeyAnalyzer {

    public static final StringKeyAnalyzer INSTANCE = new StringKeyAnalyzer();

        return new UnmodifiableTrie(trie);

    public UnmodifiableTrie(final Trie trie) {

        if (trie == null) {

            throw new IllegalArgumentException("Trie must not be null");

        final Trie tmpTrie = (Trie) trie;

        this.delegate = tmpTrie;

    }

        super(new StringKeyAnalyzer());

    }

    private transient TrieEntry root = new TrieEntry(null, null, -1);

    private transient int size = 0;

    protected transient int modCount = 0;

        super(keyAnalyzer);

    }