common/util/src/test/java/org/opendaylight/yangtools/util/MapAdaptorTest.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.util;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotSame;
  12 import static org.junit.Assert.assertSame;
  13 import static org.junit.Assert.assertTrue;
  14
  15 import com.google.common.collect.ImmutableMap;
  16 import java.util.Collections;
  17 import java.util.HashMap;
  18 import java.util.Map;
  19 import java.util.TreeMap;
  20 import org.junit.Before;
  21 import org.junit.Test;
  22
  23 public class MapAdaptorTest {
  24     private MapAdaptor adaptor;
  25
  26     @Before
  27     public void setUp() {
  28         adaptor = MapAdaptor.getInstance(true, 10, 5);
  29     }
  30
  31     @Test
  32     public void testTreeToEmpty() {
  33         final Map<String, String> input = new TreeMap<>();
  34
  35         // Converts the input into a hashmap;
  36         final Map<?, ?> snap = adaptor.takeSnapshot(input);
  37         assertNotSame(input, snap);
  38         assertTrue(snap instanceof HashMap);
  39
  40         final Map<?, ?> opt1 = adaptor.optimize(input);
  41         assertSame(ImmutableMap.of(), opt1);
  42
  43         final Map<?, ?> opt2 = adaptor.optimize(snap);
  44         assertSame(ImmutableMap.of(), opt2);
  45     }
  46
  47     @Test
  48     public void testTreeToSingleton() {
  49         final Map<String, String> input = new TreeMap<>();
  50         input.put("a", "b");
  51
  52         final Map<?, ?> snap = adaptor.takeSnapshot(input);
  53         assertNotSame(input, snap);
  54         assertTrue(snap instanceof HashMap);
  55         assertEquals(input, snap);
  56
  57         final Map<?, ?> opt1 = adaptor.optimize(input);
  58         assertNotSame(input, opt1);
  59         assertEquals(input, opt1);
  60         assertEquals(Collections.singletonMap(null, null).getClass(), opt1.getClass());
  61         final Map<?, ?> snap1 = adaptor.takeSnapshot(opt1);
  62         assertTrue(snap1 instanceof HashMap);
  63         assertEquals(input, snap1);
  64
  65         final Map<?, ?> opt2 = adaptor.optimize(snap);
  66         assertNotSame(snap, opt2);
  67         assertEquals(input, opt2);
  68         assertEquals(Collections.singletonMap(null, null).getClass(), opt2.getClass());
  69
  70         final Map<?, ?> snap2 = adaptor.takeSnapshot(opt2);
  71         assertNotSame(opt2, snap2);
  72         assertTrue(snap2 instanceof HashMap);
  73         assertEquals(input, snap2);
  74     }
  75
  76     @Test
  77     public void testTreeToTrie() {
  78         final Map<String, String> input = new TreeMap<>();
  79         for (char c = 'a'; c <= 'z'; ++c) {
  80             final String s = String.valueOf(c);
  81             input.put(s, s);
  82         }
  83
  84         final Map<String, String> snap = adaptor.takeSnapshot(input);
  85         assertTrue(snap instanceof HashMap);
  86         assertEquals(input, snap);
  87
  88         final Map<String, String> opt1 = adaptor.optimize(input);
  89         assertEquals(input, opt1);
  90         assertEquals(ReadOnlyTrieMap.class, opt1.getClass());
  91
  92         final Map<String, String> snap2 = adaptor.takeSnapshot(opt1);
  93         assertTrue(snap2 instanceof ReadWriteTrieMap);
  94         assertEquals(opt1, snap2);
  95         assertEquals(26, snap2.size());
  96
  97         // snap2 and snap3 are independent
  98         final Map<String, String> snap3 = adaptor.takeSnapshot(opt1);
  99
 100         snap2.remove("a");
 101         assertEquals(25, snap2.size());
 102         assertEquals(26, snap3.size());
 103
 104         snap3.remove("b");
 105         snap3.remove("c");
 106         assertEquals(25, snap2.size());
 107         assertEquals(24, snap3.size());
 108
 109         snap2.put("foo", "foo");
 110         snap2.put("bar", "baz");
 111         snap3.put("bar", "baz");
 112         assertEquals(27, snap2.size());
 113         assertEquals(25, snap3.size());
 114     }
 115
 116     @Test
 117     public void testTrieToHash() {
 118         final Map<String, String> input = new TreeMap<>();
 119         for (char c = 'a'; c <= 'k'; ++c) {
 120             final String s = String.valueOf(c);
 121             input.put(s, s);
 122         }
 123
 124         // Translated to read-only
 125         final Map<String, String> opt1 = adaptor.optimize(input);
 126         assertEquals(input, opt1);
 127         assertEquals(ReadOnlyTrieMap.class, opt1.getClass());
 128         assertEquals(11, opt1.size());
 129
 130         // 11 elements -- should retain TrieMap
 131         final Map<String, String> snap1 = adaptor.takeSnapshot(opt1);
 132         assertEquals(ReadWriteTrieMap.class, snap1.getClass());
 133         assertEquals(11, snap1.size());
 134
 135         for (char c = 'e'; c <= 'k'; ++c) {
 136             final String s = String.valueOf(c);
 137             snap1.remove(s);
 138         }
 139
 140         // 4 elements: should revert to HashMap
 141         assertEquals(4, snap1.size());
 142
 143         final Map<String, String> opt2 = adaptor.optimize(snap1);
 144         assertEquals(snap1, opt2);
 145         assertEquals(HashMap.class, opt2.getClass());
 146         assertEquals(4, opt2.size());
 147     }
 148 }