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