tests/net.mograsim.logic.core.tests/src/net/mograsim/logic/core/types/BitVectorTest.java

   1 package net.mograsim.logic.core.types;
   2
   3 import static net.mograsim.logic.core.types.Bit.ONE;
   4 import static net.mograsim.logic.core.types.Bit.U;
   5 import static net.mograsim.logic.core.types.Bit.X;
   6 import static net.mograsim.logic.core.types.Bit.Z;
   7 import static net.mograsim.logic.core.types.Bit.ZERO;
   8 import static net.mograsim.logic.core.types.BitVector.SINGLE_0;
   9 import static net.mograsim.logic.core.types.BitVector.SINGLE_1;
  10 import static net.mograsim.logic.core.types.BitVector.SINGLE_U;
  11 import static net.mograsim.logic.core.types.BitVector.SINGLE_X;
  12 import static net.mograsim.logic.core.types.BitVector.SINGLE_Z;
  13 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
  14 import static org.junit.jupiter.api.Assertions.assertEquals;
  15 import static org.junit.jupiter.api.Assertions.assertFalse;
  16 import static org.junit.jupiter.api.Assertions.assertNotEquals;
  17 import static org.junit.jupiter.api.Assertions.assertSame;
  18 import static org.junit.jupiter.api.Assertions.assertThrows;
  19 import static org.junit.jupiter.api.Assertions.assertTrue;
  20
  21 import java.math.BigInteger;
  22 import java.util.Iterator;
  23
  24 import org.junit.jupiter.api.Test;
  25
  26 @SuppressWarnings("static-method") // JUnit requires non-static methods
  27 class BitVectorTest
  28 {
  29
  30         @Test
  31         void testOfBitArray()
  32         {
  33                 BitVector.of(); // should be allowed and work
  34
  35                 assertSame(SINGLE_U, BitVector.of(U));
  36                 assertSame(SINGLE_X, BitVector.of(X));
  37                 assertSame(SINGLE_0, BitVector.of(ZERO));
  38                 assertSame(SINGLE_1, BitVector.of(ONE));
  39                 assertSame(SINGLE_Z, BitVector.of(Z));
  40         }
  41
  42         @Test
  43         void testOfBitInt()
  44         {
  45                 assertEquals(BitVector.of(), BitVector.of(ONE, 0));
  46
  47                 assertSame(SINGLE_U, BitVector.of(U, 1));
  48                 assertSame(SINGLE_X, BitVector.of(X, 1));
  49                 assertSame(SINGLE_0, BitVector.of(ZERO, 1));
  50                 assertSame(SINGLE_1, BitVector.of(ONE, 1));
  51                 assertSame(SINGLE_Z, BitVector.of(Z, 1));
  52
  53                 assertEquals(BitVector.of(X, X, X), BitVector.of(X, 3));
  54         }
  55
  56         @Test
  57         void testGetUnsignedValue()
  58         {
  59                 assertEquals(BigInteger.valueOf(0b101), BitVector.parseBitstring("101").getUnsignedValue());
  60                 assertEquals(BigInteger.valueOf(0b01010), BitVector.parseBitstring("01010").getUnsignedValue());
  61                 assertEquals(BigInteger.valueOf(0), BitVector.parseBitstring("0000").getUnsignedValue());
  62                 assertEquals(BigInteger.valueOf(0b0000000101), BitVector.parseBitstring("0000000101").getUnsignedValue());
  63                 assertEquals(BigInteger.valueOf(0b1010000000), BitVector.parseBitstring("1010000000").getUnsignedValue());
  64
  65                 assertThrows(NumberFormatException.class, () -> BitVector.parseBitstring("00X1").getUnsignedValue());
  66         }
  67
  68         @Test
  69         void testOfLongInt()
  70         {
  71                 assertEquals(BitVector.parseBitstring("101"), BitVector.from(0b101L, 3));
  72                 assertEquals(BitVector.parseBitstring("01010"), BitVector.from(0b01010L, 5));
  73                 assertEquals(BitVector.parseBitstring("10101"), BitVector.from(-11L, 5));
  74                 assertEquals(BitVector.parseBitstring("0000"), BitVector.from(0L, 4));
  75         }
  76
  77         @Test
  78         void testOfBigIntegerInt()
  79         {
  80                 assertEquals(BitVector.parseBitstring("101"), BitVector.from(BigInteger.valueOf(0b101), 3));
  81                 assertEquals(BitVector.parseBitstring("01010"), BitVector.from(BigInteger.valueOf(0b01010), 5));
  82                 assertEquals(BitVector.parseBitstring("10101"), BitVector.from(BigInteger.valueOf(-11), 5));
  83                 assertEquals(BitVector.parseBitstring("0000"), BitVector.from(BigInteger.valueOf(0), 4));
  84         }
  85
  86         @Test
  87         void testMutator()
  88         {
  89                 var bv = BitVector.SINGLE_1;
  90                 var bvm = bv.mutator();
  91
  92                 assertFalse(bvm.isEmpty());
  93                 assertEquals(ONE, bvm.getLSBit(0));
  94                 assertEquals(SINGLE_1, bvm.toBitVector());
  95         }
  96
  97         @Test
  98         void testGetMSBit()
  99         {
 100                 assertEquals(ONE, SINGLE_1.getMSBit(0));
 101                 assertEquals(ONE, BitVector.of(ONE, X, X, X).getMSBit(0));
 102                 assertEquals(ONE, BitVector.of(X, X, X, X, ONE, X).getMSBit(4));
 103         }
 104
 105         @Test
 106         void testGetLSBit()
 107         {
 108                 assertEquals(ONE, SINGLE_1.getLSBit(0));
 109                 assertEquals(ONE, BitVector.of(X, X, X, ONE).getLSBit(0));
 110                 assertEquals(ONE, BitVector.of(X, X, X, X, ONE, X).getLSBit(1));
 111         }
 112
 113         @Test
 114         void testGetBits()
 115         {
 116                 assertArrayEquals(new Bit[] { X, ONE, Z }, BitVector.of(X, ONE, Z).getBits());
 117                 assertArrayEquals(new Bit[] { X, ONE, Z }, BitVector.parseBitstring("X1Z").getBits());
 118         }
 119
 120         @Test
 121         void testIsBinary()
 122         {
 123                 assertTrue(SINGLE_0.isBinary());
 124                 assertTrue(SINGLE_1.isBinary());
 125
 126                 assertFalse(SINGLE_U.isBinary());
 127                 assertFalse(SINGLE_X.isBinary());
 128                 assertFalse(SINGLE_Z.isBinary());
 129
 130                 assertTrue(BitVector.of(ONE, ZERO, ONE, ONE, ZERO).isBinary());
 131                 assertFalse(BitVector.of(ONE, ZERO, ZERO, X).isBinary());
 132         }
 133
 134         @Test
 135         void testJoin()
 136         {
 137                 // binary
 138                 assertEquals(SINGLE_0, SINGLE_0.join(SINGLE_0));
 139                 assertEquals(SINGLE_X, SINGLE_0.join(SINGLE_1));
 140                 assertEquals(SINGLE_1, SINGLE_1.join(SINGLE_1));
 141
 142                 // other
 143                 assertEquals(SINGLE_1, SINGLE_Z.join(SINGLE_1));
 144                 assertEquals(SINGLE_U, SINGLE_0.join(SINGLE_U));
 145                 assertEquals(SINGLE_X, SINGLE_X.join(SINGLE_Z));
 146
 147                 // higher length
 148                 var result = BitVector.of(U, X, ZERO, ONE, Z).join(BitVector.of(ONE, ZERO, ZERO, ONE, Z));
 149                 assertEquals(BitVector.of(U, X, ZERO, ONE, Z), result);
 150         }
 151
 152         @Test
 153         void testAnd()
 154         {
 155                 // binary
 156                 assertEquals(SINGLE_0, SINGLE_0.and(SINGLE_0));
 157                 assertEquals(SINGLE_0, SINGLE_0.and(SINGLE_1));
 158                 assertEquals(SINGLE_1, SINGLE_1.and(SINGLE_1));
 159
 160                 // other
 161                 assertEquals(SINGLE_X, SINGLE_Z.and(SINGLE_1));
 162                 assertEquals(SINGLE_0, SINGLE_0.and(SINGLE_U));
 163                 assertEquals(SINGLE_X, SINGLE_X.and(SINGLE_Z));
 164
 165                 // higher length
 166                 var result = BitVector.of(U, X, ZERO, ONE, ONE).and(BitVector.of(ONE, ONE, ZERO, ZERO, ONE));
 167                 assertEquals(BitVector.of(U, X, ZERO, ZERO, ONE), result);
 168         }
 169
 170         @Test
 171         void testOr()
 172         {
 173                 // binary
 174                 assertEquals(SINGLE_0, SINGLE_0.or(SINGLE_0));
 175                 assertEquals(SINGLE_1, SINGLE_0.or(SINGLE_1));
 176                 assertEquals(SINGLE_1, SINGLE_1.or(SINGLE_1));
 177
 178                 // other
 179                 assertEquals(SINGLE_1, SINGLE_Z.or(SINGLE_1));
 180                 assertEquals(SINGLE_1, SINGLE_1.or(SINGLE_U));
 181                 assertEquals(SINGLE_X, SINGLE_X.or(SINGLE_Z));
 182
 183                 // higher length
 184                 var result = BitVector.of(U, X, ZERO, ONE, ZERO).or(BitVector.of(ZERO, ZERO, ZERO, ONE, ONE));
 185                 assertEquals(BitVector.of(U, X, ZERO, ONE, ONE), result);
 186         }
 187
 188         @Test
 189         void testXor()
 190         {
 191                 // binary
 192                 assertEquals(SINGLE_0, SINGLE_0.xor(SINGLE_0));
 193                 assertEquals(SINGLE_1, SINGLE_0.xor(SINGLE_1));
 194                 assertEquals(SINGLE_0, SINGLE_1.xor(SINGLE_1));
 195
 196                 // other
 197                 assertEquals(SINGLE_X, SINGLE_Z.xor(SINGLE_1));
 198                 assertEquals(SINGLE_U, SINGLE_0.xor(SINGLE_U));
 199                 assertEquals(SINGLE_X, SINGLE_X.xor(SINGLE_Z));
 200
 201                 // higher length
 202                 var result = BitVector.of(U, X, ZERO, ONE, ONE).xor(BitVector.of(ONE, ZERO, ZERO, ZERO, ONE));
 203                 assertEquals(BitVector.of(U, X, ZERO, ONE, ZERO), result);
 204         }
 205
 206         @Test
 207         void testNot()
 208         {
 209                 // binary
 210                 assertEquals(SINGLE_1, SINGLE_0.not());
 211                 assertEquals(SINGLE_0, SINGLE_1.not());
 212
 213                 // other
 214                 assertEquals(SINGLE_U, SINGLE_U.not());
 215                 assertEquals(SINGLE_X, SINGLE_X.not());
 216                 assertEquals(SINGLE_X, SINGLE_Z.not());
 217
 218                 // higher length
 219                 var result = BitVector.of(U, X, ZERO, ONE, Z).not();
 220                 assertEquals(BitVector.of(U, X, ONE, ZERO, X), result);
 221         }
 222
 223         @Test
 224         void testLength()
 225         {
 226                 assertEquals(0, BitVector.of().length());
 227                 assertEquals(1, SINGLE_0.length());
 228                 assertEquals(3, BitVector.of(X, X, Z).length());
 229         }
 230
 231         @Test
 232         void testConcat()
 233         {
 234                 assertEquals(BitVector.of(U, X), SINGLE_U.concat(SINGLE_X));
 235                 assertEquals(BitVector.of(Z, X, U, ONE, X), BitVector.of(Z, X, U).concat(BitVector.of(ONE, X)));
 236         }
 237
 238         @Test
 239         void testSubVectorInt()
 240         {
 241                 assertEquals(SINGLE_0, SINGLE_0.subVector(0));
 242                 assertEquals(BitVector.of(), SINGLE_0.subVector(1));
 243                 assertEquals(SINGLE_0, BitVector.of(ONE, ZERO).subVector(1));
 244                 assertEquals(BitVector.of(X, Z), BitVector.of(ZERO, U, ONE, X, Z).subVector(3));
 245         }
 246
 247         @Test
 248         void testSubVectorIntInt()
 249         {
 250                 assertEquals(SINGLE_0, SINGLE_0.subVector(0, 1));
 251                 assertEquals(BitVector.of(), SINGLE_0.subVector(0, 0));
 252                 assertEquals(SINGLE_0, BitVector.of(ONE, ZERO).subVector(1, 2));
 253                 assertEquals(BitVector.of(ONE, X), BitVector.of(ZERO, U, ONE, X, Z).subVector(2, 4));
 254         }
 255
 256         @Test
 257         void testEqualsObject()
 258         {
 259                 assertEquals(SINGLE_X, SINGLE_X);
 260                 assertNotEquals(SINGLE_0, SINGLE_1);
 261
 262                 assertEquals(BitVector.of(X, Z, U), BitVector.of(X, Z, U));
 263                 assertNotEquals(BitVector.of(X, Z, U), BitVector.of(X, X, U));
 264         }
 265
 266         @Test
 267         void testEqualsWithOffset()
 268         {
 269                 assertTrue(SINGLE_X.equalsWithOffset(SINGLE_X, 0));
 270                 assertFalse(SINGLE_0.equalsWithOffset(SINGLE_1, 0));
 271
 272                 assertTrue(BitVector.of(X, Z, U).equalsWithOffset(BitVector.of(Z, U), 1));
 273                 assertFalse(BitVector.of(X, Z, U).equalsWithOffset(BitVector.of(X, U), 1));
 274                 assertTrue(BitVector.of(X, Z, U).equalsWithOffset(BitVector.of(U), 2));
 275         }
 276
 277         @Test
 278         void testParse()
 279         {
 280                 assertEquals(SINGLE_U, BitVector.parseBitstring("U"));
 281                 assertEquals(SINGLE_X, BitVector.parseBitstring("X"));
 282                 assertEquals(SINGLE_0, BitVector.parseBitstring("0"));
 283                 assertEquals(SINGLE_1, BitVector.parseBitstring("1"));
 284                 assertEquals(SINGLE_Z, BitVector.parseBitstring("Z"));
 285
 286                 assertEquals(BitVector.of(X, U, Z, ONE, ZERO), BitVector.parseBitstring("XUZ10"));
 287
 288                 assertThrows(RuntimeException.class, () -> BitVector.parseBitstring("01BX"));
 289         }
 290
 291         @Test
 292         void testIterator()
 293         {
 294                 var bv = BitVector.of(U, Z, ONE, ZERO, X);
 295                 Iterator<Bit> it = bv.iterator();
 296
 297                 assertEquals(U, it.next());
 298                 assertEquals(Z, it.next());
 299                 assertEquals(ONE, it.next());
 300                 assertEquals(ZERO, it.next());
 301                 assertEquals(X, it.next());
 302                 assertFalse(it.hasNext());
 303         }
 304 }