net.mograsim.logic.core/test/net/mograsim/logic/core/tests/CoreComponentTest.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 org.junit.jupiter.api.BeforeEach;
   8 import org.junit.jupiter.api.Disabled;
   9 import org.junit.jupiter.api.Test;
  10
  11 import net.mograsim.logic.core.components.CoreDemux;
  12 import net.mograsim.logic.core.components.CoreMux;
  13 import net.mograsim.logic.core.components.CoreTriStateBuffer;
  14 import net.mograsim.logic.core.components.CoreUnidirectionalMerger;
  15 import net.mograsim.logic.core.components.CoreUnidirectionalSplitter;
  16 import net.mograsim.logic.core.components.gates.CoreAndGate;
  17 import net.mograsim.logic.core.components.gates.CoreNandGate;
  18 import net.mograsim.logic.core.components.gates.CoreNorGate;
  19 import net.mograsim.logic.core.components.gates.CoreNotGate;
  20 import net.mograsim.logic.core.components.gates.CoreOrGate;
  21 import net.mograsim.logic.core.components.gates.CoreXorGate;
  22 import net.mograsim.logic.core.timeline.Timeline;
  23 import net.mograsim.logic.core.types.Bit;
  24 import net.mograsim.logic.core.types.BitVector;
  25 import net.mograsim.logic.core.wires.CoreWire;
  26 import net.mograsim.logic.core.wires.CoreWire.ReadEnd;
  27 import net.mograsim.logic.core.wires.CoreWire.ReadWriteEnd;
  28
  29 @SuppressWarnings("unused")
  30 class CoreComponentTest
  31 {
  32         private Timeline t = new Timeline(11);
  33
  34         @BeforeEach
  35         void resetTimeline()
  36         {
  37                 t.reset();
  38         }
  39
  40         @Test
  41         void circuitExampleTest()
  42         {
  43                 CoreWire a = new CoreWire(t, 1, 1), b = new CoreWire(t, 1, 1), c = new CoreWire(t, 1, 10), d = new CoreWire(t, 2, 1), e = new CoreWire(t, 1, 1),
  44                                 f = new CoreWire(t, 1, 1), g = new CoreWire(t, 1, 1), h = new CoreWire(t, 2, 1), i = new CoreWire(t, 2, 1), j = new CoreWire(t, 1, 1),
  45                                 k = new CoreWire(t, 1, 1);
  46                 new CoreAndGate(t, 1, f.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());
  47                 new CoreNotGate(t, 1, f.createReadOnlyEnd(), g.createReadWriteEnd());
  48                 new CoreUnidirectionalMerger(t, h.createReadWriteEnd(), c.createReadOnlyEnd(), g.createReadOnlyEnd());
  49                 new CoreMux(t, 1, i.createReadWriteEnd(), e.createReadOnlyEnd(), h.createReadOnlyEnd(), d.createReadOnlyEnd());
  50                 new CoreUnidirectionalSplitter(t, i.createReadOnlyEnd(), k.createReadWriteEnd(), j.createReadWriteEnd());
  51
  52                 a.createReadWriteEnd().feedSignals(Bit.ZERO);
  53                 b.createReadWriteEnd().feedSignals(Bit.ONE);
  54                 c.createReadWriteEnd().feedSignals(Bit.ZERO);
  55                 d.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE);
  56                 e.createReadWriteEnd().feedSignals(Bit.ZERO);
  57
  58                 t.executeAll();
  59
  60                 assertEquals(Bit.ONE, j.getValue());
  61                 assertEquals(Bit.ZERO, k.getValue());
  62         }
  63
  64         @Test
  65         void splitterTest()
  66         {
  67                 CoreWire a = new CoreWire(t, 3, 1), b = new CoreWire(t, 2, 1), c = new CoreWire(t, 3, 1), in = new CoreWire(t, 8, 1);
  68                 in.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
  69                 new CoreUnidirectionalSplitter(t, in.createReadOnlyEnd(), a.createReadWriteEnd(), b.createReadWriteEnd(), c.createReadWriteEnd());
  70
  71                 t.executeAll();
  72
  73                 assertBitArrayEquals(a.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO);
  74                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.ZERO);
  75                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE);
  76         }
  77
  78         @Test
  79         void mergerTest()
  80         {
  81                 CoreWire a = new CoreWire(t, 3, 1), b = new CoreWire(t, 2, 1), c = new CoreWire(t, 3, 1), out = new CoreWire(t, 8, 1);
  82                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO);
  83                 b.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO);
  84                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
  85
  86                 new CoreUnidirectionalMerger(t, out.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
  87
  88                 t.executeAll();
  89
  90                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
  91         }
  92
  93         @Test
  94         void fusionTest1()
  95         {
  96                 CoreWire a = new CoreWire(t, 3, 1), b = new CoreWire(t, 2, 1), c = new CoreWire(t, 3, 1), out = new CoreWire(t, 8, 1);
  97                 CoreWire.fuse(a, out, 0, 0, a.width);
  98                 CoreWire.fuse(b, out, 0, a.width, b.width);
  99                 CoreWire.fuse(c, out, 0, a.width + b.width, c.width);
 100                 ReadWriteEnd rA = a.createReadWriteEnd();
 101                 rA.feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO);
 102                 ReadWriteEnd rB = b.createReadWriteEnd();
 103                 rB.feedSignals(Bit.ONE, Bit.ZERO);
 104                 ReadWriteEnd rC = c.createReadWriteEnd();
 105                 rC.feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
 106
 107                 t.executeAll();
 108                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 109                 out.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 110                 t.executeAll();
 111                 assertBitArrayEquals(rA.getValues(), Bit.X, Bit.X, Bit.X);
 112                 assertBitArrayEquals(rB.getValues(), Bit.X, Bit.X);
 113                 assertBitArrayEquals(rC.getValues(), Bit.X, Bit.X, Bit.X);
 114                 rA.clearSignals();
 115                 rB.clearSignals();
 116                 rC.clearSignals();
 117                 t.executeAll();
 118                 assertBitArrayEquals(rA.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE);
 119                 assertBitArrayEquals(rB.getValues(), Bit.ZERO, Bit.ONE);
 120                 assertBitArrayEquals(rC.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO);
 121         }
 122
 123         @Test
 124         void fusionTest2()
 125         {
 126                 CoreWire a = new CoreWire(t, 3, 1), b = new CoreWire(t, 3, 1);
 127                 CoreWire.fuse(a, b);
 128                 ReadWriteEnd rw = a.createReadWriteEnd();
 129                 t.executeAll();
 130                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U);
 131
 132                 rw.feedSignals(Bit.ONE, Bit.U, Bit.Z);
 133                 t.executeAll();
 134                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.U, Bit.Z);
 135         }
 136
 137         @Test
 138         void fusionTest3()
 139         {
 140                 CoreWire a = new CoreWire(t, 3, 1), b = new CoreWire(t, 3, 1);
 141                 a.createReadWriteEnd().feedSignals(Bit.Z, Bit.U, Bit.X);
 142                 t.executeAll();
 143                 CoreWire.fuse(a, b);
 144                 t.executeAll();
 145                 assertBitArrayEquals(b.getValues(), Bit.Z, Bit.U, Bit.X);
 146         }
 147
 148         @Test
 149         void fusionTest4()
 150         {
 151                 CoreWire a = new CoreWire(t, 3, 1), b = new CoreWire(t, 3, 1);
 152                 a.createReadWriteEnd();
 153                 t.executeAll();
 154
 155                 CoreWire.fuse(a, b);
 156                 t.executeAll();
 157                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U);
 158         }
 159
 160 //      @Test
 161 //      void connectorTest()
 162 //      {
 163 //              t.reset();
 164 //              Wire a = new Wire(t, 3, 1), b = new Wire(t, 3, 1);
 165 //              new Connector(t, a.createReadWriteEnd(), b.createReadWriteEnd()).connect();
 166 ////            b.createReadWriteEnd();
 167 //              a.createReadWriteEnd();
 168 //              t.executeAll();
 169 //              assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U);
 170 //      }
 171
 172         @Test
 173         void triStateBufferTest()
 174         {
 175                 CoreWire a = new CoreWire(t, 1, 1), b = new CoreWire(t, 1, 1), en = new CoreWire(t, 1, 1), notEn = new CoreWire(t, 1, 1);
 176                 new CoreNotGate(t, 1, en.createReadOnlyEnd(), notEn.createReadWriteEnd());
 177                 new CoreTriStateBuffer(t, 1, a.createReadOnlyEnd(), b.createReadWriteEnd(), en.createReadOnlyEnd());
 178                 new CoreTriStateBuffer(t, 1, b.createReadOnlyEnd(), a.createReadWriteEnd(), notEn.createReadOnlyEnd());
 179
 180                 ReadWriteEnd enI = en.createReadWriteEnd(), aI = a.createReadWriteEnd(), bI = b.createReadWriteEnd();
 181                 enI.feedSignals(Bit.ONE);
 182                 aI.feedSignals(Bit.ONE);
 183                 bI.feedSignals(Bit.Z);
 184
 185                 t.executeAll();
 186
 187                 assertEquals(Bit.ONE, b.getValue());
 188
 189                 bI.feedSignals(Bit.ZERO);
 190
 191                 t.executeAll();
 192
 193                 assertEquals(Bit.X, b.getValue());
 194                 assertEquals(Bit.ONE, a.getValue());
 195
 196                 aI.clearSignals();
 197                 enI.feedSignals(Bit.ZERO);
 198
 199                 t.executeAll();
 200
 201                 assertEquals(Bit.ZERO, a.getValue());
 202
 203         }
 204
 205         @Test
 206         void muxTest()
 207         {
 208                 CoreWire a = new CoreWire(t, 4, 3), b = new CoreWire(t, 4, 6), c = new CoreWire(t, 4, 4), select = new CoreWire(t, 2, 5), out = new CoreWire(t, 4, 1);
 209                 ReadWriteEnd selectIn = select.createReadWriteEnd();
 210
 211                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);
 212                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 213                 c.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 214
 215                 new CoreMux(t, 1, out.createReadWriteEnd(), select.createReadOnlyEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(),
 216                                 c.createReadOnlyEnd());
 217                 t.executeAll();
 218
 219                 assertBitArrayEquals(out.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 220                 selectIn.feedSignals(Bit.ZERO, Bit.ONE);
 221                 t.executeAll();
 222
 223                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 224
 225                 selectIn.feedSignals(Bit.ONE, Bit.ONE);
 226                 t.executeAll();
 227
 228                 assertBitArrayEquals(out.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 229
 230         }
 231
 232         @Test
 233         void demuxTest()
 234         {
 235                 CoreWire a = new CoreWire(t, 4, 3), b = new CoreWire(t, 4, 6), c = new CoreWire(t, 4, 4), select = new CoreWire(t, 2, 5), in = new CoreWire(t, 4, 1);
 236                 ReadWriteEnd selectIn = select.createReadWriteEnd();
 237
 238                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);
 239                 in.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 240
 241                 new CoreDemux(t, 1, in.createReadOnlyEnd(), select.createReadOnlyEnd(), a.createReadWriteEnd(), b.createReadWriteEnd(),
 242                                 c.createReadWriteEnd());
 243                 t.executeAll();
 244
 245                 assertBitArrayEquals(a.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 246                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 247                 assertBitArrayEquals(c.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 248                 selectIn.feedSignals(Bit.ZERO, 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.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 254
 255                 selectIn.feedSignals(Bit.ONE, Bit.ONE);
 256                 t.executeAll();
 257
 258                 assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 259                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 260                 assertBitArrayEquals(c.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 261
 262         }
 263
 264         @Test
 265         void andTest()
 266         {
 267                 CoreWire a = new CoreWire(t, 4, 1), b = new CoreWire(t, 4, 3), c = new CoreWire(t, 4, 1);
 268                 new CoreAndGate(t, 1, c.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());
 269                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 270                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 271
 272                 t.executeAll();
 273
 274                 assertBitArrayEquals(c.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ZERO);
 275         }
 276
 277         @Test
 278         void orTest()
 279         {
 280                 CoreWire a = new CoreWire(t, 4, 1), b = new CoreWire(t, 4, 3), c = new CoreWire(t, 4, 1);
 281                 new CoreOrGate(t, 1, c.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());
 282                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 283                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 284
 285                 t.executeAll();
 286
 287                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ONE);
 288         }
 289
 290         @Test
 291         void nandTest()
 292         {
 293                 CoreWire a = new CoreWire(t, 4, 1), b = new CoreWire(t, 4, 3), c = new CoreWire(t, 4, 1), d = new CoreWire(t, 4, 1);
 294                 new CoreNandGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
 295                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 296                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 297                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 298
 299                 t.executeAll();
 300
 301                 assertBitArrayEquals(d.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ONE);
 302         }
 303
 304         @Test
 305         void norTest()
 306         {
 307                 CoreWire a = new CoreWire(t, 4, 1), b = new CoreWire(t, 4, 3), c = new CoreWire(t, 4, 1), d = new CoreWire(t, 4, 1);
 308                 new CoreNorGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
 309                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 310                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 311                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 312
 313                 t.executeAll();
 314
 315                 assertBitArrayEquals(d.getValues(), Bit.ZERO, Bit.ZERO, Bit.ONE, Bit.ZERO);
 316         }
 317
 318         @Test
 319         void xorTest()
 320         {
 321                 CoreWire a = new CoreWire(t, 3, 1), b = new CoreWire(t, 3, 2), c = new CoreWire(t, 3, 1), d = new CoreWire(t, 3, 1);
 322                 new CoreXorGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
 323                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);
 324                 b.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
 325                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
 326
 327                 t.executeAll();
 328
 329                 assertBitArrayEquals(d.getValues(), Bit.ZERO, Bit.ONE, Bit.ONE);
 330         }
 331
 332         @Test
 333         void notTest()
 334         {
 335                 CoreWire a = new CoreWire(t, 3, 1), b = new CoreWire(t, 3, 2);
 336                 new CoreNotGate(t, 1, a.createReadOnlyEnd(), b.createReadWriteEnd());
 337                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);
 338
 339                 t.executeAll();
 340
 341                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.ZERO, Bit.ZERO);
 342         }
 343
 344         @Test
 345         void rsLatchCircuitTest()
 346         {
 347                 CoreWire r = new CoreWire(t, 1, 1), s = new CoreWire(t, 1, 1), t1 = new CoreWire(t, 1, 15), t2 = new CoreWire(t, 1, 1), q = new CoreWire(t, 1, 1),
 348                                 nq = new CoreWire(t, 1, 1);
 349
 350                 new CoreOrGate(t, 1, t2.createReadWriteEnd(), r.createReadOnlyEnd(), nq.createReadOnlyEnd());
 351                 new CoreOrGate(t, 1, t1.createReadWriteEnd(), s.createReadOnlyEnd(), q.createReadOnlyEnd());
 352                 new CoreNotGate(t, 1, t2.createReadOnlyEnd(), q.createReadWriteEnd());
 353                 new CoreNotGate(t, 1, t1.createReadOnlyEnd(), nq.createReadWriteEnd());
 354
 355                 ReadWriteEnd sIn = s.createReadWriteEnd(), rIn = r.createReadWriteEnd();
 356
 357                 sIn.feedSignals(Bit.ONE);
 358                 rIn.feedSignals(Bit.ZERO);
 359
 360                 t.executeAll();
 361
 362                 assertEquals(Bit.ONE, q.getValue());
 363                 assertEquals(Bit.ZERO, nq.getValue());
 364
 365                 sIn.feedSignals(Bit.ZERO);
 366
 367                 t.executeAll();
 368                 assertEquals(Bit.ONE, q.getValue());
 369                 assertEquals(Bit.ZERO, nq.getValue());
 370
 371                 rIn.feedSignals(Bit.ONE);
 372
 373                 t.executeAll();
 374
 375                 assertEquals(Bit.ZERO, q.getValue());
 376                 assertEquals(Bit.ONE, nq.getValue());
 377         }
 378
 379         @Test
 380         void numericValueTest()
 381         {
 382                 CoreWire a = new CoreWire(t, 4, 1);
 383                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ONE, Bit.ONE);
 384
 385                 t.executeAll();
 386
 387                 assertEquals(15, a.getUnsignedValue());
 388                 assertEquals(-1, a.getSignedValue());
 389         }
 390
 391         boolean flag = false;
 392
 393         @Test
 394         void simpleTimelineTest()
 395         {
 396                 Timeline t = new Timeline(3);
 397                 flag = false;
 398                 t.addEvent((e) ->
 399                 {
 400                         if (!flag)
 401                                 fail("Events executed out of order!");
 402                         flag = false;
 403                 }, 15);
 404                 t.addEvent((e) ->
 405                 {
 406                         if (flag)
 407                                 fail("Events executed out of order!");
 408                         flag = true;
 409                 }, 10);
 410                 t.addEvent((e) ->
 411                 {
 412                         if (flag)
 413                                 fail("Events executed out of order!");
 414                         flag = true;
 415                 }, 20);
 416                 t.addEvent((e) ->
 417                 {
 418                         fail("Only supposed to execute until timestamp 20, not 25");
 419                 }, 25);
 420
 421                 t.executeUntil(t.laterThan(20), 100);
 422
 423                 if (!flag)
 424                         fail("Not all events were executed in order!");
 425         }
 426
 427         // TODO: Adapt this test, now that update notifications are issued whenever any input to a wire changes
 428         @Disabled("Out of date")
 429         @Test
 430         void multipleInputs()
 431         {
 432                 CoreWire w = new CoreWire(t, 2, 1);
 433                 ReadWriteEnd wI1 = w.createReadWriteEnd(), wI2 = w.createReadWriteEnd();
 434                 wI1.feedSignals(Bit.ONE, Bit.Z);
 435                 wI2.feedSignals(Bit.Z, Bit.X);
 436                 t.executeAll();
 437                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.X);
 438
 439                 wI2.feedSignals(Bit.ZERO, Bit.Z);
 440                 t.executeAll();
 441                 assertBitArrayEquals(w.getValues(), Bit.X, Bit.Z);
 442
 443                 wI2.feedSignals(Bit.Z, Bit.Z);
 444                 t.executeAll();
 445                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);
 446
 447                 wI2.feedSignals(Bit.ONE, Bit.Z);
 448                 ReadEnd rE = w.createReadOnlyEnd();
 449                 rE.registerObserver((i) -> fail("WireEnd notified observer, although value did not change."));
 450                 t.executeAll();
 451                 rE.close();
 452                 wI1.feedSignals(Bit.X, Bit.X);
 453                 t.executeAll();
 454                 wI1.registerObserver((i) -> fail("WireEnd notified observer, although it was closed."));
 455                 wI1.close();
 456                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);
 457         }
 458
 459         private static void assertBitArrayEquals(BitVector actual, Bit... expected)
 460         {
 461                 assertArrayEquals(expected, actual.getBits());
 462         }
 463 }