era.mi/src/era/mi/logic/tests/ComponentTest.java

   1 package era.mi.logic.tests;\r
   2 \r
   3 import static org.junit.jupiter.api.Assertions.*;\r
   4 \r
   5 import java.util.Arrays;\r
   6 import java.util.function.LongConsumer;\r
   7 \r
   8 import org.junit.jupiter.api.Test;\r
   9 \r
  10 import era.mi.logic.Bit;\r
  11 import era.mi.logic.Simulation;\r
  12 import era.mi.logic.components.Demux;\r
  13 import era.mi.logic.components.Merger;\r
  14 import era.mi.logic.components.Mux;\r
  15 import era.mi.logic.components.Splitter;\r
  16 import era.mi.logic.components.TriStateBuffer;\r
  17 import era.mi.logic.components.gates.AndGate;\r
  18 import era.mi.logic.components.gates.NotGate;\r
  19 import era.mi.logic.components.gates.OrGate;\r
  20 import era.mi.logic.components.gates.XorGate;\r
  21 import era.mi.logic.wires.Wire;\r
  22 import era.mi.logic.wires.Wire.WireEnd;\r
  23 \r
  24 class ComponentTest\r
  25 {\r
  26 \r
  27         @Test\r
  28         void circuitExampleTest()\r
  29         {\r
  30                 Simulation.TIMELINE.reset();\r
  31                 Wire a = new Wire(1, 1), b = new Wire(1, 1), c = new Wire(1, 10), d = new Wire(2, 1),\r
  32                                 e = new Wire(1, 1), f = new Wire(1, 1), g = new Wire(1, 1), h = new Wire(2, 1), i = new Wire(2, 1),\r
  33                                 j = new Wire(1, 1), k = new Wire(1, 1);\r
  34                 new AndGate(1, f.createEnd(), a.createEnd(), b.createEnd());\r
  35                 new NotGate(1, f.createEnd(), g.createEnd());\r
  36                 new Merger(h.createEnd(), c.createEnd(), g.createEnd());\r
  37                 new Mux(1, i.createEnd(), e.createEnd(), h.createEnd(), d.createEnd());\r
  38                 new Splitter(i.createEnd(), k.createEnd(), j.createEnd());\r
  39 \r
  40                 a.createEnd().feedSignals(Bit.ZERO);\r
  41                 b.createEnd().feedSignals(Bit.ONE);\r
  42                 c.createEnd().feedSignals(Bit.ZERO);\r
  43                 d.createEnd().feedSignals(Bit.ONE, Bit.ONE);\r
  44                 e.createEnd().feedSignals(Bit.ZERO);\r
  45 \r
  46                 Simulation.TIMELINE.executeAll();\r
  47 \r
  48                 assertEquals(Bit.ONE, j.getValue());\r
  49                 assertEquals(Bit.ZERO, k.getValue());\r
  50         }\r
  51 \r
  52         @Test\r
  53         void splitterTest()\r
  54         {\r
  55                 Simulation.TIMELINE.reset();\r
  56                 Wire a = new Wire(3, 1), b = new Wire(2, 1), c = new Wire(3, 1), in = new Wire(8, 1);\r
  57                 in.createEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
  58                 new Splitter(in.createEnd(), a.createEnd(), b.createEnd(), c.createEnd());\r
  59 \r
  60                 Simulation.TIMELINE.executeAll();\r
  61 \r
  62                 assertBitArrayEquals(a.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO);\r
  63                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.ZERO);\r
  64                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE);\r
  65         }\r
  66 \r
  67         @Test\r
  68         void mergerTest()\r
  69         {\r
  70                 Simulation.TIMELINE.reset();\r
  71                 Wire a = new Wire(3, 1), b = new Wire(2, 1), c = new Wire(3, 1), out = new Wire(8, 1);\r
  72                 a.createEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO);\r
  73                 b.createEnd().feedSignals(Bit.ONE, Bit.ZERO);\r
  74                 c.createEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);\r
  75 \r
  76                 new Merger(out.createEnd(), a.createEnd(), b.createEnd(), c.createEnd());\r
  77 \r
  78                 Simulation.TIMELINE.executeAll();\r
  79 \r
  80                 assertTrue(\r
  81                                 Arrays.equals(out.getValues(), new Bit[] { Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE }));\r
  82         }\r
  83 \r
  84         @Test\r
  85         void triStateBufferTest()\r
  86         {\r
  87                 Wire a = new Wire(1, 1), b = new Wire(1, 1), en = new Wire(1, 1), notEn = new Wire(1, 1);\r
  88                 new NotGate(1, en.createEnd(), notEn.createEnd());\r
  89                 new TriStateBuffer(1, a.createEnd(), b.createEnd(), en.createEnd());\r
  90                 new TriStateBuffer(1, b.createEnd(), a.createEnd(), notEn.createEnd());\r
  91 \r
  92                 WireEnd enI = en.createEnd(), aI = a.createEnd(), bI = b.createEnd();\r
  93                 enI.feedSignals(Bit.ONE);\r
  94                 aI.feedSignals(Bit.ONE);\r
  95 \r
  96                 Simulation.TIMELINE.executeAll();\r
  97 \r
  98                 assertEquals(Bit.ONE, b.getValue());\r
  99 \r
 100                 bI.feedSignals(Bit.ZERO);\r
 101 \r
 102                 Simulation.TIMELINE.executeAll();\r
 103 \r
 104                 assertEquals(Bit.X, b.getValue());\r
 105                 assertEquals(Bit.ONE, a.getValue());\r
 106 \r
 107                 aI.clearSignals();\r
 108                 enI.feedSignals(Bit.ZERO);\r
 109 \r
 110                 Simulation.TIMELINE.executeAll();\r
 111 \r
 112                 assertEquals(Bit.ZERO, a.getValue());\r
 113 \r
 114         }\r
 115 \r
 116         @Test\r
 117         void muxTest()\r
 118         {\r
 119                 Simulation.TIMELINE.reset();\r
 120                 Wire a = new Wire(4, 3), b = new Wire(4, 6), c = new Wire(4, 4), select = new Wire(2, 5),\r
 121                                 out = new Wire(4, 1);\r
 122                 WireEnd selectIn = select.createEnd();\r
 123 \r
 124                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);\r
 125                 a.createEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 126                 c.createEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 127 \r
 128                 new Mux(1, out.createEnd(), select.createEnd(), a.createEnd(), b.createEnd(), c.createEnd());\r
 129                 Simulation.TIMELINE.executeAll();\r
 130 \r
 131                 assertBitArrayEquals(out.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 132                 selectIn.feedSignals(Bit.ZERO, Bit.ONE);\r
 133                 Simulation.TIMELINE.executeAll();\r
 134 \r
 135                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 136 \r
 137                 selectIn.feedSignals(Bit.ONE, Bit.ONE);\r
 138                 Simulation.TIMELINE.executeAll();\r
 139 \r
 140                 assertBitArrayEquals(out.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
 141 \r
 142         }\r
 143 \r
 144         @Test\r
 145         void demuxTest()\r
 146         {\r
 147                 Simulation.TIMELINE.reset();\r
 148                 Wire a = new Wire(4, 3), b = new Wire(4, 6), c = new Wire(4, 4), select = new Wire(2, 5),\r
 149                                 in = new Wire(4, 1);\r
 150                 WireEnd selectIn = select.createEnd();\r
 151 \r
 152                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);\r
 153                 in.createEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 154 \r
 155                 new Demux(1, in.createEnd(), select.createEnd(), a.createEnd(), b.createEnd(), c.createEnd());\r
 156                 Simulation.TIMELINE.executeAll();\r
 157 \r
 158                 assertBitArrayEquals(a.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 159                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
 160                 assertBitArrayEquals(c.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
 161                 selectIn.feedSignals(Bit.ZERO, Bit.ONE);\r
 162                 Simulation.TIMELINE.executeAll();\r
 163 \r
 164                 assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
 165                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
 166                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 167 \r
 168                 selectIn.feedSignals(Bit.ONE, Bit.ONE);\r
 169                 Simulation.TIMELINE.executeAll();\r
 170 \r
 171                 assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
 172                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
 173                 assertBitArrayEquals(c.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
 174 \r
 175         }\r
 176 \r
 177         @Test\r
 178         void andTest()\r
 179         {\r
 180                 Simulation.TIMELINE.reset();\r
 181                 Wire a = new Wire(4, 1), b = new Wire(4, 3), c = new Wire(4, 1);\r
 182                 new AndGate(1, c.createEnd(), a.createEnd(), b.createEnd());\r
 183                 a.createEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);\r
 184                 b.createEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 185 \r
 186                 Simulation.TIMELINE.executeAll();\r
 187 \r
 188                 assertBitArrayEquals(c.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ZERO);\r
 189         }\r
 190 \r
 191         @Test\r
 192         void orTest()\r
 193         {\r
 194                 Simulation.TIMELINE.reset();\r
 195                 Wire a = new Wire(4, 1), b = new Wire(4, 3), c = new Wire(4, 1);\r
 196                 new OrGate(1, c.createEnd(), a.createEnd(), b.createEnd());\r
 197                 a.createEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);\r
 198                 b.createEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 199 \r
 200                 Simulation.TIMELINE.executeAll();\r
 201 \r
 202                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 203         }\r
 204 \r
 205         @Test\r
 206         void xorTest()\r
 207         {\r
 208                 Simulation.TIMELINE.reset();\r
 209                 Wire a = new Wire(3, 1), b = new Wire(3, 2), c = new Wire(3, 1), d = new Wire(3, 1);\r
 210                 new XorGate(1, d.createEnd(), a.createEnd(), b.createEnd(), c.createEnd());\r
 211                 a.createEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);\r
 212                 b.createEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);\r
 213                 c.createEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);\r
 214 \r
 215                 Simulation.TIMELINE.executeAll();\r
 216 \r
 217                 assertBitArrayEquals(d.getValues(), Bit.ZERO, Bit.ONE, Bit.ONE);\r
 218         }\r
 219         \r
 220         @Test\r
 221         void notTest()\r
 222         {\r
 223                 Simulation.TIMELINE.reset();\r
 224                 Wire a = new Wire(3, 1), b = new Wire(3, 2);\r
 225                 new NotGate(1, a.createEnd(), b.createEnd());\r
 226                 a.createEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);\r
 227 \r
 228                 Simulation.TIMELINE.executeAll();\r
 229 \r
 230                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.ZERO, Bit.ZERO);\r
 231         }\r
 232 \r
 233         @Test\r
 234         void rsLatchCircuitTest()\r
 235         {\r
 236                 Simulation.TIMELINE.reset();\r
 237                 Wire r = new Wire(1, 1), s = new Wire(1, 1), t1 = new Wire(1, 15), t2 = new Wire(1, 1),\r
 238                                 q = new Wire(1, 1), nq = new Wire(1, 1);\r
 239 \r
 240                 new OrGate(1, t2.createEnd(), r.createEnd(), nq.createEnd());\r
 241                 new OrGate(1, t1.createEnd(), s.createEnd(), q.createEnd());\r
 242                 new NotGate(1, t2.createEnd(), q.createEnd());\r
 243                 new NotGate(1, t1.createEnd(), nq.createEnd());\r
 244 \r
 245                 WireEnd sIn = s.createEnd(), rIn = r.createEnd();\r
 246 \r
 247                 sIn.feedSignals(Bit.ONE);\r
 248                 rIn.feedSignals(Bit.ZERO);\r
 249 \r
 250                 Simulation.TIMELINE.executeAll();\r
 251 \r
 252                 assertEquals(Bit.ONE, q.getValue());\r
 253                 assertEquals(Bit.ZERO, nq.getValue());\r
 254 \r
 255                 sIn.feedSignals(Bit.ZERO);\r
 256 \r
 257                 Simulation.TIMELINE.executeAll();\r
 258                 assertEquals(Bit.ONE, q.getValue());\r
 259                 assertEquals(Bit.ZERO, nq.getValue());\r
 260 \r
 261                 rIn.feedSignals(Bit.ONE);\r
 262 \r
 263                 Simulation.TIMELINE.executeAll();\r
 264 \r
 265                 assertEquals(Bit.ZERO, q.getValue());\r
 266                 assertEquals(Bit.ONE, nq.getValue());\r
 267         }\r
 268 \r
 269         @Test\r
 270         void numericValueTest()\r
 271         {\r
 272                 Simulation.TIMELINE.reset();\r
 273 \r
 274                 Wire a = new Wire(4, 1);\r
 275                 a.createEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ONE, Bit.ONE);\r
 276 \r
 277                 Simulation.TIMELINE.executeAll();\r
 278 \r
 279                 assertEquals(15, a.getUnsignedValue());\r
 280                 assertEquals(-1, a.getSignedValue());\r
 281         }\r
 282 \r
 283         @Test\r
 284         void multipleInputs()\r
 285         {\r
 286                 Simulation.TIMELINE.reset();\r
 287                 Wire w = new Wire(2, 1);\r
 288                 WireEnd wI1 = w.createEnd(), wI2 = w.createEnd();\r
 289                 wI1.feedSignals(Bit.ONE, Bit.Z);\r
 290                 wI2.feedSignals(Bit.Z, Bit.X);\r
 291                 Simulation.TIMELINE.executeAll();\r
 292                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.X);\r
 293 \r
 294                 wI2.feedSignals(Bit.ZERO, Bit.Z);\r
 295                 Simulation.TIMELINE.executeAll();\r
 296                 assertBitArrayEquals(w.getValues(), Bit.X, Bit.Z);\r
 297 \r
 298                 wI2.feedSignals(Bit.Z, Bit.Z);\r
 299                 Simulation.TIMELINE.executeAll();\r
 300                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);\r
 301 \r
 302                 wI2.feedSignals(Bit.ONE, Bit.Z);\r
 303                 w.addObserver((i, oldValues) -> fail("WireArray notified observer, although value did not change."));\r
 304                 Simulation.TIMELINE.executeAll();\r
 305                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);\r
 306         }\r
 307 \r
 308 //      @Test\r
 309         void wireConnections()\r
 310         {\r
 311                 // Nur ein Experiment, was über mehrere 'passive' Bausteine hinweg passieren würde\r
 312 \r
 313                 Simulation.TIMELINE.reset();\r
 314 \r
 315                 Wire a = new Wire(1, 2);\r
 316                 Wire b = new Wire(1, 2);\r
 317                 Wire c = new Wire(1, 2);\r
 318                 WireEnd aI = a.createEnd();\r
 319                 WireEnd bI = b.createEnd();\r
 320                 WireEnd cI = c.createEnd();\r
 321 \r
 322                 TestBitDisplay test = new TestBitDisplay(c.createEnd());\r
 323                 TestBitDisplay test2 = new TestBitDisplay(a.createEnd());\r
 324                 LongConsumer print = time -> System.out.format("Time %2d\n   a: %s\n   b: %s\n   c: %s\n", time, a, b, c);\r
 325 \r
 326                 cI.feedSignals(Bit.ONE);\r
 327                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 328 \r
 329                 cI.feedSignals(Bit.X);\r
 330                 test.assertAfterSimulationIs(print, Bit.X);\r
 331 \r
 332                 cI.feedSignals(Bit.X);\r
 333                 cI.feedSignals(Bit.Z);\r
 334                 test.assertAfterSimulationIs(print, Bit.Z);\r
 335 \r
 336                 new Connector(b, c);\r
 337                 test.assertAfterSimulationIs(print, Bit.Z);\r
 338                 System.err.println("ONE");\r
 339                 bI.feedSignals(Bit.ONE);\r
 340                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 341                 System.err.println("ZERO");\r
 342                 bI.feedSignals(Bit.ZERO);\r
 343                 test.assertAfterSimulationIs(print, Bit.ZERO);\r
 344                 System.err.println("Z");\r
 345                 bI.feedSignals(Bit.Z);\r
 346                 test.assertAfterSimulationIs(print, Bit.Z);\r
 347 \r
 348                 new Connector(a, b);\r
 349                 System.err.println("Z 2");\r
 350                 aI.feedSignals(Bit.Z);\r
 351                 test.assertAfterSimulationIs(print, Bit.Z);\r
 352                 test2.assertAfterSimulationIs(Bit.Z);\r
 353                 System.err.println("ONE 2");\r
 354                 aI.feedSignals(Bit.ONE);\r
 355                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 356                 test2.assertAfterSimulationIs(Bit.ONE);\r
 357                 System.err.println("ZERO 2");\r
 358                 aI.feedSignals(Bit.ZERO);\r
 359                 test.assertAfterSimulationIs(print, Bit.ZERO);\r
 360                 test2.assertAfterSimulationIs(Bit.ZERO);\r
 361                 System.err.println("Z 2 II");\r
 362                 aI.feedSignals(Bit.Z);\r
 363                 test.assertAfterSimulationIs(print, Bit.Z);\r
 364                 test2.assertAfterSimulationIs(Bit.Z);\r
 365 \r
 366                 System.err.println("No Conflict yet");\r
 367                 bI.feedSignals(Bit.ONE);\r
 368                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 369                 test2.assertAfterSimulationIs(Bit.ONE);\r
 370                 aI.feedSignals(Bit.ONE);\r
 371                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 372                 test2.assertAfterSimulationIs(Bit.ONE);\r
 373                 System.err.println("Conflict");\r
 374                 aI.feedSignals(Bit.ZERO);\r
 375                 test.assertAfterSimulationIs(print, Bit.X);\r
 376                 test2.assertAfterSimulationIs(Bit.X);\r
 377                 aI.feedSignals(Bit.ONE);\r
 378                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 379                 test2.assertAfterSimulationIs(Bit.ONE);\r
 380         }\r
 381 \r
 382         private static void assertBitArrayEquals(Bit[] actual, Bit... expected)\r
 383         {\r
 384                 assertArrayEquals(expected, actual);\r
 385         }\r
 386 }\r