net.mograsim.logic.core/test/net/mograsim/logic/core/tests/ComponentTest.java

   1 package net.mograsim.logic.core.tests;
   2
   3 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
   4 import static org.junit.jupiter.api.Assertions.assertEquals;
   5 import static org.junit.jupiter.api.Assertions.fail;
   6
   7 import java.math.BigInteger;
   8 import java.util.Random;
   9 import java.util.function.LongConsumer;
  10
  11 import org.junit.Before;
  12 import org.junit.jupiter.api.Test;
  13
  14 import net.mograsim.logic.core.components.Connector;
  15 import net.mograsim.logic.core.components.Demux;
  16 import net.mograsim.logic.core.components.Merger;
  17 import net.mograsim.logic.core.components.Mux;
  18 import net.mograsim.logic.core.components.Splitter;
  19 import net.mograsim.logic.core.components.TriStateBuffer;
  20 import net.mograsim.logic.core.components.gates.AndGate;
  21 import net.mograsim.logic.core.components.gates.NandGate;
  22 import net.mograsim.logic.core.components.gates.NorGate;
  23 import net.mograsim.logic.core.components.gates.NotGate;
  24 import net.mograsim.logic.core.components.gates.OrGate;
  25 import net.mograsim.logic.core.components.gates.WordAddressableMemoryComponent;
  26 import net.mograsim.logic.core.components.gates.XorGate;
  27 import net.mograsim.logic.core.timeline.Timeline;
  28 import net.mograsim.logic.core.types.Bit;
  29 import net.mograsim.logic.core.types.BitVector;
  30 import net.mograsim.logic.core.wires.Wire;
  31 import net.mograsim.logic.core.wires.Wire.ReadEnd;
  32 import net.mograsim.logic.core.wires.Wire.ReadWriteEnd;
  33
  34 @SuppressWarnings("unused")
  35 class ComponentTest
  36 {
  37         private Timeline t = new Timeline(11);
  38
  39         @Before
  40         void resetTimeline()
  41         {
  42                 t.reset();
  43         }
  44
  45         @Test
  46         void circuitExampleTest()
  47         {
  48                 Wire a = new Wire(t, 1, 1), b = new Wire(t, 1, 1), c = new Wire(t, 1, 10), d = new Wire(t, 2, 1), e = new Wire(t, 1, 1),
  49                                 f = new Wire(t, 1, 1), g = new Wire(t, 1, 1), h = new Wire(t, 2, 1), i = new Wire(t, 2, 1), j = new Wire(t, 1, 1),
  50                                 k = new Wire(t, 1, 1);
  51                 new AndGate(t, 1, f.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());
  52                 new NotGate(t, 1, f.createReadOnlyEnd(), g.createReadWriteEnd());
  53                 new Merger(t, h.createReadWriteEnd(), c.createReadOnlyEnd(), g.createReadOnlyEnd());
  54                 new Mux(t, 1, i.createReadWriteEnd(), e.createReadOnlyEnd(), h.createReadOnlyEnd(), d.createReadOnlyEnd());
  55                 new Splitter(t, i.createReadOnlyEnd(), k.createReadWriteEnd(), j.createReadWriteEnd());
  56
  57                 a.createReadWriteEnd().feedSignals(Bit.ZERO);
  58                 b.createReadWriteEnd().feedSignals(Bit.ONE);
  59                 c.createReadWriteEnd().feedSignals(Bit.ZERO);
  60                 d.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE);
  61                 e.createReadWriteEnd().feedSignals(Bit.ZERO);
  62
  63                 t.executeAll();
  64
  65                 assertEquals(Bit.ONE, j.getValue());
  66                 assertEquals(Bit.ZERO, k.getValue());
  67         }
  68
  69         @Test
  70         void splitterTest()
  71         {
  72                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 2, 1), c = new Wire(t, 3, 1), in = new Wire(t, 8, 1);
  73                 in.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
  74                 new Splitter(t, in.createReadOnlyEnd(), a.createReadWriteEnd(), b.createReadWriteEnd(), c.createReadWriteEnd());
  75
  76                 t.executeAll();
  77
  78                 assertBitArrayEquals(a.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO);
  79                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.ZERO);
  80                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE);
  81         }
  82
  83         @Test
  84         void mergerTest()
  85         {
  86                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 2, 1), c = new Wire(t, 3, 1), out = new Wire(t, 8, 1);
  87                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO);
  88                 b.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO);
  89                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
  90
  91                 new Merger(t, out.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
  92
  93                 t.executeAll();
  94
  95                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
  96         }
  97
  98         @Test
  99         void fusionTest1()
 100         {
 101                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 2, 1), c = new Wire(t, 3, 1), out = new Wire(t, 8, 1);
 102                 Wire.fuse(a, out, 0, 0, a.length);
 103                 Wire.fuse(b, out, 0, a.length, b.length);
 104                 Wire.fuse(c, out, 0, a.length + b.length, c.length);
 105                 ReadWriteEnd rA = a.createReadWriteEnd();
 106                 rA.feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO);
 107                 ReadWriteEnd rB = b.createReadWriteEnd();
 108                 rB.feedSignals(Bit.ONE, Bit.ZERO);
 109                 ReadWriteEnd rC = c.createReadWriteEnd();
 110                 rC.feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
 111
 112                 t.executeAll();
 113                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 114                 out.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 115                 t.executeAll();
 116                 assertBitArrayEquals(rA.getValues(), Bit.X, Bit.X, Bit.X);
 117                 assertBitArrayEquals(rB.getValues(), Bit.X, Bit.X);
 118                 assertBitArrayEquals(rC.getValues(), Bit.X, Bit.X, Bit.X);
 119                 rA.clearSignals();
 120                 rB.clearSignals();
 121                 rC.clearSignals();
 122                 t.executeAll();
 123                 assertBitArrayEquals(rA.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE);
 124                 assertBitArrayEquals(rB.getValues(), Bit.ZERO, Bit.ONE);
 125                 assertBitArrayEquals(rC.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO);
 126         }
 127
 128         @Test
 129         void fusionTest2()
 130         {
 131                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 3, 1);
 132                 Wire.fuse(a, b);
 133                 ReadWriteEnd rw = a.createReadWriteEnd();
 134                 t.executeAll();
 135                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U);
 136
 137                 rw.feedSignals(Bit.ONE, Bit.U, Bit.Z);
 138                 t.executeAll();
 139                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.U, Bit.Z);
 140         }
 141
 142         @Test
 143         void fusionTest3()
 144         {
 145                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 3, 1);
 146                 a.createReadWriteEnd().feedSignals(Bit.Z, Bit.U, Bit.X);
 147                 t.executeAll();
 148                 Wire.fuse(a, b);
 149                 t.executeAll();
 150                 assertBitArrayEquals(b.getValues(), Bit.Z, Bit.U, Bit.X);
 151         }
 152
 153 //      @Test
 154 //      void connectorTest()
 155 //      {
 156 //              t.reset();
 157 //              Wire a = new Wire(t, 3, 1), b = new Wire(t, 3, 1);
 158 //              new Connector(t, a.createReadWriteEnd(), b.createReadWriteEnd()).connect();
 159 ////            b.createReadWriteEnd();
 160 //              a.createReadWriteEnd();
 161 //              t.executeAll();
 162 //              assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U);
 163 //      }
 164
 165         @Test
 166         void triStateBufferTest()
 167         {
 168                 Wire a = new Wire(t, 1, 1), b = new Wire(t, 1, 1), en = new Wire(t, 1, 1), notEn = new Wire(t, 1, 1);
 169                 new NotGate(t, 1, en.createReadOnlyEnd(), notEn.createReadWriteEnd());
 170                 new TriStateBuffer(t, 1, a.createReadOnlyEnd(), b.createReadWriteEnd(), en.createReadOnlyEnd());
 171                 new TriStateBuffer(t, 1, b.createReadOnlyEnd(), a.createReadWriteEnd(), notEn.createReadOnlyEnd());
 172
 173                 ReadWriteEnd enI = en.createReadWriteEnd(), aI = a.createReadWriteEnd(), bI = b.createReadWriteEnd();
 174                 enI.feedSignals(Bit.ONE);
 175                 aI.feedSignals(Bit.ONE);
 176                 bI.feedSignals(Bit.Z);
 177
 178                 t.executeAll();
 179
 180                 assertEquals(Bit.ONE, b.getValue());
 181
 182                 bI.feedSignals(Bit.ZERO);
 183
 184                 t.executeAll();
 185
 186                 assertEquals(Bit.X, b.getValue());
 187                 assertEquals(Bit.ONE, a.getValue());
 188
 189                 aI.clearSignals();
 190                 enI.feedSignals(Bit.ZERO);
 191
 192                 t.executeAll();
 193
 194                 assertEquals(Bit.ZERO, a.getValue());
 195
 196         }
 197
 198         @Test
 199         void muxTest()
 200         {
 201                 Wire a = new Wire(t, 4, 3), b = new Wire(t, 4, 6), c = new Wire(t, 4, 4), select = new Wire(t, 2, 5), out = new Wire(t, 4, 1);
 202                 ReadWriteEnd selectIn = select.createReadWriteEnd();
 203
 204                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);
 205                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 206                 c.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 207
 208                 new Mux(t, 1, out.createReadWriteEnd(), select.createReadOnlyEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(),
 209                                 c.createReadOnlyEnd());
 210                 t.executeAll();
 211
 212                 assertBitArrayEquals(out.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 213                 selectIn.feedSignals(Bit.ZERO, Bit.ONE);
 214                 t.executeAll();
 215
 216                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 217
 218                 selectIn.feedSignals(Bit.ONE, Bit.ONE);
 219                 t.executeAll();
 220
 221                 assertBitArrayEquals(out.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 222
 223         }
 224
 225         @Test
 226         void demuxTest()
 227         {
 228                 Wire a = new Wire(t, 4, 3), b = new Wire(t, 4, 6), c = new Wire(t, 4, 4), select = new Wire(t, 2, 5), in = new Wire(t, 4, 1);
 229                 ReadWriteEnd selectIn = select.createReadWriteEnd();
 230
 231                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);
 232                 in.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 233
 234                 new Demux(t, 1, in.createReadOnlyEnd(), select.createReadOnlyEnd(), a.createReadWriteEnd(), b.createReadWriteEnd(),
 235                                 c.createReadWriteEnd());
 236                 t.executeAll();
 237
 238                 assertBitArrayEquals(a.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 239                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 240                 assertBitArrayEquals(c.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 241                 selectIn.feedSignals(Bit.ZERO, Bit.ONE);
 242                 t.executeAll();
 243
 244                 assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 245                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 246                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 247
 248                 selectIn.feedSignals(Bit.ONE, Bit.ONE);
 249                 t.executeAll();
 250
 251                 assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 252                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 253                 assertBitArrayEquals(c.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 254
 255         }
 256
 257         @Test
 258         void andTest()
 259         {
 260                 Wire a = new Wire(t, 4, 1), b = new Wire(t, 4, 3), c = new Wire(t, 4, 1);
 261                 new AndGate(t, 1, c.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());
 262                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 263                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 264
 265                 t.executeAll();
 266
 267                 assertBitArrayEquals(c.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ZERO);
 268         }
 269
 270         @Test
 271         void orTest()
 272         {
 273                 Wire a = new Wire(t, 4, 1), b = new Wire(t, 4, 3), c = new Wire(t, 4, 1);
 274                 new OrGate(t, 1, c.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());
 275                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 276                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 277
 278                 t.executeAll();
 279
 280                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ONE);
 281         }
 282
 283         @Test
 284         void nandTest()
 285         {
 286                 Wire a = new Wire(t, 4, 1), b = new Wire(t, 4, 3), c = new Wire(t, 4, 1), d = new Wire(t, 4, 1);
 287                 new NandGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
 288                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 289                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 290                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 291
 292                 t.executeAll();
 293
 294                 assertBitArrayEquals(d.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ONE);
 295         }
 296
 297         @Test
 298         void norTest()
 299         {
 300                 Wire a = new Wire(t, 4, 1), b = new Wire(t, 4, 3), c = new Wire(t, 4, 1), d = new Wire(t, 4, 1);
 301                 new NorGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
 302                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 303                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 304                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 305
 306                 t.executeAll();
 307
 308                 assertBitArrayEquals(d.getValues(), Bit.ZERO, Bit.ZERO, Bit.ONE, Bit.ZERO);
 309         }
 310
 311         @Test
 312         void xorTest()
 313         {
 314                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 3, 2), c = new Wire(t, 3, 1), d = new Wire(t, 3, 1);
 315                 new XorGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
 316                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);
 317                 b.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
 318                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
 319
 320                 t.executeAll();
 321
 322                 assertBitArrayEquals(d.getValues(), Bit.ZERO, Bit.ONE, Bit.ONE);
 323         }
 324
 325         @Test
 326         void notTest()
 327         {
 328                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 3, 2);
 329                 new NotGate(t, 1, a.createReadOnlyEnd(), b.createReadWriteEnd());
 330                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);
 331
 332                 t.executeAll();
 333
 334                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.ZERO, Bit.ZERO);
 335         }
 336
 337         @Test
 338         void rsLatchCircuitTest()
 339         {
 340                 Wire r = new Wire(t, 1, 1), s = new Wire(t, 1, 1), t1 = new Wire(t, 1, 15), t2 = new Wire(t, 1, 1), q = new Wire(t, 1, 1),
 341                                 nq = new Wire(t, 1, 1);
 342
 343                 new OrGate(t, 1, t2.createReadWriteEnd(), r.createReadOnlyEnd(), nq.createReadOnlyEnd());
 344                 new OrGate(t, 1, t1.createReadWriteEnd(), s.createReadOnlyEnd(), q.createReadOnlyEnd());
 345                 new NotGate(t, 1, t2.createReadOnlyEnd(), q.createReadWriteEnd());
 346                 new NotGate(t, 1, t1.createReadOnlyEnd(), nq.createReadWriteEnd());
 347
 348                 ReadWriteEnd sIn = s.createReadWriteEnd(), rIn = r.createReadWriteEnd();
 349
 350                 sIn.feedSignals(Bit.ONE);
 351                 rIn.feedSignals(Bit.ZERO);
 352
 353                 t.executeAll();
 354
 355                 assertEquals(Bit.ONE, q.getValue());
 356                 assertEquals(Bit.ZERO, nq.getValue());
 357
 358                 sIn.feedSignals(Bit.ZERO);
 359
 360                 t.executeAll();
 361                 assertEquals(Bit.ONE, q.getValue());
 362                 assertEquals(Bit.ZERO, nq.getValue());
 363
 364                 rIn.feedSignals(Bit.ONE);
 365
 366                 t.executeAll();
 367
 368                 assertEquals(Bit.ZERO, q.getValue());
 369                 assertEquals(Bit.ONE, nq.getValue());
 370         }
 371
 372         @Test
 373         void numericValueTest()
 374         {
 375                 Wire a = new Wire(t, 4, 1);
 376                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ONE, Bit.ONE);
 377
 378                 t.executeAll();
 379
 380                 assertEquals(15, a.getUnsignedValue());
 381                 assertEquals(-1, a.getSignedValue());
 382         }
 383
 384         boolean flag = false;
 385
 386         @Test
 387         void simpleTimelineTest()
 388         {
 389                 Timeline t = new Timeline(3);
 390                 flag = false;
 391                 t.addEvent((e) ->
 392                 {
 393                         if (!flag)
 394                                 fail("Events executed out of order!");
 395                         flag = false;
 396                 }, 15);
 397                 t.addEvent((e) ->
 398                 {
 399                         if (flag)
 400                                 fail("Events executed out of order!");
 401                         flag = true;
 402                 }, 10);
 403                 t.addEvent((e) ->
 404                 {
 405                         if (flag)
 406                                 fail("Events executed out of order!");
 407                         flag = true;
 408                 }, 20);
 409                 t.addEvent((e) ->
 410                 {
 411                         fail("Only supposed to execute until timestamp 20, not 25");
 412                 }, 25);
 413
 414                 t.executeUntil(t.laterThan(20), 100);
 415
 416                 if (!flag)
 417                         fail("Not all events were executed in order!");
 418         }
 419
 420         @Test
 421         void multipleInputs()
 422         {
 423                 Wire w = new Wire(t, 2, 1);
 424                 ReadWriteEnd wI1 = w.createReadWriteEnd(), wI2 = w.createReadWriteEnd();
 425                 wI1.feedSignals(Bit.ONE, Bit.Z);
 426                 wI2.feedSignals(Bit.Z, Bit.X);
 427                 t.executeAll();
 428                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.X);
 429
 430                 wI2.feedSignals(Bit.ZERO, Bit.Z);
 431                 t.executeAll();
 432                 assertBitArrayEquals(w.getValues(), Bit.X, Bit.Z);
 433
 434                 wI2.feedSignals(Bit.Z, Bit.Z);
 435                 t.executeAll();
 436                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);
 437
 438                 wI2.feedSignals(Bit.ONE, Bit.Z);
 439                 ReadEnd rE = w.createReadOnlyEnd();
 440                 rE.registerObserver((i) -> fail("WireEnd notified observer, although value did not change."));
 441                 t.executeAll();
 442                 rE.close();
 443                 wI1.feedSignals(Bit.X, Bit.X);
 444                 t.executeAll();
 445                 wI1.registerObserver((i) -> fail("WireEnd notified observer, although it was closed."));
 446                 wI1.close();
 447                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);
 448         }
 449
 450         @Test
 451         void wireConnections()
 452         {
 453                 // Nur ein Experiment, was über mehrere 'passive' Bausteine hinweg passieren würde
 454
 455                 Wire a = new Wire(t, 1, 2);
 456                 Wire b = new Wire(t, 1, 2);
 457                 Wire c = new Wire(t, 1, 2);
 458                 ReadWriteEnd aI = a.createReadWriteEnd();
 459                 ReadWriteEnd bI = b.createReadWriteEnd();
 460                 ReadWriteEnd cI = c.createReadWriteEnd();
 461
 462                 TestBitDisplay test = new TestBitDisplay(t, c.createReadOnlyEnd());
 463                 TestBitDisplay test2 = new TestBitDisplay(t, a.createReadOnlyEnd());
 464                 LongConsumer print = time -> System.out.format("Time %2d\n a: %s\n b: %s\n c: %s\n", time, a, b, c);
 465
 466                 cI.feedSignals(Bit.ONE);
 467                 test.assertAfterSimulationIs(print, Bit.ONE);
 468
 469                 cI.feedSignals(Bit.X);
 470                 test.assertAfterSimulationIs(print, Bit.X);
 471
 472                 cI.feedSignals(Bit.X);
 473                 cI.feedSignals(Bit.Z);
 474                 test.assertAfterSimulationIs(print, Bit.Z);
 475
 476                 new Connector(t, b.createReadWriteEnd(), c.createReadWriteEnd()).connect();
 477                 test.assertAfterSimulationIs(print, Bit.Z);
 478                 System.err.println("ONE");
 479                 bI.feedSignals(Bit.ONE);
 480                 test.assertAfterSimulationIs(print, Bit.ONE);
 481                 System.err.println("ZERO");
 482                 bI.feedSignals(Bit.ZERO);
 483                 test.assertAfterSimulationIs(print, Bit.ZERO);
 484                 System.err.println("Z");
 485                 bI.feedSignals(Bit.Z);
 486                 test.assertAfterSimulationIs(print, Bit.Z);
 487
 488                 new Connector(t, a.createReadWriteEnd(), b.createReadWriteEnd()).connect();
 489                 System.err.println("Z 2");
 490                 aI.feedSignals(Bit.Z);
 491                 test.assertAfterSimulationIs(print, Bit.Z);
 492                 test2.assertAfterSimulationIs(Bit.Z);
 493                 System.err.println("ONE 2");
 494                 aI.feedSignals(Bit.ONE);
 495                 test.assertAfterSimulationIs(print, Bit.ONE);
 496                 test2.assertAfterSimulationIs(Bit.ONE);
 497                 System.err.println("ZERO 2");
 498                 aI.feedSignals(Bit.ZERO);
 499                 test.assertAfterSimulationIs(print, Bit.ZERO);
 500                 test2.assertAfterSimulationIs(Bit.ZERO);
 501                 System.err.println("Z 2 II");
 502                 aI.feedSignals(Bit.Z);
 503                 test.assertAfterSimulationIs(print, Bit.Z);
 504                 test2.assertAfterSimulationIs(Bit.Z);
 505
 506                 System.err.println("No Conflict yet");
 507                 bI.feedSignals(Bit.ONE);
 508                 test.assertAfterSimulationIs(print, Bit.ONE);
 509                 test2.assertAfterSimulationIs(Bit.ONE);
 510                 aI.feedSignals(Bit.ONE);
 511                 test.assertAfterSimulationIs(print, Bit.ONE);
 512                 test2.assertAfterSimulationIs(Bit.ONE);
 513                 System.err.println("Conflict");
 514                 aI.feedSignals(Bit.ZERO);
 515                 test.assertAfterSimulationIs(print, Bit.X);
 516                 test2.assertAfterSimulationIs(Bit.X);
 517                 aI.feedSignals(Bit.ONE);
 518                 test.assertAfterSimulationIs(print, Bit.ONE);
 519                 test2.assertAfterSimulationIs(Bit.ONE);
 520         }
 521
 522         @Test
 523         public void wordAddressableMemoryLargeTest()
 524         {
 525                 Wire rW = new Wire(t, 1, 2);
 526                 Wire data = new Wire(t, 16, 2);
 527                 Wire address = new Wire(t, 64, 2);
 528                 ReadWriteEnd rWI = rW.createReadWriteEnd();
 529                 ReadWriteEnd dataI = data.createReadWriteEnd();
 530                 ReadWriteEnd addressI = address.createReadWriteEnd();
 531
 532                 WordAddressableMemoryComponent memory = new WordAddressableMemoryComponent(t, 4, 4096L, Long.MAX_VALUE, data.createReadWriteEnd(),
 533                                 rW.createReadOnlyEnd(), address.createReadOnlyEnd());
 534
 535                 Random r = new Random();
 536                 for (long j = 1; j > 0; j *= 2)
 537                 {
 538                         for (int i = 0; i < 50; i++)
 539                         {
 540                                 String sAddress = String.format("%64s", BigInteger.valueOf(4096 + i + j).toString(2)).replace(' ', '0');
 541                                 sAddress = new StringBuilder(sAddress).reverse().toString();
 542                                 BitVector bAddress = BitVector.parse(sAddress);
 543                                 addressI.feedSignals(bAddress);
 544                                 t.executeAll();
 545                                 String random = BigInteger.valueOf(Math.abs(r.nextInt())).toString(5);
 546                                 random = random.substring(Integer.max(0, random.length() - 16));
 547                                 random = String.format("%16s", random).replace(' ', '0');
 548                                 random = random.replace('2', 'X').replace('3', 'Z').replace('4', 'U');
 549                                 BitVector vector = BitVector.parse(random);
 550                                 dataI.feedSignals(vector);
 551                                 rWI.feedSignals(Bit.ZERO);
 552                                 t.executeAll();
 553                                 rWI.feedSignals(Bit.ONE);
 554                                 t.executeAll();
 555                                 dataI.clearSignals();
 556                                 t.executeAll();
 557
 558                                 assertBitArrayEquals(dataI.getValues(), vector.getBits());
 559                         }
 560                 }
 561         }
 562
 563         private static void assertBitArrayEquals(BitVector actual, Bit... expected)
 564         {
 565                 assertArrayEquals(expected, actual.getBits());
 566         }
 567 }