core/test/src/com/google/zxing/qrcode/encoder/BitVectorTestCase.java

   1 /*
   2  * Copyright 2008 ZXing authors
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.google.zxing.qrcode.encoder;
  18
  19 import com.google.zxing.common.BitArray;
  20 import org.junit.Assert;
  21 import org.junit.Test;
  22
  23 /**
  24  * @author satorux@google.com (Satoru Takabayashi) - creator
  25  * @author dswitkin@google.com (Daniel Switkin) - ported from C++
  26  */
  27 public class BitVectorTestCase extends Assert {
  28
  29   private static long getUnsignedInt(BitArray v, int index) {
  30     long result = 0L;
  31     for (int i = 0, offset = index << 3; i < 32; i++) {
  32       if (v.get(offset + i)) {
  33         result |= 1L << (31 - i);
  34       }
  35     }
  36     return result;
  37   }
  38
  39   @Test
  40   public void testAppendBit() {
  41     BitArray v = new BitArray();
  42     assertEquals(0, v.getSizeInBytes());
  43     // 1
  44     v.appendBit(true);
  45     assertEquals(1, v.getSize());
  46     assertEquals(0x80000000L, getUnsignedInt(v, 0));
  47     // 10
  48     v.appendBit(false);
  49     assertEquals(2, v.getSize());
  50     assertEquals(0x80000000L, getUnsignedInt(v, 0));
  51     // 101
  52     v.appendBit(true);
  53     assertEquals(3, v.getSize());
  54     assertEquals(0xa0000000L, getUnsignedInt(v, 0));
  55     // 1010
  56     v.appendBit(false);
  57     assertEquals(4, v.getSize());
  58     assertEquals(0xa0000000L, getUnsignedInt(v, 0));
  59     // 10101
  60     v.appendBit(true);
  61     assertEquals(5, v.getSize());
  62     assertEquals(0xa8000000L, getUnsignedInt(v, 0));
  63     // 101010
  64     v.appendBit(false);
  65     assertEquals(6, v.getSize());
  66     assertEquals(0xa8000000L, getUnsignedInt(v, 0));
  67     // 1010101
  68     v.appendBit(true);
  69     assertEquals(7, v.getSize());
  70     assertEquals(0xaa000000L, getUnsignedInt(v, 0));
  71     // 10101010
  72     v.appendBit(false);
  73     assertEquals(8, v.getSize());
  74     assertEquals(0xaa000000L, getUnsignedInt(v, 0));
  75     // 10101010 1
  76     v.appendBit(true);
  77     assertEquals(9, v.getSize());
  78     assertEquals(0xaa800000L, getUnsignedInt(v, 0));
  79     // 10101010 10
  80     v.appendBit(false);
  81     assertEquals(10, v.getSize());
  82     assertEquals(0xaa800000L, getUnsignedInt(v, 0));
  83   }
  84
  85   @Test
  86   public void testAppendBits() {
  87     {
  88       BitArray v = new BitArray();
  89       v.appendBits(0x1, 1);
  90       assertEquals(1, v.getSize());
  91       assertEquals(0x80000000L, getUnsignedInt(v, 0));
  92     }
  93     {
  94       BitArray v = new BitArray();
  95       v.appendBits(0xff, 8);
  96       assertEquals(8, v.getSize());
  97       assertEquals(0xff000000L, getUnsignedInt(v, 0));
  98     }
  99     {
 100       BitArray v = new BitArray();
 101       v.appendBits(0xff7, 12);
 102       assertEquals(12, v.getSize());
 103       assertEquals(0xff700000L, getUnsignedInt(v, 0));
 104     }
 105   }
 106
 107   @Test
 108   public void testNumBytes() {
 109     BitArray v = new BitArray();
 110     assertEquals(0, v.getSizeInBytes());
 111     v.appendBit(false);
 112     // 1 bit was added in the vector, so 1 byte should be consumed.
 113     assertEquals(1, v.getSizeInBytes());
 114     v.appendBits(0, 7);
 115     assertEquals(1, v.getSizeInBytes());
 116     v.appendBits(0, 8);
 117     assertEquals(2, v.getSizeInBytes());
 118     v.appendBits(0, 1);
 119     // We now have 17 bits, so 3 bytes should be consumed.
 120     assertEquals(3, v.getSizeInBytes());
 121   }
 122
 123   @Test
 124   public void testAppendBitVector() {
 125     BitArray v1 = new BitArray();
 126     v1.appendBits(0xbe, 8);
 127     BitArray v2 = new BitArray();
 128     v2.appendBits(0xef, 8);
 129     v1.appendBitArray(v2);
 130     // beef = 1011 1110 1110 1111
 131     assertEquals(" X.XXXXX. XXX.XXXX", v1.toString());
 132   }
 133
 134   @Test
 135   public void testXOR() {
 136     {
 137       BitArray v1 = new BitArray();
 138       v1.appendBits(0x5555aaaa, 32);
 139       BitArray v2 = new BitArray();
 140       v2.appendBits(0xaaaa5555, 32);
 141       v1.xor(v2);
 142       assertEquals(0xffffffffL, getUnsignedInt(v1, 0));
 143     }
 144     {
 145       BitArray v1 = new BitArray();
 146       v1.appendBits(0x2a, 7);  // 010 1010
 147       BitArray v2 = new BitArray();
 148       v2.appendBits(0x55, 7);  // 101 0101
 149       v1.xor(v2);
 150       assertEquals(0xfe000000L, getUnsignedInt(v1, 0));  // 1111 1110
 151     }
 152   }
 153
 154   @Test
 155   public void testAt() {
 156     BitArray v = new BitArray();
 157     v.appendBits(0xdead, 16);  // 1101 1110 1010 1101
 158     assertTrue(v.get(0));
 159     assertTrue(v.get(1));
 160     assertFalse(v.get(2));
 161     assertTrue(v.get(3));
 162
 163     assertTrue(v.get(4));
 164     assertTrue(v.get(5));
 165     assertTrue(v.get(6));
 166     assertFalse(v.get(7));
 167
 168     assertTrue(v.get(8));
 169     assertFalse(v.get(9));
 170     assertTrue(v.get(10));
 171     assertFalse(v.get(11));
 172
 173     assertTrue(v.get(12));
 174     assertTrue(v.get(13));
 175     assertFalse(v.get(14));
 176     assertTrue(v.get(15));
 177   }
 178
 179   @Test
 180   public void testToString() {
 181     BitArray v = new BitArray();
 182     v.appendBits(0xdead, 16);  // 1101 1110 1010 1101
 183     assertEquals(" XX.XXXX. X.X.XX.X", v.toString());
 184   }
 185
 186 }