datarouter-prov/src/test/java/datarouter/provisioning/IntegrationTestRleBitSet.java

   1 /*******************************************************************************
   2  * ============LICENSE_START==================================================
   3  * * org.onap.dmaap
   4  * * ===========================================================================
   5  * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * * ===========================================================================
   7  * * Licensed under the Apache License, Version 2.0 (the "License");
   8  * * you may not use this file except in compliance with the License.
   9  * * You may obtain a copy of the License at
  10  * *
  11  *  *      http://www.apache.org/licenses/LICENSE-2.0
  12  * *
  13  *  * Unless required by applicable law or agreed to in writing, software
  14  * * distributed under the License is distributed on an "AS IS" BASIS,
  15  * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * * See the License for the specific language governing permissions and
  17  * * limitations under the License.
  18  * * ============LICENSE_END====================================================
  19  * *
  20  * * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  21  * *
  22  ******************************************************************************/
  23
  24 package datarouter.provisioning;
  25
  26 import static org.junit.Assert.fail;
  27
  28 import java.util.Iterator;
  29
  30 import org.junit.Test;
  31 import org.onap.dmaap.datarouter.provisioning.utils.RLEBitSet;
  32
  33 public class IntegrationTestRleBitSet {
  34     @Test
  35     public void testBasicConstructor() {
  36         RLEBitSet bs = new RLEBitSet();
  37         if (!bs.isEmpty()) {
  38             fail("bit set not empty");
  39         }
  40     }
  41
  42     @Test
  43     public void testStringConstructor() {
  44         RLEBitSet bs = new RLEBitSet("1-10");
  45         if (bs.isEmpty()) {
  46             fail("bit set is empty");
  47         }
  48         if (!bs.toString().equals("1-10")) {
  49             fail("bad value");
  50         }
  51         bs = new RLEBitSet("69,70,71");
  52         if (bs.isEmpty()) {
  53             fail("bit set is empty");
  54         }
  55         if (!bs.toString().equals("69-71")) {
  56             fail("bad value");
  57         }
  58         bs = new RLEBitSet("555 444    443  442");
  59         if (!bs.toString().equals("442-444,555")) {
  60             fail("bad value");
  61         }
  62     }
  63
  64     @Test
  65     public void testLength() {
  66         RLEBitSet bs = new RLEBitSet();
  67         if (bs.length() != 0) {
  68             fail("testLength fail " + bs + " " + bs.length());
  69         }
  70         bs = new RLEBitSet("1-10");
  71         if (bs.length() != 11) {
  72             fail("testLength fail " + bs + " " + bs.length());
  73         }
  74         bs = new RLEBitSet("1-20,100000000-100000005");
  75         if (bs.length() != 100000006) {
  76             fail("testLength fail " + bs + " " + bs.length());
  77         }
  78     }
  79
  80     @Test
  81     public void testGet() {
  82         RLEBitSet bs = new RLEBitSet("1-10");
  83         if (!bs.get(5)) {
  84             fail("get");
  85         }
  86         if (bs.get(69)) {
  87             fail("get");
  88         }
  89     }
  90
  91     @Test
  92     public void testSetOneBit() {
  93         RLEBitSet bs = new RLEBitSet();
  94         for (int i = 12; i < 200; i++) {
  95             bs.set(i);
  96         }
  97         bs.set(690);
  98         for (int i = 305; i < 309; i++) {
  99             bs.set(i);
 100         }
 101         bs.set(304);
 102         if (!bs.toString().equals("12-199,304-308,690")) {
 103             fail("testSetOneBit fail " + bs);
 104         }
 105     }
 106
 107     @Test
 108     public void testSetString() {
 109         RLEBitSet bs = new RLEBitSet();
 110         bs.set("1-100");
 111         if (!bs.toString().equals("1-100")) {
 112             fail("testSetString fail " + bs);
 113         }
 114     }
 115
 116     @Test
 117     public void testSetRange() {
 118         RLEBitSet bs = new RLEBitSet();
 119         bs.set(50,60);
 120         if (!bs.toString().equals("50-59")) {
 121             fail("testSetRange fail " + bs);
 122         }
 123     }
 124
 125     @Test
 126     public void testClearOneBit() {
 127         RLEBitSet bs = new RLEBitSet("1-10");
 128         bs.clear(5);
 129         if (!bs.toString().equals("1-4,6-10")) {
 130             fail("testClearOneBit fail");
 131         }
 132         bs = new RLEBitSet("1-10");
 133         bs.clear(11);
 134         if (!bs.toString().equals("1-10")) {
 135             fail("testClearOneBit fail " + bs);
 136         }
 137     }
 138
 139     @Test
 140     public void testClearRangeLeft() {
 141         RLEBitSet bs = new RLEBitSet("100-200");
 142         bs.clear(40,50);
 143         if (!bs.toString().equals("100-200")) {
 144             fail("testClearRangeLeft fail " + bs);
 145         }
 146     }
 147
 148     @Test
 149     public void testClearRangeRight() {
 150         RLEBitSet bs = new RLEBitSet("100-200");
 151         bs.clear(400,500);
 152         if (!bs.toString().equals("100-200")) {
 153             fail("testClearRangeRight fail " + bs);
 154         }
 155     }
 156
 157     @Test
 158     public void testClearRangeMiddle() {
 159         RLEBitSet bs = new RLEBitSet("100-200");
 160         bs.clear(120,130);
 161         if (!bs.toString().equals("100-119,130-200")) {
 162             fail("testClearRangeRight fail " + bs);
 163         }
 164     }
 165
 166     @Test
 167     public void testClearRangeIntersect() {
 168         RLEBitSet bs = new RLEBitSet("100-200");
 169         bs.clear(100,200);
 170         if (!bs.toString().equals("200")) {
 171             fail("testClearRangeIntersect fail " + bs);
 172         }
 173     }
 174
 175     @Test
 176     public void testClearOverlapLeft() {
 177         RLEBitSet bs = new RLEBitSet("100-200");
 178         bs.clear(50,150);
 179         if (!bs.toString().equals("150-200")) {
 180             fail("testClearOverlapLeft fail " + bs);
 181         }
 182     }
 183
 184     @Test
 185     public void testClearOverlapRight() {
 186         RLEBitSet bs = new RLEBitSet("100-200");
 187         bs.clear(150,250);
 188         if (!bs.toString().equals("100-149")) {
 189             fail("testClearOverlapRight fail " + bs);
 190         }
 191     }
 192
 193     @Test
 194     public void testClearOverlapAll() {
 195         RLEBitSet bs = new RLEBitSet("100-200");
 196         bs.clear(50,250);
 197         if (!bs.toString().equals("")) {
 198             fail("testClearOverlapAll fail " + bs);
 199         }
 200     }
 201
 202     @Test
 203     public void testAnd() {
 204         RLEBitSet bs = new RLEBitSet("100-200");
 205         RLEBitSet b2 = new RLEBitSet("150-400");
 206         bs.and(b2);
 207         if (!bs.toString().equals("150-200")) {
 208             fail("testAnd fail " + bs);
 209         }
 210         bs = new RLEBitSet("100-200");
 211         b2 = new RLEBitSet("1500-4000");
 212         bs.and(b2);
 213         if (!bs.isEmpty()) {
 214             fail("testAnd fail " + bs);
 215         }
 216     }
 217
 218     @Test
 219     public void testAndNot() {
 220         RLEBitSet bs = new RLEBitSet("100-200");
 221         RLEBitSet b2 = new RLEBitSet("150-159");
 222         bs.andNot(b2);
 223         if (!bs.toString().equals("100-149,160-200")) {
 224             fail("testAndNot fail " + bs);
 225         }
 226     }
 227
 228     @Test
 229     public void testIsEmpty() {
 230         RLEBitSet bs = new RLEBitSet("");
 231         if (!bs.isEmpty()) {
 232             fail("testIsEmpty fail " + bs);
 233         }
 234         bs.set(1);
 235         if (bs.isEmpty()) {
 236             fail("testIsEmpty fail " + bs);
 237         }
 238     }
 239
 240     @Test
 241     public void testCardinality() {
 242         RLEBitSet bs = new RLEBitSet("1-120,10000000-10000005");
 243         if (bs.cardinality() != 126) {
 244             fail("testCardinality fail 1");
 245         }
 246     }
 247
 248     @Test
 249     public void testIterator() {
 250         RLEBitSet rleBitSet = new RLEBitSet("1,5,10-12");
 251         Iterator<Long[]> rleBitSetRangeIterator = rleBitSet.getRangeIterator();
 252         if (!rleBitSetRangeIterator.hasNext()) {
 253             fail("iterator fail 1");
 254         }
 255         Long[] ll = rleBitSetRangeIterator.next();
 256         if (ll == null || ll[0] != 1 || ll[1] != 1) {
 257             fail("iterator fail 2");
 258         }
 259
 260         if (!rleBitSetRangeIterator.hasNext()) {
 261             fail("iterator fail 3");
 262         }
 263         ll = rleBitSetRangeIterator.next();
 264         if (ll == null || ll[0] != 5 || ll[1] != 5) {
 265             fail("iterator fail 4");
 266         }
 267
 268         if (!rleBitSetRangeIterator.hasNext()) {
 269             fail("iterator fail 5");
 270         }
 271         ll = rleBitSetRangeIterator.next();
 272         if (ll == null || ll[0] != 10 || ll[1] != 12) {
 273             fail("iterator fail 6");
 274         }
 275
 276         if (rleBitSetRangeIterator.hasNext()) {
 277             fail("iterator fail 7");
 278         }
 279     }
 280
 281     @Test
 282     public void testClone() {
 283         RLEBitSet bs1 = new RLEBitSet("1,5,10-12");
 284         RLEBitSet bs2 = (RLEBitSet) bs1.clone();
 285         if (!bs1.toString().equals(bs2.toString())) {
 286             fail("clone");
 287         }
 288     }
 289 }