net.mograsim.logic.ui.am2900/test/net/mograsim/logic/ui/am2900/Am2901Test.java

   1 package net.mograsim.logic.ui.am2900;
   2
   3 import static net.mograsim.logic.ui.am2900.TestUtil.*;
   4 import static net.mograsim.logic.ui.am2900.TestableAm2901.Am2901_Dest.*;
   5 import static net.mograsim.logic.ui.am2900.TestableAm2901.Am2901_Func.*;
   6 import static net.mograsim.logic.ui.am2900.TestableAm2901.Am2901_Src.*;
   7 import static net.mograsim.logic.ui.am2900.TestableAm2901.Register.*;
   8 import static org.junit.jupiter.api.Assertions.*;
   9
  10 import java.awt.Point;
  11 import java.util.stream.IntStream;
  12 import java.util.stream.Stream;
  13
  14 import org.junit.jupiter.api.BeforeEach;
  15 import org.junit.jupiter.api.Order;
  16 import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
  17 import org.junit.jupiter.api.Test;
  18 import org.junit.jupiter.api.TestMethodOrder;
  19 import org.junit.jupiter.params.ParameterizedTest;
  20 import org.junit.jupiter.params.provider.ArgumentsSource;
  21 import net.mograsim.logic.ui.am2900.TestableAm2901.Register;
  22
  23 @TestMethodOrder(OrderAnnotation.class)
  24 public class Am2901Test
  25 {
  26         private TestableAm2901 am2901;
  27
  28         @BeforeEach
  29         void initialize()
  30         {
  31                 createAndSetup();
  32                 setInputsToZero();
  33         }
  34
  35         void createAndSetup()
  36         {
  37                 am2901 = new TestableAm2901Impl();
  38                 am2901.setup();
  39         }
  40
  41         void setRegistersToZero()
  42         {
  43                 setInputsToZero();
  44                 for (Register r : Register.values())
  45                 {
  46                         setRegisterToZero(r);
  47                 }
  48         }
  49
  50         void setRegisterToZero(Register r)
  51         {
  52                 System.out.println("Setting reg " + r + " to zero");
  53
  54                 am2901.setD("0000");
  55                 am2901.setSrc(DZ);
  56                 am2901.setFunc(AND);
  57                 setRegOutput(r);
  58
  59                 am2901.assertFullCycleSuccess();
  60         }
  61
  62         void setRegOutput(Register r)
  63         {
  64                 if (r == Q)
  65                 {
  66                         am2901.setDest(QREG);
  67                 } else
  68                 {
  69                         am2901.setReg_B(r.toBitString());
  70                         am2901.setDest(RAMF);
  71                 }
  72         }
  73
  74         void setInputsToZero()
  75         {
  76                 am2901.setCarryIn("0");
  77                 am2901.setQ_0("0");
  78                 am2901.setQ_3("0");
  79                 am2901.setRAM_0("0");
  80                 am2901.setRAM_3("0");
  81                 am2901.setReg_A("0000");
  82                 am2901.setReg_B("0000");
  83                 am2901.setD("0000");
  84                 am2901.setSrc(AB);
  85                 am2901.setFunc(ADD);
  86                 am2901.setDest(QREG);
  87 //              am2901.setNotOutEnable("0"); TODO
  88                 am2901.clockOn(true);
  89                 am2901.assertRunSuccess();
  90         }
  91
  92         @Order(1)
  93         @ParameterizedTest
  94         @ArgumentsSource(TestableAm2901.RegisterProvider.class)
  95         void testDirectAccess(Register r)
  96         {
  97                 assertEquals("UUUU", am2901.getDirectly(r));
  98
  99                 am2901.setDirectly(r, "1011");
 100
 101                 assertEquals("1011", am2901.getDirectly(r));
 102         }
 103
 104         @Order(2)
 105         @ParameterizedTest
 106         @ArgumentsSource(TestableAm2901.RegisterProvider.class)
 107         void testSetToZero(Register r)
 108         {
 109                 assertEquals("UUUU", am2901.getDirectly(r));
 110
 111                 setRegisterToZero(r);
 112
 113                 assertEquals("0000", am2901.getDirectly(r));
 114                 assertEquals("0000", am2901.getY());
 115                 assertEquals("0", am2901.getCarryOut());
 116                 assertEquals("0", am2901.getOverflow());
 117                 assertEquals("0", am2901.getSign());
 118                 assertEquals("1", am2901.getZero());
 119         }
 120
 121         @Order(3)
 122         @Test
 123         void testSetAllToZero()
 124         {
 125                 setRegistersToZero();
 126
 127                 assertEquals("0000", am2901.getY());
 128                 assertEquals("0", am2901.getCarryOut());
 129                 assertEquals("0", am2901.getOverflow());
 130                 assertEquals("0", am2901.getSign());
 131                 assertEquals("1", am2901.getZero());
 132                 assertEquals("0", am2901.getQ_0());
 133                 assertEquals("0", am2901.getQ_3());
 134                 assertEquals("0", am2901.getRAM_0());
 135                 assertEquals("0", am2901.getRAM_3());
 136
 137                 assertAll("register values", Register.stream().map(r -> () ->
 138                 {
 139                         assertEquals("0000", am2901.getDirectly(r), r.name());
 140                 }));
 141         }
 142
 143         @Order(4)
 144         @Test
 145         void testADD()
 146         {
 147                 am2901.setSrc(DA);
 148                 am2901.setFunc(ADD);
 149                 am2901.setDest(NOP);
 150                 am2901.setReg_A(r0.toBitString());
 151
 152                 assertAll(getAll4BitPairs().map(xy -> () ->
 153                 {
 154                         am2901.setDirectly(r0, to4bitBin(xy.x));
 155                         am2901.setD(to4bitBin(xy.y));
 156
 157                         am2901.assertFullCycleSuccess();
 158
 159                         int res32Bit = xy.x + xy.y;
 160                         int res4Bit = res32Bit & 0b1111;
 161                         int res32Bit_sgn = signed4ToSigned32(xy.x) + signed4ToSigned32(xy.y);
 162                         int res4Bit_sgn = signed4ToSigned32(res32Bit_sgn);
 163
 164                         String desc = xy.x + " + " + xy.y + " = " + res4Bit + ": ";
 165
 166                         assertEquals(to4bitBin(res4Bit & 0b1111), am2901.getY(), desc + "Y");
 167                         assertEquals(to1bitBin(res4Bit == 0), am2901.getZero(), desc + "F=0");
 168                         assertEquals(to1bitBin(res4Bit & 0b1000), am2901.getSign(), desc + "F3");
 169                         assertEquals(to1bitBin(res32Bit & 0b1_0000), am2901.getCarryOut(), desc + "Cn+4");
 170                         assertEquals(to1bitBin(res4Bit_sgn != res32Bit_sgn), am2901.getOverflow(), desc + "OVR");
 171                 }));
 172         }
 173
 174         @Order(4)
 175         @Test
 176         void testAND()
 177         {
 178                 am2901.setSrc(DA);
 179                 am2901.setFunc(AND);
 180                 am2901.setDest(NOP);
 181                 am2901.setReg_A(r0.toBitString());
 182
 183                 assertAll(getAll4BitPairs().map(xy -> () ->
 184                 {
 185                         am2901.setDirectly(r0, to4bitBin(xy.x));
 186                         am2901.setD(to4bitBin(xy.y));
 187
 188                         am2901.assertFullCycleSuccess();
 189
 190                         int res32Bit = xy.x & xy.y;
 191
 192                         String desc = xy.x + " & " + xy.y + " = " + res32Bit + ": ";
 193
 194                         assertEquals(to4bitBin(res32Bit), am2901.getY(), desc + "Y");
 195                         assertEquals(to1bitBin(res32Bit == 0), am2901.getZero(), desc + "F=0");
 196                         assertEquals(to1bitBin(res32Bit & 0b1000), am2901.getSign(), desc + "F3");
 197 //                      assertEquals(to1bitBin(res32Bit), am2901.getCarryOut(), desc + "Cn+4"); // TODO
 198 //                      assertEquals(to1bitBin(res32Bit), am2901.getOverflow(), desc + "OVR"); // TODO
 199                 }));
 200         }
 201
 202         @Order(4)
 203         @Test
 204         void testOR()
 205         {
 206                 am2901.setSrc(DA);
 207                 am2901.setFunc(OR);
 208                 am2901.setDest(NOP);
 209                 am2901.setReg_A(r0.toBitString());
 210
 211                 assertAll(getAll4BitPairs().map(xy -> () ->
 212                 {
 213                         am2901.setDirectly(r0, to4bitBin(xy.x));
 214                         am2901.setD(to4bitBin(xy.y));
 215
 216                         am2901.assertFullCycleSuccess();
 217
 218                         int res32Bit = xy.x | xy.y;
 219
 220                         String desc = xy.x + " | " + xy.y + " = " + res32Bit + ": ";
 221
 222                         assertEquals(to4bitBin(res32Bit), am2901.getY(), desc + "Y");
 223                         assertEquals(to1bitBin(res32Bit == 0), am2901.getZero(), desc + "F=0");
 224                         assertEquals(to1bitBin(res32Bit & 0b1000), am2901.getSign(), desc + "F3");
 225 //                      assertEquals(to1bitBin(res32Bit != 0b1111), am2901.getCarryOut(), desc + "Cn+4"); // TODO
 226 //                      assertEquals(to1bitBin(res32Bit != 0b1111), am2901.getOverflow(), desc + "OVR"); // TODO
 227                 }));
 228         }
 229
 230         @Order(4)
 231         @Test
 232         void testXOR()
 233         {
 234                 am2901.setSrc(DA);
 235                 am2901.setFunc(EXOR);
 236                 am2901.setDest(NOP);
 237                 am2901.setReg_A(r0.toBitString());
 238
 239                 assertAll(getAll4BitPairs().map(xy -> () ->
 240                 {
 241                         am2901.setDirectly(r0, to4bitBin(xy.x));
 242                         am2901.setD(to4bitBin(xy.y));
 243
 244                         am2901.assertFullCycleSuccess();
 245
 246                         int res32Bit = xy.x ^ xy.y;
 247
 248                         String desc = xy.x + " ^ " + xy.y + " = " + res32Bit + ": ";
 249
 250                         assertEquals(to4bitBin(res32Bit), am2901.getY(), desc + "Y");
 251                         assertEquals(to1bitBin(res32Bit == 0), am2901.getZero(), desc + "F=0");
 252                         assertEquals(to1bitBin(res32Bit & 0b1000), am2901.getSign(), desc + "F3");
 253 //                      assertEquals(to1bitBin(res32Bit != 0b1111), am2901.getCarryOut(), desc + "Cn+4"); // TODO
 254 //                      assertEquals(to1bitBin(res32Bit != 0b1111), am2901.getOverflow(), desc + "OVR"); // TODO
 255                 }));
 256         }
 257
 258         @Order(4)
 259         @Test
 260         void testSUB()
 261         {
 262                 am2901.setSrc(DA);
 263                 am2901.setCarryIn("1");
 264                 am2901.setFunc(SUBR);
 265                 am2901.setDest(NOP);
 266                 am2901.setReg_A(r0.toBitString());
 267
 268                 assertAll(getAll4BitPairs().map(xy -> () ->
 269                 {
 270                         am2901.setDirectly(r0, to4bitBin(xy.x));
 271                         am2901.setD(to4bitBin(xy.y));
 272
 273                         am2901.assertFullCycleSuccess();
 274
 275                         int res32Bit = xy.x - xy.y;
 276                         int res4Bit = res32Bit & 0b1111;
 277                         int res32Bit_sgn = signed4ToSigned32(xy.x) - signed4ToSigned32(xy.y);
 278                         int res4Bit_sgn = signed4ToSigned32(res32Bit_sgn);
 279
 280                         String desc = xy.x + " - " + xy.y + " = " + res4Bit + ": ";
 281
 282                         assertEquals(to4bitBin(res4Bit & 0b1111), am2901.getY(), desc + "Y");
 283                         assertEquals(to1bitBin(res4Bit == 0), am2901.getZero(), desc + "F=0");
 284                         assertEquals(to1bitBin(res4Bit & 0b1000), am2901.getSign(), desc + "F3");
 285                         assertEquals(to1bitBin(xy.x >= xy.y), am2901.getCarryOut(), desc + "Cn+4");
 286                         assertEquals(to1bitBin(res4Bit_sgn != res32Bit_sgn), am2901.getOverflow(), desc + "OVR");
 287                 }));
 288         }
 289
 290         static Stream<Point> getAll4BitPairs()
 291         {
 292                 return IntStream.range(0, 16).boxed().flatMap(x -> IntStream.range(0, 16).mapToObj(y -> new Point(x, y)));
 293         }
 294 }