hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSimpleTimeRangeTracker.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.regionserver;
  19
  20 import static org.junit.Assert.assertEquals;
  21 import static org.junit.Assert.assertFalse;
  22 import static org.junit.Assert.assertTrue;
  23
  24 import java.io.DataOutputStream;
  25 import java.io.IOException;
  26 import org.apache.hadoop.hbase.HBaseClassTestRule;
  27 import org.apache.hadoop.hbase.io.ByteArrayOutputStream;
  28 import org.apache.hadoop.hbase.io.TimeRange;
  29 import org.apache.hadoop.hbase.testclassification.RegionServerTests;
  30 import org.apache.hadoop.hbase.testclassification.SmallTests;
  31 import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
  32 import org.junit.ClassRule;
  33 import org.junit.Test;
  34 import org.junit.experimental.categories.Category;
  35
  36 @Category({RegionServerTests.class, SmallTests.class})
  37 public class TestSimpleTimeRangeTracker {
  38
  39   @ClassRule
  40   public static final HBaseClassTestRule CLASS_RULE =
  41       HBaseClassTestRule.forClass(TestSimpleTimeRangeTracker.class);
  42
  43   protected TimeRangeTracker getTimeRangeTracker() {
  44     return TimeRangeTracker.create(TimeRangeTracker.Type.NON_SYNC);
  45   }
  46
  47   protected TimeRangeTracker getTimeRangeTracker(long min, long max) {
  48     return TimeRangeTracker.create(TimeRangeTracker.Type.NON_SYNC, min, max);
  49   }
  50
  51   @Test
  52   public void testExtreme() {
  53     TimeRange tr = TimeRange.allTime();
  54     assertTrue(tr.includesTimeRange(TimeRange.allTime()));
  55     TimeRangeTracker trt = getTimeRangeTracker();
  56     assertFalse(trt.includesTimeRange(TimeRange.allTime()));
  57     trt.includeTimestamp(1);
  58     trt.includeTimestamp(10);
  59     assertTrue(trt.includesTimeRange(TimeRange.allTime()));
  60   }
  61
  62   @Test
  63   public void testTimeRangeInitialized() {
  64     TimeRangeTracker src = getTimeRangeTracker();
  65     TimeRange tr = TimeRange.from(EnvironmentEdgeManager.currentTime());
  66     assertFalse(src.includesTimeRange(tr));
  67   }
  68
  69   @Test
  70   public void testTimeRangeTrackerNullIsSameAsTimeRangeNull() throws IOException {
  71     TimeRangeTracker src = getTimeRangeTracker(1, 2);
  72     byte[] bytes = TimeRangeTracker.toByteArray(src);
  73     TimeRange tgt = TimeRangeTracker.parseFrom(bytes).toTimeRange();
  74     assertEquals(src.getMin(), tgt.getMin());
  75     assertEquals(src.getMax(), tgt.getMax());
  76   }
  77
  78   @Test
  79   public void testSerialization() throws IOException {
  80     TimeRangeTracker src = getTimeRangeTracker(1, 2);
  81     TimeRangeTracker tgt = TimeRangeTracker.parseFrom(TimeRangeTracker.toByteArray(src));
  82     assertEquals(src.getMin(), tgt.getMin());
  83     assertEquals(src.getMax(), tgt.getMax());
  84   }
  85
  86   @Test
  87   public void testLegacySerialization() throws IOException {
  88     ByteArrayOutputStream data = new ByteArrayOutputStream();
  89     DataOutputStream output = new DataOutputStream(data);
  90     output.writeLong(100);
  91     output.writeLong(200);
  92     TimeRangeTracker tgt = TimeRangeTracker.parseFrom(data.toByteArray());
  93     assertEquals(100, tgt.getMin());
  94     assertEquals(200, tgt.getMax());
  95   }
  96
  97   @Test
  98   public void testAlwaysDecrementingSetsMaximum() {
  99     TimeRangeTracker trr = getTimeRangeTracker();
 100     trr.includeTimestamp(3);
 101     trr.includeTimestamp(2);
 102     trr.includeTimestamp(1);
 103     assertTrue(trr.getMin() != TimeRangeTracker.INITIAL_MIN_TIMESTAMP);
 104     assertTrue(trr.getMax() != -1 /*The initial max value*/);
 105   }
 106
 107   @Test
 108   public void testSimpleInRange() {
 109     TimeRangeTracker trr = getTimeRangeTracker();
 110     trr.includeTimestamp(0);
 111     trr.includeTimestamp(2);
 112     assertTrue(trr.includesTimeRange(TimeRange.from(1)));
 113   }
 114
 115   @Test
 116   public void testRangeConstruction() throws IOException {
 117     TimeRange defaultRange = TimeRange.allTime();
 118     assertEquals(0L, defaultRange.getMin());
 119     assertEquals(Long.MAX_VALUE, defaultRange.getMax());
 120     assertTrue(defaultRange.isAllTime());
 121
 122     TimeRange oneArgRange = TimeRange.from(0L);
 123     assertEquals(0L, oneArgRange.getMin());
 124     assertEquals(Long.MAX_VALUE, oneArgRange.getMax());
 125     assertTrue(oneArgRange.isAllTime());
 126
 127     TimeRange oneArgRange2 = TimeRange.from(1);
 128     assertEquals(1, oneArgRange2.getMin());
 129     assertEquals(Long.MAX_VALUE, oneArgRange2.getMax());
 130     assertFalse(oneArgRange2.isAllTime());
 131
 132     TimeRange twoArgRange = TimeRange.between(0L, Long.MAX_VALUE);
 133     assertEquals(0L, twoArgRange.getMin());
 134     assertEquals(Long.MAX_VALUE, twoArgRange.getMax());
 135     assertTrue(twoArgRange.isAllTime());
 136
 137     TimeRange twoArgRange2 = TimeRange.between(0L, Long.MAX_VALUE - 1);
 138     assertEquals(0L, twoArgRange2.getMin());
 139     assertEquals(Long.MAX_VALUE - 1, twoArgRange2.getMax());
 140     assertFalse(twoArgRange2.isAllTime());
 141
 142     TimeRange twoArgRange3 = TimeRange.between(1, Long.MAX_VALUE);
 143     assertEquals(1, twoArgRange3.getMin());
 144     assertEquals(Long.MAX_VALUE, twoArgRange3.getMax());
 145     assertFalse(twoArgRange3.isAllTime());
 146   }
 147
 148 }