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