hbase-client/src/test/java/org/apache/hadoop/hbase/util/TestRoundRobinPoolMap.java

   1 /**
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements.  See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership.  The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License.  You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18 package org.apache.hadoop.hbase.util;
  19
  20 import static org.junit.Assert.assertEquals;
  21 import static org.junit.Assert.assertFalse;
  22
  23 import java.io.IOException;
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.Iterator;
  27 import java.util.List;
  28 import java.util.concurrent.CompletableFuture;
  29 import java.util.concurrent.CompletionException;
  30 import java.util.concurrent.ExecutionException;
  31 import java.util.concurrent.atomic.AtomicInteger;
  32 import org.apache.hadoop.hbase.HBaseClassTestRule;
  33 import org.apache.hadoop.hbase.testclassification.MiscTests;
  34 import org.apache.hadoop.hbase.testclassification.SmallTests;
  35 import org.apache.hadoop.hbase.util.PoolMap.PoolType;
  36 import org.junit.ClassRule;
  37 import org.junit.Test;
  38 import org.junit.experimental.categories.Category;
  39
  40 @Category({ MiscTests.class, SmallTests.class })
  41 public class TestRoundRobinPoolMap extends PoolMapTestBase {
  42
  43   @ClassRule
  44   public static final HBaseClassTestRule CLASS_RULE =
  45       HBaseClassTestRule.forClass(TestRoundRobinPoolMap.class);
  46
  47   @Override
  48   protected PoolType getPoolType() {
  49     return PoolType.RoundRobin;
  50   }
  51
  52   @Test
  53   public void testGetOrCreate() throws IOException {
  54     String key = "key";
  55     String value = "value";
  56     String result = poolMap.getOrCreate(key, () -> value);
  57
  58     assertEquals(value, result);
  59     assertEquals(1, poolMap.values().size());
  60   }
  61
  62   @Test
  63   public void testMultipleKeys() throws IOException {
  64     for (int i = 0; i < KEY_COUNT; i++) {
  65       String key = Integer.toString(i);
  66       String value = Integer.toString(2 * i);
  67       String result = poolMap.getOrCreate(key, () -> value);
  68
  69       assertEquals(value, result);
  70     }
  71
  72     assertEquals(KEY_COUNT, poolMap.values().size());
  73   }
  74
  75   @Test
  76   public void testMultipleValues() throws IOException {
  77     String key = "key";
  78
  79     for (int i = 0; i < POOL_SIZE; i++) {
  80       String value = Integer.toString(i);
  81       String result = poolMap.getOrCreate(key, () -> value);
  82
  83       assertEquals(value, result);
  84     }
  85
  86     assertEquals(POOL_SIZE, poolMap.values().size());
  87   }
  88
  89   @Test
  90   public void testRoundRobin() throws IOException {
  91     String key = "key";
  92
  93     for (int i = 0; i < POOL_SIZE; i++) {
  94       String value = Integer.toString(i);
  95       poolMap.getOrCreate(key, () -> value);
  96     }
  97
  98     assertEquals(POOL_SIZE, poolMap.values().size());
  99
 100     /* pool is filled, get() should return elements round robin order */
 101     for (int i = 0; i < 2 * POOL_SIZE; i++) {
 102       String expected = Integer.toString(i % POOL_SIZE);
 103       assertEquals(expected, poolMap.getOrCreate(key, () -> {
 104         throw new IOException("must not call me");
 105       }));
 106     }
 107
 108     assertEquals(POOL_SIZE, poolMap.values().size());
 109   }
 110
 111   @Test
 112   public void testMultiThreadedRoundRobin() throws ExecutionException, InterruptedException {
 113     String key = "key";
 114     AtomicInteger id = new AtomicInteger();
 115     List<String> results = Collections.synchronizedList(new ArrayList<>());
 116
 117     Runnable runnable = () -> {
 118       try {
 119         for (int i = 0; i < POOL_SIZE; i++) {
 120           String value = Integer.toString(id.getAndIncrement());
 121           String result = poolMap.getOrCreate(key, () -> value);
 122           results.add(result);
 123
 124           Thread.yield();
 125         }
 126       } catch (IOException e) {
 127         throw new CompletionException(e);
 128       }
 129     };
 130
 131     CompletableFuture<Void> future1 = CompletableFuture.runAsync(runnable);
 132     CompletableFuture<Void> future2 = CompletableFuture.runAsync(runnable);
 133
 134     /* test for successful completion */
 135     future1.get();
 136     future2.get();
 137
 138     assertEquals(POOL_SIZE, poolMap.values().size());
 139
 140     /* check every elements occur twice */
 141     Collections.sort(results);
 142     Iterator<String> iterator = results.iterator();
 143
 144     for (int i = 0; i < POOL_SIZE; i++) {
 145       String next1 = iterator.next();
 146       String next2 = iterator.next();
 147       assertEquals(next1, next2);
 148     }
 149
 150     assertFalse(iterator.hasNext());
 151   }
 152 }