net.mograsim.logic.core/test/net/mograsim/logic/core/types/BitVectorTest.java

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