tests/net.mograsim.logic.tests/src/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),
  44                                 e = new CoreWire(t, 1, 1), f = new CoreWire(t, 1, 1), g = new CoreWire(t, 1, 1), h = new CoreWire(t, 2, 1),
  45                                 i = new CoreWire(t, 2, 1), j = new CoreWire(t, 1, 1), 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),
 209                                 out = new CoreWire(t, 4, 1);
 210                 ReadWriteEnd selectIn = select.createReadWriteEnd();
 211
 212                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);
 213                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 214                 c.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 215
 216                 new CoreMux(t, 1, out.createReadWriteEnd(), select.createReadOnlyEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(),
 217                                 c.createReadOnlyEnd());
 218                 t.executeAll();
 219
 220                 assertBitArrayEquals(out.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 221                 selectIn.feedSignals(Bit.ONE, Bit.ZERO);
 222                 t.executeAll();
 223
 224                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 225
 226                 selectIn.feedSignals(Bit.ONE, Bit.ONE);
 227                 t.executeAll();
 228
 229                 assertBitArrayEquals(out.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 230
 231         }
 232
 233         @Test
 234         void demuxTest()
 235         {
 236                 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),
 237                                 in = new CoreWire(t, 4, 1);
 238                 ReadWriteEnd selectIn = select.createReadWriteEnd();
 239
 240                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);
 241                 in.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 242
 243                 new CoreDemux(t, 1, in.createReadOnlyEnd(), select.createReadOnlyEnd(), a.createReadWriteEnd(), b.createReadWriteEnd(),
 244                                 c.createReadWriteEnd());
 245                 t.executeAll();
 246
 247                 assertBitArrayEquals(a.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 248                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 249                 assertBitArrayEquals(c.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 250                 selectIn.feedSignals(Bit.ONE, Bit.ZERO);
 251                 t.executeAll();
 252
 253                 assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 254                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 255                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);
 256
 257                 selectIn.feedSignals(Bit.ONE, Bit.ONE);
 258                 t.executeAll();
 259
 260                 assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 261                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);
 262                 assertBitArrayEquals(c.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);
 263
 264         }
 265
 266         @Test
 267         void andTest()
 268         {
 269                 CoreWire a = new CoreWire(t, 4, 1), b = new CoreWire(t, 4, 3), c = new CoreWire(t, 4, 1);
 270                 new CoreAndGate(t, 1, c.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());
 271                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 272                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 273
 274                 t.executeAll();
 275
 276                 assertBitArrayEquals(c.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ZERO);
 277         }
 278
 279         @Test
 280         void orTest()
 281         {
 282                 CoreWire a = new CoreWire(t, 4, 1), b = new CoreWire(t, 4, 3), c = new CoreWire(t, 4, 1);
 283                 new CoreOrGate(t, 1, c.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());
 284                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 285                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 286
 287                 t.executeAll();
 288
 289                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ONE);
 290         }
 291
 292         @Test
 293         void nandTest()
 294         {
 295                 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);
 296                 new CoreNandGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
 297                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 298                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 299                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 300
 301                 t.executeAll();
 302
 303                 assertBitArrayEquals(d.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ONE);
 304         }
 305
 306         @Test
 307         void norTest()
 308         {
 309                 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);
 310                 new CoreNorGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
 311                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 312                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);
 313                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);
 314
 315                 t.executeAll();
 316
 317                 assertBitArrayEquals(d.getValues(), Bit.ZERO, Bit.ZERO, Bit.ONE, Bit.ZERO);
 318         }
 319
 320         @Test
 321         void xorTest()
 322         {
 323                 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);
 324                 new CoreXorGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());
 325                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);
 326                 b.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
 327                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);
 328
 329                 t.executeAll();
 330
 331                 assertBitArrayEquals(d.getValues(), Bit.ZERO, Bit.ONE, Bit.ONE);
 332         }
 333
 334         @Test
 335         void notTest()
 336         {
 337                 CoreWire a = new CoreWire(t, 3, 1), b = new CoreWire(t, 3, 2);
 338                 new CoreNotGate(t, 1, a.createReadOnlyEnd(), b.createReadWriteEnd());
 339                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);
 340
 341                 t.executeAll();
 342
 343                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.ZERO, Bit.ZERO);
 344         }
 345
 346         @Test
 347         void rsLatchCircuitTest()
 348         {
 349                 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),
 350                                 q = new CoreWire(t, 1, 1), nq = new CoreWire(t, 1, 1);
 351
 352                 new CoreOrGate(t, 1, t2.createReadWriteEnd(), r.createReadOnlyEnd(), nq.createReadOnlyEnd());
 353                 new CoreOrGate(t, 1, t1.createReadWriteEnd(), s.createReadOnlyEnd(), q.createReadOnlyEnd());
 354                 new CoreNotGate(t, 1, t2.createReadOnlyEnd(), q.createReadWriteEnd());
 355                 new CoreNotGate(t, 1, t1.createReadOnlyEnd(), nq.createReadWriteEnd());
 356
 357                 ReadWriteEnd sIn = s.createReadWriteEnd(), rIn = r.createReadWriteEnd();
 358
 359                 sIn.feedSignals(Bit.ONE);
 360                 rIn.feedSignals(Bit.ZERO);
 361
 362                 t.executeAll();
 363
 364                 assertEquals(Bit.ONE, q.getValue());
 365                 assertEquals(Bit.ZERO, nq.getValue());
 366
 367                 sIn.feedSignals(Bit.ZERO);
 368
 369                 t.executeAll();
 370                 assertEquals(Bit.ONE, q.getValue());
 371                 assertEquals(Bit.ZERO, nq.getValue());
 372
 373                 rIn.feedSignals(Bit.ONE);
 374
 375                 t.executeAll();
 376
 377                 assertEquals(Bit.ZERO, q.getValue());
 378                 assertEquals(Bit.ONE, nq.getValue());
 379         }
 380
 381         @Test
 382         void numericValueTest()
 383         {
 384                 CoreWire a = new CoreWire(t, 4, 1);
 385                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ONE);
 386
 387                 t.executeAll();
 388
 389                 assertEquals(11, a.getValues().getUnsignedValueLong());
 390                 assertEquals(-5, a.getValues().getSignedValueLong());
 391         }
 392
 393         boolean flag = false;
 394
 395         @Test
 396         void simpleTimelineTest()
 397         {
 398                 Timeline t = new Timeline(3);
 399                 flag = false;
 400                 t.addEvent((e) ->
 401                 {
 402                         if (!flag)
 403                                 fail("Events executed out of order!");
 404                         flag = false;
 405                 }, 15);
 406                 t.addEvent((e) ->
 407                 {
 408                         if (flag)
 409                                 fail("Events executed out of order!");
 410                         flag = true;
 411                 }, 10);
 412                 t.addEvent((e) ->
 413                 {
 414                         if (flag)
 415                                 fail("Events executed out of order!");
 416                         flag = true;
 417                 }, 20);
 418                 t.addEvent((e) ->
 419                 {
 420                         fail("Only supposed to execute until timestamp 20, not 25");
 421                 }, 25);
 422
 423                 t.executeUntil(t.laterThan(20), 100);
 424
 425                 if (!flag)
 426                         fail("Not all events were executed in order!");
 427         }
 428
 429         // TODO: Adapt this test, now that update notifications are issued whenever any input to a wire changes
 430         @Disabled("Out of date")
 431         @Test
 432         void multipleInputs()
 433         {
 434                 CoreWire w = new CoreWire(t, 2, 1);
 435                 ReadWriteEnd wI1 = w.createReadWriteEnd(), wI2 = w.createReadWriteEnd();
 436                 wI1.feedSignals(Bit.ONE, Bit.Z);
 437                 wI2.feedSignals(Bit.Z, Bit.X);
 438                 t.executeAll();
 439                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.X);
 440
 441                 wI2.feedSignals(Bit.ZERO, Bit.Z);
 442                 t.executeAll();
 443                 assertBitArrayEquals(w.getValues(), Bit.X, Bit.Z);
 444
 445                 wI2.feedSignals(Bit.Z, Bit.Z);
 446                 t.executeAll();
 447                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);
 448
 449                 wI2.feedSignals(Bit.ONE, Bit.Z);
 450                 ReadEnd rE = w.createReadOnlyEnd();
 451                 rE.registerObserver((i) -> fail("WireEnd notified observer, although value did not change."));
 452                 t.executeAll();
 453                 rE.close();
 454                 wI1.feedSignals(Bit.X, Bit.X);
 455                 t.executeAll();
 456                 wI1.registerObserver((i) -> fail("WireEnd notified observer, although it was closed."));
 457                 wI1.close();
 458                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);
 459         }
 460
 461         private static void assertBitArrayEquals(BitVector actual, Bit... expected)
 462         {
 463                 assertArrayEquals(expected, actual.getBits());
 464         }
 465 }