;INITIALIZE UUO HANDLER START: PGMINT ;INITIALIZE SUBROUTINES MOVE 0,RANDBS ;EXEC, SETUP RANDOM BASE SKIPE USER ;USER, USE TIME OF DAY IN JIFFIES CALL 0,[SIXBIT/TIMER/] MOVEM 0,RAN ;SETUP RANDOM BASE ;INITIALIZE COMPLEXITY TABLE A=0 STARTA: SETZM CMPLXT ;STORE A TABLE OF POWERS OF 2 MOVEI 1,1 ;OR 0. SWITCH TLNN RELIAB ;FAST CYCLE SWITCH SET ? SETZM 1 ;YES, STORE ZERO'S REPEAT 7, < MOVEM 1,CMPLXT+1+A LSH 1,1 A=A+1> ;INITIALIZE RUN TIME MOVEI 1,1 TLNE RELIAB ;FAST CYCLE SWITCH SET ? MOVEI 1,7 ;NO, MULTIPLY RUNNING TIME MOVEM 1,RTIME ;STORE IN RTIME JRST CAM1 ;GO PERFORM DIAGNOSTIC RENTR1: DROPDV ;CLOSE LOGICAL OUTPUT FILE CALL [SIXBIT .EXIT.] PGMNAM: ASCIZ/ PDP-10 KA10 BASIC INSTRUCTION RELIABILITY TEST 1 (DAKBA) (COMPARES, SKIPS, EXCHANGES, BOOLE, ROTATES, TESTS, ETC.) / ;CONSTANTS RTIME: 0 CMPLXT: BLOCK 20 SUBTTL DIAGNOSTIC SECTION LALL ;TEST CAMN,CAME (SIMPLE) ;THE CONTENTS OF THE AC IS COMPARED WITH ITSELF ;AN ERROR WILL OCCUR IF CAMN SKIPS OR CAME FAILS TO SKIP ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) ;15 ACS ARE USED IN THE TEST AC=2 CAM1: SETUP 20,0 RANDOM CAMNE1: REPEAT ^D10, < MOVE AC,RAN CAMN AC,AC ;C(AC) = C(AC) CAME AC,AC ERROR AC,AC ;CHECK CAME,CAMN AC=&17 > AC=2 LOOP CAMNE1-3,CAMNE1 ;TEST MOVE TO AC,FURTHER TEST OF CAME ;THE C(AC) IS COMPARED WITH THE CONTENTS OF THE RANDOM ;NUMBER GENERATOR. 15 ACS ARE USED IN THE TEST ;ERRORS ARE PRINTED IN THE FORM (PC,AC,C(AC),CORRECT) AC=2 MOVAC: SETUP 20,0 RANDOM MOVAC1: REPEAT ^D10, < MOVE AC,RAN ;MOVE RAN INTO AC. CAME AC,RAN ;RANDOM SHOULD EQUAL AC ERROR AC,RAN ;IF NOT MOVE FAILED CAME AC,RAN# ;IF AC=RAN CAME FAILED ERROR AC,RAN# ;IF PREVIOUS WORKED,INHIBIT STORE AC=&17 ;AC ON CAME FAILED > AC=2 LOOP MOVAC1-3,MOVAC1 ;TEST THE SKIP INST FOR NO SKIP,ABILITY TO LOAD ;AN AC,AC SELECTION,AND AC0 LOGIC(NOT LOADING 0) ;ERRORS ARE PRESENTED IN THE FORM(PC,AC,C(AC),CORRECT) AC=5 SKP: SETUP 30,0 RANDOM SKP1: MOVE [0] ;DO NOT USE AC0 FOR SKIP REPEAT ^D8, < SKIP AC1,RAN# ;STORE IN AC,DO NOT SKIP,CHECK CAME AC1,AC ;NEW AC AGAINST PREVIOUSLY ERROR AC1,AC ;STORED AC. IF AC=AC+1(SKIP LOGIC) CAME [0] ;IF NOT= STORE CYCLE ERROR [0] ;IF 0 NONE ZERO ADDR/STORE AC=&17 AC1=&17 > AC=5 LOOP SKP1-4,SKP1 ;TEST SKIPA INST FOR PC INCREMENT,ABILITY TO LOAD AN AC, ;AC SELECTION AND AC0 LOGIC(NOT LOADING 0).ERRORS ARE ;PRESENTED IN THE FORM (PC,AC,C(AC),CORRECT) AC=5 SKPA: SETUP 30,0 RANDOM SKPA1: MOVE [0] ;DO NOT USE AC0 FOR SKIPA REPEAT ^D8, < SKIPA AC1,AC ;LOAD AC1 AND SKIP ER AC,[ASCII /SKP/] ;FAILED TO SKIP. CAME AC,RAN ;C(E) GET CHANGED? ERROR AC,RAN ;YES. CAME AC1,RAN ;AC GET LOADED WITH RAN? ERROR AC1,RAN ;NO. CAME 0,[0] ;C(AC0) STILL = 0? ERROR [0] ;CHECK STORE CYCLE,AC ADDRESS AC=&17 AC1=&17 > AC=5 LOOP SKPA1-4,SKPA1 ;TEST EXCH. BOTH AC AND E ARE AC'S. CHECK FOR ;CORRECT DATA IN AC AND C(E). ;C(E) = -1, C(AC) = RAN NUM. AC=5 EXCH1: SETUP 200,0 EXCH2: RANDOM EXCH3: SETOB AC1,RAN1 ;MAKE C(E) = -1. EXCH AC,AC1 ;DO THE EXCH. CAME AC,RAN1 ;THE C(AC) SHOULD = ORIG C(E). ERR RAN1,RAN CAME AC1,RAN ;THE C(E) SHOULD = ORIG C(AC). ERR RAN1,RAN LOOP EXCH2,EXCH3 ;TEST SETCA FOR COMPLEMENT AC AND NOT STORING IN C(E) ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) ;SETCA DOES NOT NORMALLY CHANGE THE CONTENTS OF "E" AC=10 BOLCA: REPEAT 2, < SETUP 100,2 RANDOM MOVE AC2,[0] ;CLEAR AC2, USED TO INSURE SETCA AC,AC2 ;SETCA DOES NOT STORE IN C(E) CAMN AC,RAN# ;IF AC UNCHANGED CNTL PULSES ERROR AC,RAN ;FOR INST SETCA FAILED REPEAT 3, < SETCA AC,AC2> CAME AC,RAN# ;A TOTAL OF 4 COMPLEMENTS ERROR AC,RAN ;SHOULD PRODUCE ORIGINAL NUM CAME AC2,[0] ;IF SETCA STORED C(E) ERROR AC2,[0] ;C(AC2) WILL NO LONGER BE 0. LOOP .-16,.-15 AC=AC+17 > ;TEST SETCAI ABILITY TO COMPLEMENT AC AND FAILURE TO FETCH C(E) ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT ;SETCA IS INDEXED FOR NOISE PURPOSES AC=5 BOLCAI: SETUP 40,0 BOLCA1: RANDOM BOLCA2: REPEAT 4, < MOVE AC1,AC ;MOVE RANDOM TO AN AC SETCAI AC1,-1(AC) ;TWO COMP SHOULD PRODUCE SETCAI AC1,777000(AC) ;ORIGINAL NUMBER CAME AC1,AC ;SETCAI FAILED ERROR AC1,AC AC=&17 AC1=&17 > AC=5 LOOP BOLCA1,BOLCA2 ;TEST XOR TO ZERO,XOR 0 TO N,N TO N,-1 TO N ;THREE ACS ARE USED IN THE TEST ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT AC=1 BOLX: REPEAT 3, < SETUP 200,0 RANDOM MOVE AC,[0] ;CLEAR THE AC XOR AC,RAN ;0 EXCLUSIVE ORED WITH CAME AC,RAN ;RANDOM SHOULD = RANDOM ERROR AC,RAN ;XOR FAILED XOR AC,[0] ;ANY NUMBER XORED CAME AC,RAN ;WITH THE NUMBER 0 ERROR AC,RAN ;SHOULD REMAIN UNCHANGED XOR AC,RAN ;ANY NUMBER XORED CAME AC,[0] ;WITH ITSELF SHOULD ERROR AC,[0] ;EQUAL 0 XOR AC,[-1] ;SET AC TO ALL ONES XOR AC,RAN ;AC SHOULD CONTAIN COMP OF RAN XOR AC,[-1] ;RECOMPLEMENT AC TO ORIG CAME AC,RAN ;CHECK FOR RANDOM ERROR AC,RAN ;XOR FAILED LOOP .-22,.-21 AC=AC+1 > ;TEST SETZI AND IOR. SETZI ABILITY TO CLEAR,IOR RAN TO 0, ;RANDOM TO RANDOM,RANDOM TO COMP RANDOM,0 TO RANDOM ;ERROR IN THE FORM (PC,AC,C(AC),CORRECT) AC=5 BOLZI: SETUP 100,0 RANDOM BOLZI1: REPEAT 2, < MOVE AC,RAN# ;LOAD THE AC THEN SETZI AC,(AC) ;TRY TO CLEAR IT,INDEX REDUNDANT CAME AC,[0] ;IF NOT 0 ERROR AC,[0] ;SETZI FAILED IOR AC,RAN ;INCLUSIVE OR OF A CAME AC,RAN ;NUMBER TO 0 SHOULD PRODUCE ERROR AC,RAN ;THE NUMBER IOR AC,RAN ;IOR SAME NUMBERS CAME AC,RAN ;SHOULD HAVE NO EFFECT ERROR AC,RAN ;ON AC.IOR FAILED IOR AC,[0] ;IOR OF NO BITS SHOULD DO NOTHING CAME AC,RAN ERROR AC,RAN ;IOR FAILED SETCA AC,0 IOR AC,RAN ;INCLUSIVE OR OF COMP NUMBERS CAME AC,[-1] ;SHOULD SET ALL BITS ERROR AC,[-1] ;IOR FAILED IOR AC,[-1] ;ALL BITS TO ALL BITS CAME AC,[-1] ;PRODUCE ALL BITS ERROR AC,[-1] AC=&17 > AC=5 LOOP BOLZI1-4,BOLZI1 ;TEST AND FOR 0 TO 0,1 TO 1,0 TO 1,1 TO 0 ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 BOLA: SETUP 400,0 RANDOM BOLA1: AND AC,RAN ;NUMBER AND NUMBeR CAME AC,RAN ;SHOULD EQUAL NUMBER ERROR AC,RAN ;IF NOT, "AND" FAILED. AND AC,[-1] ;"AND" OF ALL BITS WITH CAME AC,RAN ;ANY NUMBER SHOULD ERROR AC,RAN ;LEAVE THE NUMBER UNCHANGED SETCA AC, AND AC,RAN ;"AND" OF A NUMBER WITH ITS CAME AC,[0] ;COMPLEMENT SHOULD ERROR AC,[0] ;PRODUCE 0 LOOP BOLA1-4,BOLA1 ;TEST ORCA AND SETO. 1 TO 0,1 TO 1, 0 TO 0, 1 TO 0,0 TO 1 ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) ;ONE AC IS USED FOR TESTING AC=12 BOLOS: SETUP 300,0 RANDOM BOLOS1: SETO AC,. ;WILL CHANGE THIS INST IF FETCH/STORE C(E). CAME AC,[-1] ;CHECK FOR ALL BITS SET ERROR AC,[-1] ;SETO FAILED ORCA AC,RAN ;-1 ORED TO RANDOM CAME AC,RAN ;SHOULD PRODUCE RANDOM ERROR AC,RAN ;IF AC COMP PROBELY ORCA AC,RAN ;RANDOM TO RANDOM SHOULD CAME AC,[-1] ;PRODUCE -1 ERROR AC,[-1] ;IF AC COMPLEMENTED PROPERLY ORCA AC,[0] ;WITH NO BITS EFFECT IC COMP AC ORCA AC,RAN CAME AC,[-1] ;NO BITS COMPLEMENTS TO PRODUCE ERROR AC,[-1] ;ALL ONES LOOP BOLOS1-4,BOLOS1 ;TEST ANDCA.1 TO 1,0 TO 0, 0 TO 1,0 TO 0,1 TO 1,1 TO 0 ;ERRORS ARE IN THE FORM(PC,AC,C(AC),CORRECT ;ONE AC IS USED AC=13 BOLAC: SETUP 200,1 RANDOM BOLAC1: ANDCA AC,RAN ;ANDCA OF LIKE NUMBERS CAME AC,[0] ;SHOULD PRODUCE 0 ERROR AC,[0] ;ANDCA FAILED ANDCA AC,RAN CAME AC,RAN ;ANDCA OF ZERO AND NUMBER ERROR AC,RAN ;SHOULD PRODUCE NUMBER SETO AC,. ;SET ALL BITS ANDCA AC,RAN CAME AC,[0] ;ANDCA OF ALL BITS WITH NUMBER ERROR AC,[0] ;SHOULD PRODUCE 0 LOOP BOLAC1-4,BOLAC1 ;TEST EQV,1 TO 1,0 TO 0,1 TO 0,0 TO 1. EQV =(SET ALL LIKE BITS) ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=14 BOLEQ: SETUP 200,2 RANDOM BOLEQ1: EQV AC,RAN ;WHEN NUMBERS ARE EQUAL CAME AC,[-1] ;EQV SHOULD PRODUCE ALL ERROR AC,[-1] ;BITS SET.EQV FAILED EQV AC,RAN# CAME AC,RAN ;WITH AC SET,EQV SHOULD ERROR AC,RAN ;PRODUCE C(E) IN THE AC SETZI AC,-1 EQV AC,RAN ;WHEN AC=0 EQV SHOULD SETCA AC,. ;PRODUCE COMPLEMENT OF CAME AC,RAN ;C(E) ERROR AC,RAN ;EQV FAILED LOOP BOLEQ1-3,BOLEQ1 ;TEST SETM. SET THE CONTENTS OF MEMORY TO THE AC ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 BOLSM: SETUP 100,0 RANDOM BOLSM1: REPEAT 2, < SETM AC1,RAN ;THE NET RESULT OF SETM CAME AC1,AC ;IS THE SAME AS MOVE ERROR AC1,RAN ;SETM FAILED AC=&17 AC1=&17 > AC=10 LOOP BOLSM1-4,BOLSM1 ;TEST SETCM. (MOVE THE COMPLEMENT OF MEMORY TO AC) ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=14 BOLCM: SETUP 100,0 RANDOM BOLCM1: SETCM AC1,RAN ;COMP OF RANDOM TO AC SETCM AC2,AC1 ;RECOMP TO AC2 CAME AC2,RAN ERROR AC2,RAN ;SETCM 1 OR 2 FAILED LOOP BOLCM1-3,BOLCM1 ;TEST ORCM. (INCLUSIVE OR THE CONTENTS OF COMPLEMENTED MEMORY ;TO THE CONTENTS OF AC.) ERRORS ARE IN THE FORM (PC,AC, ;C(AC),CORRECT AC=5 BOLOC: SETUP 140,0 RANDOM BOLOC1: ORCM AC,RAN ;LIKE NUMBERS SHOULD PRODUCE CAME AC,[-1] ;ALL BITS SET ERROR AC,[-1] ORCM AC,RAN ;ANY NUMBER ORED WITH ALL CAME AC,[-1] ;ONES SHOULD PRODUCE ERROR AC,[-1] ;ALL ONES SETZI AC,-1 ORCM AC,RAN ;THE RANDOM NUMBER IS SETCA AC,. ;ORED TO 0. THIS SHOULD CAME AC,RAN ;PRODUCE THE COMPLEMENT ERROR AC,RAN ;OF RANDOM ORCM AC,[-1] CAME AC,RAN ;ORING -1 SHOULD LEAVE ERROR AC,RAN ;AC UNCHANGED LOOP BOLOC1-3,BOLOC1 ;TEST ANDCM (AND WITH THE COMP OF MEMORY) ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 BOLAX: SETUP 140,0 RANDOM BOLAX1: ANDCM AC,RAN ;LIKE NUMBERS SHOULD CAME AC,[0] ;PRODUCE 0 ERROR AC,[0] ;ANDCM FAILED ANDCM AC,RAN ;ANYTHING ANDED TO CAME AC,[0] ;ZERO SHOULD = 0 ERROR AC,[0] SETO AC, ANDCM AC,RAN ;AC SHOULD - COMP OF MEMORY ANDCM AC,[0] ;AC SHOULD REMAIN UNCHANGED XOR AC,[-1] ;COMP AC CAME AC,RAN ;AFTER COMP SHOULD EQUAL ERROR AC,RAN ;RANDOM. ANDCM FAILED LOOP BOLAX1-3,BOLAX1 ;TEST ORCB (INCLUSIVE OR THE COMPLEMENT OF AC AND C(E)) ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=1 BOLOB: SETUP 140,0 RANDOM BOLOB1: ORCB AC,RAN ;PRODUCE COMP OF RAN ORCB AC,[-1] ;COMP AC CAME AC,RAN ;CHECK ORCB ERROR AC,RAN ORCB AC,[-1] ;COMP AC ORCB AC,RAN ;ANY TWO COMPLEMENTED NUMBERS CAME AC,[-1] ;SHOULD PRODUCE ALL ONES ERROR AC,[-1] ORCB AC,[0] ;AC COMPLEMENTS TO 0 CAME AC,[-1] ERROR AC,[-1] ;ORCB FAILED LOOP BOLOB1-4,BOLOB1 ;TEST ANDCB (AND WITH BOTH OPERANDS COMPLEMENTED) ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=2 BOLAB: SETUP 140,0 RANDOM BOLAB1: ANDCB AC,RAN ;PRODUCE COMP OF RAN ANDCB AC,[0] ;COMP AC CAME AC,RAN ;CHECK FOR ORIGIONAL NUMBER ERROR AC,RAN ;ANDCB FAILED ANDCB AC,[0] ;COMPLEMENT AC ANDCB AC,[0] ;RECOMPLEMENT AC CAME AC,RAN ;SHOULD PRODUCE ORIGIONAL ERROR AC,RAN ;ANDCB FAILED ANDCB AC,[-1] ;RESULT SHOULD BE 0 IF CAME AC,[0] ;CONTENTS OF E ERROR AC,[0] ;CONTAINS NO BITS AFTER COMP ANDCB AC,RAN ;AC SHOULD EQUAL COMP OF RAN ANDCB AC,[0] ;COMP AC CAME AC,RAN ;THE AND TO 0 ERROR AC,RAN ;FAILED LOOP BOLAB1-3,BOLAB1 ;TEST SETA (EFFECTIVELY A NO OPERATION IN THIS MODE) ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=3 BOLSA: SETUP 100,0 RANDOM ;DO 7 SETA'S. BOLSA1: REPEAT 7,< SETA AC,.> CAME AC,RAN ;C(AC) SHOULD = ORIG. C(AC) ERROR AC,RAN LOOP BOLSA1-3,BOLSA1 ;TEST IORM, WHERE E IS AN AC. THE INST IS TESTED ;FOR NOT STORING IN AC AS WELL AS STORING PROPERLY ;IN E. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=11 BMIOR: SETUP 100,1 BMIOR1: RANDOM BMIOR2: MOVS AC1,AC ;AC=C(E) ORIG CAMN AC,AC1 ;HALVES SAME? JRST BMIOR1 ;YES. REJECT. SETCM AC ;SIM AN AND AC1 ;IOR XOR AC ;INST IORM AC,AC1 ;RESULT TO AC1 CAMN AC,AC1 ;BOTH SAME? ERROR AC,AC1 ;YES. STORED IN AC. CAME AC1,0 ;C(E) = SIM. ANS? ERROR AC,0 ;NO. IORM FAILED. LOOP BMIOR1,BMIOR2 ;TEST ORCAM, WHERE E IS AN AC. THE INSTRUCTION IS TESTED ;FOR NOT STORING IN AC AS WELL AS STORING PROPERLY IN C(E). ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=12 BMICA: SETUP 100,1 BMICA1: RANDOM BMICA2: MOVS AC1,AC ;SECOND RANDOM NUMBER SETCM AC2,AC1 ;MOVE COMPLEMENT OF NUMBER SETCM AC ;SIMULATE AND AC2 ;THE INSTRUCTION XOR AC ;IN AC0. ORCAM AC1,AC ;RESULT TO C(E) CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. STORED IN AC. CAME AC,0 ;C(E) = SIM. ANS? ERROR AC,0 ;NO. ORCAM FAILED. LOOP BMICA1,BMICA2 ;TEST ORCMM, WHERE E IS AN AC. THE INSTRUCTION ;IS TESTED FOR NOT STORING IN AC AS WELL AS THE ;CORRECT ANSWER IN C(E). ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=13 BMICM: SETUP 100,0 BMICM1: RANDOM BMICM2: MOVS AC1,AC ;SECOND RANDOM NUMBER SETCM AC2,AC ;SIMULATE SETCM AC1 ;THE AND AC2 ;INSTRUCTION XOR AC1 ;IN AC0 CAMN 0,AC1 ;IS SIMULATED ANS JRST BMICM1 ;= C(AC)?...REJECT. ORCMM AC1,AC ;IF AC1 = AC, STORE INHIBIT CAMN AC1,AC ERROR AC1,AC ;FAILED. CAME AC,0 ;C(E) SHOULD = SIM. ANS. ERROR AC,0 ;ORCMM FAILED. LOOP BMICM1,BMICM2 ;TEST ORCBM, WHERE E IS AN AC. THE INSTRUCTION ;IS TESTED FOR NOT STORING IN AC AS WELL AS THE ;CORRECT ANSWER IN C(E). ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=14 BMICB: SETUP 200,0 BMICB1: RANDOM BMICB2: MOVS AC1,AC ;AC1= 0101,0011 SETCM AC2,AC ;AC2= 1100,1010 SETCM AC2 ;AC0 = 0011,0101 ANDCM AC1 ;AC0 = 0010,0100 XOR AC2 ;AC0 = 1110,1110 ORCBM AC1,AC ;SHOULD PRODUCE SAME LOGIC CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,0 ;C(E) SHOULD = SIM. ANS. ERROR AC,0 ;ORCBM FAILED. LOOP BMICB1,BMICB2 ;TEST XORM, WHERE E IS AN AC. THE INSTRUCTION IS ;TESTED FOR NOT STORING AC AS WELL AS CONTENTS ;OF E CORRECTNESS. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 BMX: SETUP 200,1 BMX1: RANDOM BMX2: JUMPE AC,BMX1 ;REJECT IF RAN = 0. MOVS AC1,AC ;SECOND RANDOM NUMBER. SETCM AC ANDCA AC1 ;PERFORM MOVE AC2,AC ;A PSEUDO IOR AC2,AC1 ;EXCLUSIVE ANDCA AC2 ;OR INSTRUCTION XORM AC1,AC ;DO THE XOR CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,0 ;C(E) SHOULD = SIM. ANS. ERROR AC,0 ;XORM FAILED. LOOP BMX1,BMX2 ;TEST EQVM, WHERE E IS AN AC. THE INSTRUCTION ;IS TESTED FOR NOT STORING AC AS WELL AS ;CORRECTNESS OF C(E). ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 BMEQ: SETUP 100,0 BMEQ1: RANDOM BMEQ2: MOVS AC1,AC ;SECOND RANDOM NUMBER SETCM AC1 ;EQV IS SAME LOGIC XOR AC ;AS XOR WITH COMP AC EQVM AC1,AC ;EQV SETS ALL LIKE BITS CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,0 ;C(E) SHOULD = SIM. ANS. ERROR AC,0 ;EQVM FAILED. LOOP BMEQ1,BMEQ2 ;TEST ANDM, WHERE E IS AN AC. THE INSTRUCTION IS ;TESTED FOR NOT STORING IN AC AS WELL AS STORING ;PROPERLY IN C(E). ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=3 BMAN: SETUP 100,0 BMAN1: RANDOM BMAN2: MOVS AC1,AC ;SECOND RANDOM NUMBER MOVE AC ;SIMULATE IOR AC1 ;AN "AND" XOR AC1 ;INSTRUCTION. XOR AC ;IN AC0 CAMN AC1,AC ;REJECT THE NUMBER JRST BMAN1 ;IF EQUAL. ANDM AC1,AC ;THE INSTRUCTION CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,0 ;C(E) SHOULD = SIM. ANS. ERROR AC,0 ;AND FAILED. LOOP BMAN1,BMAN2 ;TEST ANDCAM, WHERE E IS AN AC. THE INSTRUCTION IS ;TESTED FOR NOT STORING IN AN AC AS WELL AS ;STORING C(E) PROPERLY. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=4 BMACA: SETUP 100,0 BMACA1: RANDOM BMACA2: JUMPE AC,BMACA1 ;REJECT IF RAN = 0. MOVS AC1,AC ;SECOND RANDOM NUMBER SETM AC ;SIMULATE ORCA AC1 ;ANDCA SETCA ;LOGIC ANDCAM AC1,AC ;THE INSTRUCTION CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,0 ;C(E) SHOULD = SIM. ANS. ERROR AC,0 ;ANDCA FAILED. LOOP BMACA1,BMACA2 ;TEST ANDCMM, WHERE E IS AN AC. THE INSTRUCTION IS ;TESTED FOR NOT STORING IN AN AC AS WELL AS ;STORING C(E) PROPERLY. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=5 BMACM: SETUP 100,0 BMACM1: RANDOM BMACM2: JUMPE AC,BMACM1 ;REJECT IF RAN = 0. MOVS AC1,AC ;SECOND RANDOM NUMBER SETAM AC1,0 ;AC1 TO AC0. IOR AC ;SIMULATE XOR AC ;THE INSTUCTION CAMN 0,AC1 ;SIM ANS = C(AC)? JRST BMACM1 ;YES. REJECT. ANDCMM AC1,AC ;DO AN ANDCMM INSTRUCTION. CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,0 ;C(E) SHOULD = SIM. ANS. ERROR AC,0 ;ANDCMM FAILED. LOOP BMACM1,BMACM2 ;TEST ANDCBM, WHERE E IS AN AC. THE INSTRUCTION ;IS TESTED FOR NOT STORING IN AC AS WELL AS STORING ;PROPERLY IN C(E). ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=7 BMACB: SETUP 100,0 BMACB1: RANDOM BMACB2: MOVS AC1,AC ;SECOND RANDOM NUMBER. SETCM AC1 ;SIMULATE SETCM 1,AC ;AN AND 1 ;ANDCBM INST. ANDCBM AC1,AC ;DO AN ANDCBM. CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,0 ;C(E) SHOULD = SIM. ANS. ERROR AC,0 ;ANDCBM FAILED. LOOP BMACB1,BMACB2 ;TEST SETCAM, WHERE E IS AN AC. THE INSTRUCTION ;IS TESTED FOR NOT STORING IN AC AS WELL AS ;PROPER C(E). ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 BMCMM: SETUP 200,0 BMCMM1: RANDOM BMCMM2: MOVS AC1,AC ;CHECK FOR NO CHANGE CAMN AC1,AC ;IN 8 COMPLEMENTS JRST BMCMM1 ;REJECT IF HALF SAME. REPEAT 10,< SETCMM AC1,AC> CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,RAN ;C(E) SHOULD = ORIG. C(E). ERROR AC,RAN ;SETCMM FAILED. LOOP BMCMM1,BMCMM2 ;TEST SETCAM, WHERE E IS AN AC. TEST FOR NOT ;STORING IN AC AS WELL AS PROPER STORAGE IN C(E). ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=11 BMCAM: SETUP 100,0 BMCAM1: RANDOM BMCAM2: MOVS AC1,AC ;SECOND RANDOM NUMBER. SETCM AC1 ;SIMULATE SETCAM. SETCAM AC1,AC ;DO SETCAM. CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,0 ;C(E) SHOULD = SIM. ANS. ERROR AC,0 ;SETCAM FAILED. LOOP BMCAM1,BMACM2 ;TEST SETAM, WHERE E IS AN AC. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 BMSA: SETUP 100,0 BMSA1: RANDOM BMSA2: MOVS AC1,AC ;SECOND RANDOM NUMBER CAMN AC1,AC JRST BMSA1 ;REJECT IF SAME. SETAM AC,AC1 ;C(AC) TO C(AC1) CAME AC,AC1 ;EQUAL? ERROR AC,AC1 ;NO. CAME AC1,RAN ;C(E) SHOULD = ORIG C(AC). ERROR AC1,RAN ;SETAM FAILED. LOOP BMSA1,BMSA2 ;TEST SETOM, WHERE E IS AN AC. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 BMSM: SETUP 100,0 BMSM1: RANDOM BMSM2: MOVS AC1,AC ;SECOND RANDOM NUMBER SETOM AC1,AC ;DO SETOM INST. CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,[-1] ;C(E) SHOULD = A -1. ERROR AC,[-1] ;SETOM FAILED. LOOP BMSM1,BMSM2 ;TEST SETMM, WHERE E IS AN AC. ;ERRORS ARE IN THE FORM (PC, AC,C(AC),CORRECT) AC=10 BMSMM: SETUP 100,0 BMSMM1: RANDOM BMSMM2: MOVS AC1,AC ;A SECOND RANDOM NUMBER CAMN AC,AC1 ;REJECT IF JRST BMSMM1 ;HALF SAME ;DO 8 SETMM...SHOULD NOT CHANGE C(E). REPEAT 10,< SETMM AC1,AC> CAMN AC1,AC ;EQUAL? ERROR AC1,AC ;YES. INHIBIT STORE AC FAILED. CAME AC,RAN ;C(E) SHOULD = ORIG. C(E). ERROR AC,RAN ;SETMM FAILED. LOOP BMSMM1,BMSMM2 ;TEST SETZM, WHERE E IS AN AC. TESTS FOR NOT STORING ;IN AC AS WELL AS STORING IN C(E) PROPERLY. AC=10 SETZM1: SETUP 40,0 SETZM2: RANDOM SETZM3: JUMPE AC,SETZM2 ;REJECT IF C(AC) = 0. SETOB AC1,RAN1 ;SET C(AC) TO ALL ONES. SETZM AC1,AC ;DO SETZM CAME AC,[0] ;DID AC GET CLEARED? EERR ,RAN1 ;NO. CAME AC1,[-1] ;DOES C(AC1) STILL = -1? EERR ,RAN1 ;NO. LOOP SETZM2,SETZM3 ;TEST ROT LEFT 3X(2X18). CHECKING FOR AC1 NOT CHANGED ;AS WELL AS C(AC) BEING THE PROPER NUMBER. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 ROTL2: SETUP 200,2 ROTL2A: RANDOM ROTL2B: SETOB AC1,RAN1 ;SET AC+1 TO ALL ONES. ;DO 6 X (ROT LEFT 18 PLACES). REPEAT 3,< ROT AC,22 ROT AC,22> CAME AC,RAN ;C(AC)SHOULD = C(AC) BEFORE ROT. EERRI ,22 CAME AC1,[-1] ;AC1 SHOULD NOT HAVE CHANGED. ERR RAN1,22 LOOP ROTL2A,ROTL2B ;TEST ROT RIGHT 3X(2X18)..CHECKING FOR AC1 NOT ;CHANGED AS WELL AS C(AC) ENDING UP BEING ;THE SAME AS IT WAS BEFORE THE ROT. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=10 ROTR2: SETUP 300,2 ROTR2A: RANDOM ROTR2B: SETOB AC1,RAN1 ;SET AC+1 TO ALL ONES. ;DO 6 X (ROT RIGHT 18 PLACES). REPEAT 3,< ROT AC,-22 ROT AC,-22> CAME AC,RAN ;C(AC) SHOULD = C(AC) BEFORE ROT. EERR ,-22 CAME AC1,[-1] ;C(AC1) SHOULD STILL = -1. ERRI RAN1,-22 LOOP ROTR2A,ROTR2B ;TEST ROT LEFT 3X36. CHECKING FOR AC1 NOT ;CHANGED AND C(AC) = WHAT IT WAS BEFORE ;ROT. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=2 RTL36: SETUP 300,2 RTL36A: RANDOM RTL36B: SETOB AC1,RAN1 ;SET AC+1 TO ALL ONES. ;DO 3 X (ROT LEFT 36 PLACES). REPEAT 3,< ROT AC,44> CAME AC,RAN ;C(AC) SHOULD = C(AC) BEFORE ROT. EERRI ,44 CAME AC1,[-1] ;C(AC1) SHOULD STILL = -1. ERRI RAN1,44 LOOP RTL36A,RTL36B ;TEST ROT RIGHT 3X36. CHECKING FOR AC1 NOT ;CHANGED AND C(AC) = WHAT IT DID BEFORE ROT. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=2 RTR36: SETUP 300,2 RTR36A: RANDOM RTR36B: SETOB AC1,RAN1 ;SET AC+1 TO ALL ONES. ;DO 3 X (ROT RIGHT 36 PLACES). REPEAT 3,< ROT AC,-44> CAME AC,RAN ;C(AC) SHOULD = RAN. EERRI ,-44 CAME AC1,[-1] ;C(AC1) SHOULD STILL = -1. ERRI RAN1,-44 LOOP RTR36A,RTR36B ;TEST ROTC LEFT 3X36 THROUGH ALL AC'S CHECKING ;FOR C(AC) AND C(AC1) BEING EXCHANGED ;AFTER THE ROTC. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=2 RTCL: SETUP 100,2 RTCLA: RANDOM RTCLB: REPEAT ^D10,< MOVE AC,RAN ;MOVE A RAN NUM INTO AN AC. SETOB AC1,RAN1 ;SET AC+1 TO ALL ONES. ;DO 3 X (ROTC LEFT 36 PLACES). REPEAT 3,< ROTC AC,44> CAME AC1,RAN ;C(AC1) SHOULD = RAN. EERRI ,44 CAME AC,[-1] ;C(AC) SHOULD = A -1. ERRI RAN1,44 AC=&17 AC1=&17 > AC=2 LOOP RTCLA,RTCLB ;TEST ROTC RIGHT 3X36 THROUGH ALL AC'S. CHECKING ;FOR C(AC) AND C(AC1) BEING EXCHANGED. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=2 RTCR: SETUP 100,2 RTCRA: RANDOM RTCRB: REPEAT ^D10,< MOVE AC,RAN ;MOVE A RAN NUM INTO AN AC. SETOB AC1,RAN1 ;SET AC+1 TO ALL ONES. ;DO 3 X (ROTC RIGHT 36 PLACES). REPEAT 3,< ROTC AC,-44> CAME AC1,RAN ;C(AC1) SHOULD = C(AC) BEFORE ROTC. EERRI ,-44 CAME AC,[-1] ;C(AC) SHOULD = C(AC1) BEFORE ROTC. ERRI RAN1,-44 AC=&17 AC1=&17 > AC=2 LOOP RTCRA,RTCRB ;TEST ROT. ROT A RANDOM NUMBER A RANDOM NUMBER OF TIMES ;IN ONE DIRECTION AND THEN THE SAME NUMBER OF TIMES ;IN THE OPPOSITE DIRECTION. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT). AC=2 ROTLR: SETUP 100,4 ROTLR1: RANDOM MOVE AC3,RAN ;CHECK TO SEE AND AC3,[377] ;THAT THE RIGHT MOST 8 BITS JUMPE AC3,ROTLR1 ;DO NOT = 0..REJECT IF THEY DO. ROTLR2: MOVN AC2,RAN ;PUT 2'S COMP OF RAN INTO AC2. SETOB AC1,RAN1 ;SET AC+1 TO ALL ONES. ROT AC,(AC) ;ROT AC A RANDOM NUMBER OF TIMES. ROT AC,(AC2) ;ROT AC THE SAME NUM OF TIMES ;IN THE OPPOSITE DIRECTION. CAME AC,RAN ;C(AC) SHOULD STILL = C(RAN). ERROR AC,RAN CAME AC1,[-1] ;C(AC1) SHOULD STILL = -1. ERROR AC1,[-1] LOOP ROTLR1,ROTLR2 ;TEST ROTC. DO A ROTC WITH A RANDOM NUMBER A RANDOM ;NUMBER OF TIMES IN ONE DIRECTION AND THEN THE SAME ;NUMBER OF TIMES IN THE OPPOSITE DIRECTION. ;REPEAT THIS TEST FOR ALL AC'S. ;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT) AC=2 RTCLR: SETUP 200,3 RTCLR1: RANDOM MOVE AC3,RAN ;CHECK TO SEE AND AC3,[377] ;THAT THE RIGHT MOST 8 BITS JUMPE AC3,RTCLR1 ;DO NOT = 0..REJECT IF THEY DO. RTCLR2: REPEAT ^D10,< MOVE AC,RAN ;MOVE A RAN NUM INTO AN AC. MOVN AC2,RAN ;MOVE THE 2'S COMP INTO ANOTHER AC. SETO AC1, ;SET AC1 TO ALL ONES. ROTC AC,(AC) ;ROTC AC A RANDOM NUMBER OF ;TIMES IN ONE DIRECTION. ROTC AC,(AC2) ;ROTC AC THE SAME NUMBER OF ;TIMES IN THE OPPOSITE DIRECTION. CAME AC,RAN ;C(AC) SHOULD STILL = RAN. ERROR AC,RAN CAME AC1,[-1] ;C(AC1) SHOULD STILL =-1 ERROR AC1,[-1] AC=&17 AC1=&17 AC2=&17 > AC=2 LOOP RTCLR1,RTCLR2 ;TEST OVERFLOW ON A ROT LEFT...AROV SHOULD NOT COME UP. AC=2 ROTOV: SETUP 20,0 ROTOV1: RANDOM ROTOV2: JUMPE AC,ROTOV1 ;REJECT IF RAN = 0. CAMN AC,[-1] ;ALSO REJECT IF RAN = -1. JRST ROTOV1 JFCL 10,.+1 ;CLEAR OV FLAG. ROT AC,256 ;ROT C(AC) 256 TIMES. JFCL 10,.+2 ;OV FLAG GET SET? JRST .+2 ;NO. ER AC,[ASCII /OV/] ;YES. SHOULD NOT SET ON A ROT. LOOP ROTOV1,ROTOV2 ;TEST OVERFLOW FLAG ON A ROT RIGHT...SHOULD NEVER GET SET. AC=3 RTROV: SETUP 20,0 RTROV1: RANDOM RTROV2: JUMPE AC,RTROV1 ;REJECT IF RAN = 0. CAMN AC,[-1] ;ALSO REJECT IF RAN = -1. JRST RTROV1 JFCL 10,.+1 ;CLEAR OVERFLOW FLAG. ROT AC,-256 ;ROT AC RIGHT 256 TIMES. JFCL 10,.+2 ;OVERFLOW FALG GET SET? JRST .+2 ;NO. ER AC,[ASCII /OV/] LOOP RTROV1,RTROV2 ;TEST MOVEM. AFTER FOLLOWED BY ;, C(AC) SHOULD = ORIG C(AC). ;RAN TO RAN1. AC=2 MVEM1: SETUP 30,0 MVEM2: RANDOM ;DO 3 SETS OF MOVEM'S. MVEM3: REPEAT 3,< MOVEM AC,AC1 MOVEM AC1,AC> CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERROR AC,RAN CAME AC1,RAN ;C(AC1) SHOULD ALSO = ORIG. C(AC). ERROR AC1,RAN LOOP MVEM2,MVEM3 ;TEST MOVES. AFTER 6 MOVES IN A ROW, THE C(E) ;SHOULD = ORIG C(E). AC=2 MVES1: SETUP 200,1 MVES2: RANDOM ;DO 6 MOVE INSTRUCTIONS. MVES3: REPEAT 3,< MOVES AC1,AC MOVES AC1,AC> CAME AC1,AC ;C(AC) SHOULD = C(E). ERROR AC1,AC CAME AC,RAN ;C(E) SHOULD = ORIG C(E). ERROR AC,RAN LOOP MVES2,MVES3 ;TEST MOVS INSTRUCTION...TWO MOVS SHOULD GIVE SAME NUMBER. AC=4 MOVSA: SETUP 200,2 MOVSB: RANDOM ;DO 6 MOVS INSTRUCTIONS. MOVSC: REPEAT 3,< MOVS AC,AC MOVS AC,AC> CAME AC,RAN ;C(AC) SHOULD STILL = RAN. EERR ,RAN LOOP MOVSB,MOVSC ;TEST MOVS INSTRUCTION...MOVS FOLLOWED BY ROT SHOULD GIVE ;SAME NUMBER. AC=5 MOVS1: SETUP 200,1 MOVS2: RANDOM MOVS3: MOVS AC,AC ;DO MOVS INSTRUCTION. ROT AC,22 ;ROT LEFT 18 PLACES. CAME AC,RAN ;C(AC) SHOULD NOW = RAN. EERR ,RAN LOOP MOVS2,MOVS3 ;TEST MOVSM....TWO MOVSM SHOULD GIVE THE ORIG. NUM. AC=6 MOVSMA: SETUP 300,1 MOVSMB: RANDOM MOVSMC: REPEAT 3,< MOVSM AC,AC1 MOVSM AC1,AC> CAME AC,RAN ;C(AC) SHOULD NOW BE = TO RAN. ERROR AC,RAN LOOP MOVSMB,MOVSMC ;TEST MOVSS...TWO MOVSS SHOULD GIVE THE ORIGINAL NUMBER. AC=7 MOVSSA: SETUP 200,0 MOVSSB: RANDOM MOVSSC: SETZB 0,RAN1 ;CLEAR AC0. REPEAT 3,< MOVSS AC MOVSS AC> CAME AC,RAN ;C(AC) SHOULD NOW BE = TO RAN. EERR ,RAN1 CAME [0] ;C(AC0) SHOULD STILL = 0. EERR ,RAN1 LOOP MOVSSB,MOVSSC ;TEST MOVSI. AC=10 MOVSIA: SETUP 100,0 MOVSIB: RANDOM MOVE AC2,RAN ;PUT RAN INTO AN AC. MOVSIC: ANDI AC,-1 ;SIMULATE ROT AC,22 ;A MOVSI INST. MOVSI AC1,(AC2) ;DO MOVSI. CAME AC1,AC ;C(AC1) SHOULD = SIM. ANS. ERROR AC1,AC LOOP MOVSIB,MOVSIC ;TEST LSH. SIMULATE A LSH 18 PLACES WITH A MOVSI. AC=11 LSHA: SETUP 200,1 LSHB: RANDOM LSHC: SETO AC1, ;SET AC+1 TO ALL ONES. MOVSI AC2,(AC) ;SIMULATE LSH 18 PLACES. LSH AC,22 ;DO LSH CAME AC,AC2 ;C(AC) SHOULD = SIM. ANS. ERROR AC,AC2 CAME AC1,[-1] ;AC1 GET CHANGED? ERROR AC1,[-1] ;YES. LOOP LSHB,LSHC ;TEST LSH RIGHT 18 PLACES. AC=10 LSH1: SETUP 200,1 LSH2: RANDOM LSH3: SETOB AC1,RAN1 ;SET C(AC+1) TO ALL ONES. LSH AC,-22 ;DO LSH RIGHT 18 PLACES. MOVS AC2,RAN ;SIMULATE ANDI AC2,-1 ;LSH. CAME AC,AC2 ;C(AC) SHOULD = SIM. ANS. EERRI ,-22 CAME AC1,[-1] ;C(AC+1) GET CHANGED? ERRI RAN1,-22 LOOP LSH2,LSH3 ;TEST ASH ABILITY TO SET OR NOT SET OVERFLOW FLAG. AC=10 ASHOV: SETUP 30,0 ASHOV1: SETO AC, ;SET AC TO ALL ONES..1,1 CONDITION. JFCL 10,.+1 ;CLEAR OV FLAG. ASH AC,1 ;DO ASH. JFCL 10,.+2 ;OVERFLOW FLAG GET SET? JRST .+2 ;NO. ER AC,[ASCII /OV/] ;YES. 1,1 CONDITION SHOULD NOT SET IT. JFCL 10,.+1 ;CLEAR OV FLAG. SETZ AC, ;CLEAR AC...0,0 CONDITION. ASH AC,1 ;DO ASH. JFCL 10,.+2 ;OVERFLOW FLAG GET SET? JRST .+2 ;NO. ER AC,[ASCII /OV/] ;YES. 0,0 COND. SHOULDN'T SET IT. JFCL 10,.+1 ;CLEAR OV FLAG. MOVSI AC,377777 ;SET AC FOR 0,1 CONDITION. ASH AC,1 ;DO ASH. JFCL 10,.+2 ;OVERFLOW FLAG GET SET? ER AC,[ASCII /OV/] ;NO. 0,1 COND. SHOULD SET IT. JFCL 10,.+1 ;CLEAR OV FLAG. MOVSI AC,400000 ;SET AC FOR 1,0 CONDITION. ASH AC,1 ;DO ASH. JFCL 10,.+2 ;OV FLAG GET SET? ER AC,[ASCII /OV/] ;NO. 1,0 COND. SHOULD SET IT. LOOP ASHOV1,ASHOV1 ;TEST ASH. DO ASH RIGHT 36 PLACES WITH ORIG. ;C(AC) = 400000000000. AFTER ASH THE C(AC) SHOULD = A -1. AC=10 ASH1: SETUP 20,0 ASH2: MOVE AC,[XWD 400000,0] ;MAKE C(AC) = ALL 0'S WITH SIGN BIT SET. ASH AC,-44 ;DO ASH RIGHT 36 PLACES...SIGN CAME AC,[-1] ;BIT SHOULD HAVE SET ALL BITS TO A ONE. ERROR AC,[-1] LOOP ASH2,ASH2 ;TEST ASH. DO ASH LEFT 36 PLACES WITH ORIG. C(AC) = ;TO A -1. AFTER ASH THE C(AC) SHOULD = THE SIGN ;BIT SET AND THE REST ZEROS. AC=11 ASH3: SETUP 20,0 ASH4: MOVE AC,[-1] ;MAKE C(AC) = A -1. ASH AC,44 ;DO ASH LEFT 36 PLACES..0'S GOING CAME AC,[XWD 400000,0] ;INTO BIT 35 SHOULD JUST LEAVE SIGN BIT SET. ERROR AC,[0] LOOP ASH4,ASH4 ;TEST ADD. RAN TO 0 CONDITION. AC=10 ADD1: SETUP 100,0 ADD2: RANDOM ADD3: SETZ AC, ;CLEAR AC. ADD AC,RAN ;ADD RAN TO 0. CAME AC,RAN ;C(AC) SHOULD = RAN NUM. ERROR AC,RAN LOOP ADD2,ADD3 ; TEST ADD. 0 TO RAN CONDITION. AC=10 ADD1A: SETUP 100,0 ADD2A: RANDOM ;ADD A CONSTANT 0 TO RAN 5 TIMES. ADD3A: REPEAT 5,< ADD AC,[0]> CAME AC,RAN ;C(AC) SHOULD STILL = RAN NUM. ERROR AC,RAN LOOP ADD2A,ADD3A ;TEST ADD. ADD 1'S COMP OF RAN TO RAN. ;SHOULD GET A -1. AC=10 ADD1B: SETUP 100,0 ADD2B: RANDOM ADD3B: SETCM AC1,RAN ;1'S COMP OF RAN TO AC1. ADD AC,AC1 ;ADD IT TO RAN. CAME AC,[-1] ;C(AC) SHOULD = -1. ERROR AC,[-1] LOOP ADD2B,ADD3B ;TEST ADD. CHECK CRY0,CRY1,AND OV FLAGS. ;ADD, TO A RANDOM NUMBER, A -1 AND THEN A +1. ;CRY0 AND CRY1 SHOULD BOTH GET SET AND AROV SHOULD NOT GET SET. AC=10 ADD1C: SETUP 400,2 ADD2C: RANDOM ADD3C: JFCL 17,.+1 ;CLEAR ALL FLAGS. ADD AC,[-1] ;ADD A -1 TO RAN. ADD AC,[1] ;ADD A +1 TO ANS OF ADDITION OF RAN AND A -1. CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERROR AC,RAN JFCL 4,CRY0A JFCL 2,.+2 JRST BOTHF ER AC,[ASCII /CRY0/];CRY0 FAILED TO GET SET. CRY0A: JFCL 2,.+2 ER AC,[ASCII /CRY1/];CRY1 FAILED TO GET SET. JRST AROVA BOTHF: ER AC,[ASCII /CRY01/];BOTH CRY0 + CRY1 FAILED TO GET SET. AROVA: JFCL 10,.+2 JRST ADD4C ER AC,[ASCII /OV/] ;AROV GOT SET. ADD4C: LOOP ADD2C,ADD3C ;TEST ADDM. WHERE E IS AN AC. ;RAN TO 0 CONDITION. AC=4 ADDM1: SETUP 100,0 ADDM2: RANDOM MOVE AC2,RAN ;SAVE RAN IN AN AC. ADDM3: SETZB AC1,RAN1 ;MAKE C(E) = 0. ADDM AC,AC1 ;DO ADDM. CAME AC2,AC1 ;C(E) SHOULD =ORIG C(AC). ERRM RAN1,RAN LOOP ADDM2,ADDM3 ;TEST ADDM. WHERE E IS AN AC. ;0 TO RAN CONDITION. AC=5 ADDM1A: SETUP 100,0 ADDM2A: RANDOM MOVE AC2,RAN ;SAVE RAN IN AN AC. ADDM3A: SETZB AC1,RAN1 ;MAKE C(AC) = 0. ADDM AC1,AC ;DO ADDM. CAME AC2,AC ;C(E) SHOULD = ORIG C(E). EERRM ,RAN1 LOOP ADDM2A,ADDM3A ;TEST ADDM. WHERE E IS AN AC. ;1'S COMP RAN TO RAN. AC=6 ADDM1B: SETUP 100,0 ADDM2B: RANDOM ADDM3B: SETCM AC1,AC ;MAKE C(AC) = 1'S COMP OF C(E). MOVE RAN1,AC1 ;SAVE C(AC) IN CASE OF ERROR. ADDM AC1,AC ;DO ADDM. CAME AC,[-1] ;C(E) SHOULD = A -1. EERRM ,RAN1 LOOP ADDM2B,ADDM3B ;TEST ADDI. CHECK C(AC) FOR CORRECT DATA. ;0 TO RAN CONDITION. AC=2 ADDI1: SETUP 20,0 ADDI2: RANDOM ADDI3: ADDI AC,0 ;DO ADDI. CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). EERRI ,0 LOOP ADDI2,ADDI3 ;TEST ADDI. CHECK FOR CORRECT DATA IN AC. ;RAN TO 0 CONDITION. AC=2 ADDI1A: SETUP 100,0 ADDI2A: RANDOM ADDI3A: SETZB AC1,RAN1 ;CLEAR C(AC). MOVEI AC2,(AC) ;SIMULATE ADDI. ADDI AC1,(AC) ;DO ADDI. CAME AC1,AC2 ;C(AC) SHOULD = SIM. ANS. ERRI RAN1,(AC) LOOP ADDI2A,ADDI3A ;TEST ADDI. CHECK FOR CORRECT DATA IN AC. ;1'S COMP RAN TO RAN. AC=3 ADDI1B: SETUP 40,0 ADDI2B: RANDOM ADDI3B: SETCM AC1,AC ;MAKE C(AC) = 1'S COMP OF E. MOVE AC2,AC1 ;SIMULATE IORI AC2,-1 ;ADDI INST. MOVE RAN1,AC1 ;SAVE C(AC) IN CASE OF ERROR. ADDI AC1,(AC) ;DO ADDI. CAME AC1,AC2 ;C(AC) SHOULD = SIM. ANS. ERRI RAN1,(AC) LOOP ADDI2B,ADDI3B ;TEST ADDB. CHECK FOR C(AC) = C(E), AND CORRECT ;DATA IN AC FOR 0 TO RAN CONDITION. AC=4 ADDB1: SETUP 100,0 ADDB2: RANDOM ADDB3: SETZB AC1,RAN1 ;CLEAR C(E). ADDB AC,AC1 ;DO ADDB. CAME AC,AC1 ;C(AC) SHOULLD = C(E). ERR RAN1,RAN CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERR RAN1,RAN LOOP ADDB2,ADDB3 ;TEST ADDB. CHECK FOR C(AC) = C(E), AND CORRECT ;DATA IN AC FOR RAN TO 0 CONDITION. AC=5 ADDB1A: SETUP 100,0 ADDB2A: RANDOM ADDB3A: SETZB AC1,RAN1 ;CLEAR C(AC). ADDB AC1,AC ;DO ADDB. CAME AC1,AC ;C(AC) SHOULD = C(E). EERR ,RAN1 CAME AC1,RAN ;C(AC) SHOULD = ORIG C(E). EERR ,RAN1 LOOP ADDB2A,ADDB3A ;TEST ADDB. CHECK FOR C(AC) = C(E), AND CORRECT DATA ;IN AC FOR NOT RAN TO RAN CONDITION. AC=6 ADDB1B: SETUP 100,0 ADDB2B: RANDOM ADDB3B: SETCM AC1,AC ;MAKE C(E) = 1'S COMP OF C(AC). MOVE RAN1,AC1 ;SAVE C(E) IN CASE OF ERROR. ADDB AC,AC1 ;DO ADDB. CAME AC,AC1 ;C(AC) SHOULD = C(E). ERR RAN1,RAN CAME AC,[-1] ;C(AC) SHOULD = A -1. ERR RAN1,RAN LOOP ADDB2B,ADDB3B ;TEST SUB. CHECK C(AC) FOR CORRECT DATA. ;0 TO RAN CONDITION. AC=2 SUB1: SETUP 100,0 SUB2: RANDOM SUB3: SETZB AC1,RAN1 ;CLEAR C(E). REPEAT 3,< SUB AC,AC1> CAME AC,RAN ;C(AC) SHOULD STILL = ORIG C(AC). ERR RAN1,RAN LOOP SUB2,SUB3 ;TEST SUB. CHECK C(AC) FOR CORRECT DATA. ;RAN TO 0 CONDITION. AC=2 SUB1A: SETUP 100,0 SUB1B: RANDOM SUB1C: SETZB AC1,RAN1 ;CLEAR C(AC). MOVN AC2,RAN ;ANY NUM FROM 0 = 2'S COMP OF THAT NUM. SUB AC1,AC ;SUBTRACT RAN FROM 0. CAME AC1,AC2 ;C(AC) SHOULD = SIM. ANS. EERR ,RAN1 LOOP SUB1B,SUB1C ;TEST SUB. CHECK C(AC) FOR CORRECT DATA. ;SUB RAN FROM RAN. AC=2 SUB2A: SETUP 100,0 SUB2B: RANDOM SUB2C: MOVE AC1,AC ;MAKE C(E) = C(AC). SUB AC,AC1 ;SUB RAN FROM RAN. CAME AC,[0] ;C(AC) SHOULD = 0. EERR ,RAN LOOP SUB2B,SUB2C ;TEST SUBM. WHERE E IS AN AC. ;RAN TO 0 CONDITION. AC=7 SUBM1: SETUP 100,0 SUBM2: RANDOM SUBM3: SETZB AC1,RAN1 ;CLEAR C(AC). MOVN AC2,AC ;SIM SUB..RAN FROM 0 = 2'S COMP RAN. SUBM AC1,AC ;DO SUBM. CAME AC2,AC ;C(E) SHOULD = SIM. ANS. EERRM ,RAN1 LOOP SUBM2,SUBM3 ;TEST SUBM. SHERE E IS AN AC. ;0 TO RAN CONDITION. AC=10 SUBM1A: SETUP 100,0 SUBM2A: RANDOM MOVE AC2,RAN ;SAVE RAN IN AN AC. SUBM3A: SETZB AC1,RAN1 ;CLEAR C(E). SUBM AC,AC1 ;DO SUBM...0 FROM RAN = RAN. CAME AC2,AC1 ;C(E) SHOULD = ORIG C(AC). ERRM RAN1,RAN CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERRM RAN1,RAN LOOP SUBM2A,SUBM3A ;TEST SUBM. WHERE E IS AN AC. ;RAN TO RAN CONDITION. AC=11 SUBM1B: SETUP 100,0 SUBM2B: RANDOM SUBM3B: MOVE AC1,AC ;MAKE C(E) = C(AC). SUBM AC,AC1 ;DO SUBM. CAME AC1,[0] ;C(E) SHOULD = 0. EERRM ,RAN CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). EERRM ,RAN LOOP SUBM2B,SUBM3B ;TEST SUBI. CHECK C(AC) FOR CORRECT DATA. ;0 TO RAN CONDITION. AC=10 SUBI1: SETUP 20,0 SUBI2: RANDOM SUBI3: SUBI AC,0 ;DO SUBI..0 FROM RAN = RAN. CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). EERRI ,0 LOOP SUBI2,SUBI3 ;TEST SUBI. CHECK C(AC) FOR CORRECT DATA. ;RAN TO 0 CONDITION. AC=10 SUBI1A: SETUP 20,0 SUBI2A: RANDOM SUBI3A: SETZB AC1,RAN1 ;CLEAR C(AC). MOVNI AC2,(AC) ;SIM SUB..RAN FROM 0 = 2'S COMP RAN. SUBI AC1,(AC) ;DO SUBI. CAME AC1,AC2 ;C(AC) SHOULD = SIM ANS. ERRI RAN1,(AC) LOOP SUBI2A,SUBI3A ;TEST SUBI. CHECK C(AC) FOR CORRECT DATA. ;RAN TO RAN CONDITION. AC=10 SUBI1B: SETUP 20,0 SUBI2B: RANDOM MOVE RAN1,AC ;SAVE C(AC) IN CASE OF ERROR. SUBI3B: MOVE AC1,AC ;SIMULATE A AND AC1,[XWD -1,0] ;SUBI RAN FROM RAN. SUBI AC,(AC) ;DO SUBI. CAME AC,AC1 ;C(AC) SHOULD = SIM. ANS. ERRI RAN1,(RAN1) LOOP SUBI2B,SUBI3B ;TEST SUBB. CHECK THAT C(AC) = C(E) AND C(AC) ;= CORRECT DATA. ;0 TO RAN. AC=10 SUBB1: SETUP 20,0 SUBB2: RANDOM SUBB3: SETZB AC1,RAN1 ;CLEAR C(E). SUBB AC,AC1 ;DO SUBB..0 FROM RAN = RAN. CAME AC,AC1 ;C(AC) SHOULD = C(E). ERR RAN1,RAN CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERR RAN1,RAN LOOP SUBB2,SUBB3 ;TEST SUBB. CHECK C(AC) = C(E) AND C(AC) FOR ;CORRECT DATA. ;RAN TO 0 CONDITION. AC=10 SUBB1A: SETUP 20,0 SUBB2A: RANDOM SUBB3A: SETZB AC1,RAN1 ;CLEAR C(AC). MOVN AC2,AC ;SIMULATE SUB...RAN FROM 0 = 2'S COMP RAN. SUBB AC1,AC ;DO SUBB. CAME AC1,AC ;C(AC) SHOULD = C(E). EERR ,RAN1 CAME AC1,AC2 ;C(AC) SHOULD = SIM. ANS. EERR ,RAN1 LOOP SUBB2A,SUBB3A ;TEST SUBB. CHECK C(AC) = C(E) AND FOR ;CORRECT DATA IN AC. ;RAN TO RAN CONDITION. AC=10 SUBB1B: SETUP 40,0 SUBB2B: RANDOM SUBB3B: MOVE AC1,AC ;MAKE C(E) = C(AC). SUBB AC,AC1 ;DO SUBB..RAN FROM RAN = 0. CAME AC,AC1 ;C(AC) SHOULD = C(E). EERR ,RAN CAME AC,[0] ;C(AC) SHOULD = 0. EERR ,RAN LOOP SUBB2B,SUBB3B ;TEST MOVEI. CHECK C(AC) FOR CORRECT DATA. ;RAN TO RAN1. AC=2 MVEI1: SETUP 20,0 MVEI2: RANDOM MOVE AC2,RAN ;SAVE RAN IN AN AC. MVEI3: MOVSS RAN1,AC ;MAKE C(AC) = SEC RAN NUM. MOVE AC1,RAN ;SIMULATE LSH AC1,22 ;A LSH AC1,-22 ;MOVEI. MOVEI AC,(AC2) ;DO A MOVEI. CAME AC,AC1 ;C(AC) SHOULD = SIM. ANS. ERRI RAN1,(AC2) LOOP MVEI2,MVEI3 ;TEST MOVN. TWO MOVN INSTRUCTIONS SHOULD NOT CHANGE C(AC). AC=2 MOVN1: SETUP 200,0 MOVN2: RANDOM ;DO 6 X (MOVN RAN TO RAN). MOVN3: REPEAT 3,< MOVN AC,AC MOVN AC,AC> CAME AC,RAN ;C(AC) SHOULD STILL = RAN NUM. ERROR AC,RAN LOOP MOVN2,MOVN3 ;TEST MOVNI. CHECK C(AC) FOR CORRECT DATA. ;RAN TO RAN1. AC=2 MVNI1: SETUP 40,0 MVNI2: RANDOM MOVE AC2,RAN ;SAVE RAN IN AN AC. MVNI3: MOVSS RAN1,AC ;C(AC) = SEC RAN NUM. MOVEI AC1,(AC2) ;SIMULATE SETCA AC1, ;A ADD AC1,[1] ;MOVNI INST. MOVNI AC,(AC2) ;DO A MOVNI. CAME AC,AC1 ;C(AC) SHOULD = SIM. ANS. ERRI RAN1,(AC2) LOOP MVNI2,MVNI3 ;TEST MOVNM. WHERE E IS AN AC. ;CHECK C(E) FOR CORRECT DATA. ;RAN TO RAN. AC=2 MVNM1: SETUP 100,0 MVNM2: RANDOM MOVE RAN1,RAN ;SAVE RAN IN AN AC. MVNM3: MOVE AC1,AC ;MAKE C(E) = C(AC). ;DO 3 X 2(MOVNM). REPEAT 3,< MOVNM AC,AC1 MOVNM AC1,AC> CAME RAN1,AC ;C(E) SHOULD = ORIG C(E). EERRM ,RAN LOOP MVNM2,MVNM3 ;TEST MOVNS. WHERE E IS AN AC. ;CHECK PROPER STORING OF C(E) INTO AC. ;TWO MOVNS = ORIG NUMBER. ;C(E) = RAN. AC=3 MVNS1: SETUP 100,0 MVNS2: RANDOM MOVE AC2,RAN ;PUT C(RAN) INTO AC2 FOR FUTURE COMPARE. MVNS3: SETOB AC1,RAN1 ;MAKE C(AC) = -1. ;DO 3 X 2(MOVNS). REPEAT 3,< MOVNS AC1,AC MOVNS AC1,AC> CAME AC1,AC ;C(AC) SHOULD = C(E). EERRM ,RAN1 CAME AC2,AC ;C(E) SHOULD = ORIG. C(E). EERRM ,RAN1 LOOP MVNS2,MVNS3 ;TEST MOVNS. WHERE E IS AN AC. ;CHECK FOR NOT LOADING C(E) INTO AC WHEN AC= 0. ;TWO MOVNS = ORIGINAL NUM. ;C(E) = RAN. AC=10 MVNSA: SETUP 40,0 MVNSB: RANDOM MOVE AC2,RAN ;SAVE RAN IN AN AC. MVNSC: SETOB RAN1 ;MAKE C(AC) = -1. ;DO 3 X 2(MOVNS). REPEAT 3,< MOVNS AC MOVNS AC> CAMN AC ;C(AC) SHOULD NOT = C(E). EERRM ,RAN1 CAME AC2,AC ;C(AC) SHOULD = ORIG C(AC). EERRM ,RAN1 LOOP MVNSB, MVNSC ;TEST MOVM. CHECK F(AC) FOR CORRECT DATA. ;RAN TO RAN1. AC=7 MVM1: SETUP 40,0 MVM2: RANDOM MVM3: MOVSS RAN1,AC ;C(AC) = SEC RAN NUM. MOVE AC1,RAN ;C(E) = 1ST RAN NUM. SETCM AC2,AC1 ;SIMULATE TLNN AC1,400000 ;A MOVE AC2,AC1 ;MOVM TLNE AC1,400000 ;INST. ADD AC2,[1] MOVM AC,AC1 ;DO A MOVM. CAME AC,AC2 ;C(AC) SHOULD = SIM. ANS. EERR ,RAN1 LOOP MVM2, MVM3 ;TEST MOVMI. CHECK C(AC) FOR CORRECT DATA. ;RAN TO RAN1. AC=10 MVMI1: SETUP 40,0 MVMI2: RANDOM MVMI3: MOVEI AC1,AC ;SIMULATE A MOVMI INST...MOVEI. MOVSS RAN1,AC ;C(AC) = SEC RAN NUM. MOVMI AC,(AC1) ;DO MOVMI. CAME AC,AC1 ;C(AC) SHOULD = SIM ANS. ERRI RAN1,(AC1) LOOP MVMI2, MVMI3 ;TEST MOVMM. CHECK C(AC) + C(E) FOR CORRECT DATA. ;RAN TO RAN1. AC=11 MVMM1: SETUP 200,0 MVMM2: RANDOM MVMM3: MOVSS RAN1,AC ;C(AC) = SEC RAN NUM. MOVE AC1,RAN ;C(E) = RAN. SETCM AC2,AC ;SIMULATE TLNN AC,400000 ;A MOVE AC2,AC ;MOVMM TLNE AC,400000 ;INST ADD AC2,[1] MOVMM AC,AC1 ;DO A MOVMM INST. CAME AC,RAN1 ;C(AC) SHOULD = ORIG C(AC). EERRM ,RAN1 CAME AC1,AC2 ;C(E) SHOULD = SIM. ANS. EERRM ,RAN1 LOOP MVMM2, MVMM3 ;TEST MOVMS. CHECK C(E) FOR CORRECT DATA. ;RAN TO RAN1. AC=10 MVMS1: SETUP 200,0 MVMS2: RANDOM MVMS3: MOVSS RAN1,AC ;C(AC) = SEC RAN NUM. MOVE AC1,RAN ;C(E) = RAN. SETCM AC2,RAN ;SIMULATE TLNN AC1,400000 ;A MOVE AC2,AC1 ;MOVMS TLNE AC1,400000 ;INST. ADD AC2,[1] MOVMS AC,AC1 ;DO A MOVMS. CAME AC,AC1 ;C(AC) SHOULD = C(E). EERRM ,RAN1 CAME AC1,AC2 ;C(E) SHOULD = SIM. ANS. EERRM ,RAN1 LOOP MVMS2, MVMS3 ;TEST LSH. A LSH LEFT AND A LSH RIGHT SHOULD ;GIVE THE SAME NUMBER WITH A ZERO SIGN BIT. AC=2 LSH1P: SETUP 40,0 LSH1PA: RANDOM LSH1PB: AND AC,[XWD 377777,-1] ;SIMULATE A LSH LEFT THEN RIGHT. MOVE AC1,RAN ;MOVE RANDOM NUM INTO AN AC ;AND DO 3(LSH LEFT 1 PLACE THEN RIGHT 1 PLACE). REPEAT 3,< LSH AC1,1 LSH AC1,-1> CAME AC1,AC ;C(AC1) = SIM. ANS? ERROR AC1,AC ;NO. LSH FAILED. LOOP LSH1PA,LSH1PB ;TEST TDN,TDNA. CHECK FOR SKIP/NO SKIP AND ;NO DATA CHANGE IN AC FOR RAN1 TO RAN CONDITION. AC=2 TDN1: SETUP 100,0 TDN2: RANDOM TDN3: MOVS AC1,AC ;PUT SECOND RAN. NUM. INTO "E". TDN AC,AC1 ;NO SKIP, NO DATA CHANGE. JRST .+2 ;HERE..GO AROUND ERR UUO. ER AC,[ASCII /TST/];TDN SKIPPED. TDNA AC,AC1 ;SKIP, NO DATA CHANGE. ER AC,[ASCII /TST/] CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERR AC1,RAN LOOP TDN2,TDN3 ;TEST TDNN,TDNE. CHECK FOR SKIP/ NO SKIP AND ;NO DATA CHANGE IN AC FOR RAN TO 0 CONDITION. AC=3 TDNE1A: SETUP 100,0 TDNE2A: RANDOM TDNE3A: SETZB AC1,RAN1 ;CLEAR C(AC). TDNN AC1,AC ;C(E) + C(AC) =0..NO SKIP. JRST .+2 ER AC1,[ASCII /TST/];TDNN SKIPPED. TDNE AC1,AC ;C(E) + C(AC) = 0. SKIP. ER AC1,[ASCII /TST/] CAME AC1,[0] ;C(AC) SHOULD STILL = 0. ERR AC,RAN1 LOOP TDNE2A,TDNE3A ;TEST TDNN,TDNE. CHECK FOR SKIP/ NO SKIP AND ;NO DATA CHANGE FOR 0 TO RAN CONDITION. AC=4 TDNE1B: SETUP 40,0 TDNE2B: RANDOM TDNE3B: SETZ AC1, ;CLEAR C(E). TDNN AC,AC1 ;C(E) + C(AC) = 0. NO SKIP. JRST .+2 ER AC,[ASCII /TST/];TDNN SKIPPED. TDNE AC,AC1 ;C(E) + C(AC) = 0. SKIP. ER AC,[ASCII /TST/] CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERR AC1,RAN LOOP TDNE2B,TDNE3B ;TEST TDNN,TDNE. CHECK FOR SKIP/ NO SKIP AND ;NO DATA CHANGE IN AC FOR RAN TO -1 CONDITION. AC=5 TDNE1C: SETUP 40,0 TDNE2C: RANDOM JUMPE AC,TDNE2C ;REJECT IF RAN = 0. TDNE3C: SETOB AC1,RAN1 ;SET C(AC) TO ALL ONES. TDNE AC1,AC ;C(E) + C(AC) NOT = 0..NO SKIP. JRST .+2 ER AC1,[ASCII /TST/];TDNE SKIPPED. TDNN AC1,AC ;C(E) + C(AC) NOT = 0..SKIP. ER AC1,[ASCII /TST/] CAME AC1,[-1] ;C(AC) SHOULD = ORIG C(AC). ERR AC,RAN1 LOOP TDNE2C,TDNE3C ;TEST TDNE,TDNN. CHECK FOR SKIP/ NO SKIP AND ;NO DATA CHANGE IN AC FOR -1 TO RAN CONDITION. AC=6 TDNE1D: SETUP 40,0 TDNE2D: RANDOM JUMPE AC,TDNE2D ;REJECT IF RAN = 0. TDNE3D: SETO AC1, ;SET C(E) TO ALL ONES. TDNE AC,AC1 ;C(E) + C(AC) NOT = 0..NO SKIP. JRST .+2 ER AC,[ASCII /TST/];TDNE SKIPPED. TDNN AC,AC1 ;C(E) + C(AC) NOT = 0..SKIP. ER AC,[ASCII /TST/] CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERR AC1,RAN LOOP TDNE2D,TDNE3D ;TEST TDNE,TDNN. CHECK FOR SKIP/ NO SKIP AND ;NO DATA CHANGE IN AC FOR RAN TO RAN CONDITION. AC=7 TDNE1E: SETUP 20,0 TDNE2E: RANDOM JUMPE AC,TDNE2E ;REJECT IF RAN = 0. TDNE3E: MOVE AC1,AC ;MAKE C(E) = C(AC). TDNE AC,AC1 ;C(E) + C(AC) NOT = 0..NO SKIP. JRST .+2 ER AC,[ASCII /TST/];TDNE SKIPPED. TDNN AC,AC1 ;C(E) + C(AC) NOT = 0. SKIP. ER AC,[ASCII /TST/] CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERR AC1,RAN LOOP TDNE2E,TDNE3E ;TEST TDNE,TDNN. CHECK FOR SKIP/ NO SKIP AND ;NO DATA CHANGE IN AC FOR NOT RAN TO RAN CONDITON. AC=10 TDNE1F: SETUP 20,0 TDNE2F: RANDOM TDNE3F: SETCM AC1,AC ;MAKE C(E) = 1'S COMP OF C(AC). TDNN AC,AC1 ;C(E) + C(AC) = 0..NO SKIP. JRST .+2 ER AC,[ASCII /TST/];TDNN SKIPPED. TDNE AC,AC1 ;C(E) + C(AC) = 0..SKIP. ER AC,[ASCII /TST/] CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERR AC1,RAN LOOP TDNE2F,TDNE3F ;TEST TDZ,TDZA. CHECK FOR SKIP/ NO SKIP AND ;CORRECT DATA IN AC FOR NOT RAN TO RAN CONDITION. AC=11 TDZA1: SETUP 100,0 TDZA2: RANDOM TDZA3: SETCM AC1,AC ;MAKE C(E) 1'S COMP OF C(AC). TDZ AC,AC1 ;SHOULD NOT SKIP. JRST .+2 ER AC,[ASCII/TST/] ;TDZ SKIPPED. TDZA AC,AC1 ;SHOULD SKIP. ER AC,[ASCII /TST/] CAME AC,RAN ;C(AC) SHOULD STILL = RAN NUM. ERR AC1,RAN CAMN AC1,RAN ;C(E) SHOULD NOT = RAN. ERR AC1,RAN LOOP TDZA2,TDZA3 ;TEST TDZ,TDZA. CHECK FOR SKIP/NO SKIP AND ;CORRECT DATA IN AC FOR RAN TO RAN CONDITION. AC=10 TDZAA: SETUP 100,1 TDZAB: RANDOM TDZAC: TDZ AC,AC ;SHOULD NOT SKIP. CAME AC,[0] ;SHOULD CLEAR C(AC). EERR ,RAN MOVE AC,RAN ;RESTORE AC. TDZA AC,AC ;SHOULD SKIP. ER AC,[ASCII /TST/] CAME AC,[0] ;C(AC) SHOULD BE CLEARED. EERR ,RAN LOOP TDZAB,TDZAC ;TEST TDZ,TDZA. CHECK FOR SKIP/ NO SKIP AND ;CORRECT DATA IN AC FOR RAN1 TO RAN CONDITION. AC=10 TDZB1: SETUP 100,0 TDZB2: RANDOM TDZB3: MOVS AC1,AC ;MAKE C(E) A DIFF. RAN. NUM. MOVE AC2,AC1 ;SIMULATE XOR AC2,AC ;A AND AC2,AC ;TDZ. TDZ AC,AC1 ;TDZ SHOULD NOT SKIP. CAME AC,AC2 ;C(AC) SHOULD = SIM. ANS. ERR AC1,RAN MOVE AC,RAN ;RESTORE AC. TDZA AC,AC1 ;SHOULD SKIP. ER AC,[ASCII /TST/] CAME AC,AC2 ;C(AC) SHOULD = SIM. ANS. ERR AC1,RAN LOOP TDZB2,TDZB3 ;TEST TDZE, TDZN. CHECK FOR SKIP/NO SKIP AND ;CORRECT DATA IN AC FOR FLOATING ONE IN C(E) AND ;THAT BIT CLEARED IN RANDOM NUM. IN AC. AC=10 TDZE1: SETUP 100,0 MOVEI AC1,1 ;SETUP AC1 TO CONTAIN A MASK BIT. TDZE2: RANDOM ROT AC1,1 ;ROT TO TEST NEXT BIT. TDZE3: ANDCM AC,AC1 ;CLEAR MASK BIT IN AC. MOVE AC2,AC ;SAVE FOR FUTURE COMPARE. TDZN AC,AC1 ;C(E) + C(AC) = 0...NO SKIP. JRST .+2 ER AC,[ASCII /TST/] ;TDZN SKIPPED. TDZE AC,AC1 ;C(E) + C(AC) = 0...SKIP. ER AC,[ASCII /TST/] CAME AC,AC2 ;C(AC) SHOULD = ORIG C(AC). ERR AC1,AC2 LOOP TDZE2,TDZE3 ;TEST TDZE, TDZN. CHECK FOR SKIP/ NO SKIP AND ;CORRECT DATA IN AC FOR FLOATING ONE IN C(E) ;AND THAT BIT SET IN RAN. NUM. IN C(AC). AC=10 TDZEA: SETUP 100,0 MOVEI AC1,1 ;SET MASK BIT IN C(E). TDZEB: RANDOM ROT AC1,1 ;ROT MASK BIT TO TEST NEXT BIT. TDZEC: IOR AC,AC1 ;SET MASK BIT IN AC. MOVE RAN1,AC ;SAVE C(AC) IN CASE OF ERROR. MOVE AC2,AC ;SIMULATE ANDCM AC2,AC1 ;A TDZ. TDZE AC,AC1 ;C(E) + C(AC) NOT = 0...NO SKIP. CAME AC,AC2 ;C(AC) SHOULD = SIM. ANS. ERR AC1,RAN1 IOR AC,AC1 ;RESET MASK BIT IN AC. TDZN AC,AC1 ;C(E) + C(AC) NOT = 0...SKIP. ER AC,[ASCII /TST/] CAME AC,AC2 ;AND C(AC) SHOULD = SIM. ANS. ERR AC1,RAN1 LOOP TDZEB,TDZEC ;TEST TDZE,TDZN. SET AND ROT A MASK BIT IN AC ;AND CHECK SKIP/NO SKIP AND PROPER C(AC) ;FOR MASK BIT IN AC ANS RANDOM NUMBER IN E. AC=10 TDZNA: SETUP 100,0 MOVEI AC1,1 ;SETUP AC1 FOR MASK BIT. TDZNB: RANDOM ROT AC1,1 ;ROT AC1 TO TEST NEXT BIT. MOVE AC2,AC1 ;SAVE MASK BIT. TDZNC: MOVE AC1,AC2 ;RESTORE MASK BIT IF ERROR. ANDCM AC,AC1 ;CLEAR MASK BIT IN RAN NUM. TDZN AC1,AC ;C(E) + C(AC) =0..SHOULDN'T SKIP. JRST .+2 ER AC1,[ASCII /TST/];TDZN SKIPPED. TDZE AC1,AC ;C(E) + C(AC) = 0..SKIP. ER AC1,[ASCII /TST/] CAME AC1,AC2 ;C(AC1) SHOULD NOT HAVE CHANGED. ERR AC,AC2 LOOP TDZNB,TDZNC ;TEST TDZE,TDZN. SET AND ROT A MASK BIT IN AC ;AND CHECK SKIP/NO SKIP AND PROPER C(AC) ;FOR MASK BIT IN AC AND RANDOM NUMBER IN E. ;RANDOM NUMBER HAS MASK BIT SET. AC=10 TDZN1: SETUP 40,0 MOVEI AC1,1 ;SETUP AC1 FOR MASK BIT. TDZN2: RANDOM ROT AC1,1 ;ROT AC1 TO TEST NEXT BIT. TDZN3: MOVE AC2,AC1 ;SAVE MASK BIT. IOR AC,AC1 ;SET MASK BIT IN RAN. TDZE AC1,AC ;C(E) + C(AC) NOT = 0...NO SKIP. CAME AC1,[0] ;C(AC) SHOULD = 0. ERR AC,AC2 MOVE AC1,AC2 ;RESTORE MASK BIT. TDZN AC1,AC ;C(E) + C(AC) NOT = 0...SKIP. ER AC1,[ASCII /TST/] CAME AC1,[0] ;AC1 SHOULD HAVE GOTTEN CLEARED OUT. ERR AC,AC2 MOVE AC1,AC2 ;RESTORE MASK BIT. LOOP TDZN2,TDZN3 ;TEST TDO TDOA. CHECK FOR SKIP/NO SKIP ANS CORRECT DATA ;IN AC FOR RAN TO NOT RAN. AC=10 TDOA1: SETUP 100,0 TDOA2: RANDOM TDOA3: SETCM AC1,AC ;MAKE "C(E)" = COMP OF RAN. TDO AC,AC1 ;SHOULD NOT SKIP. CAME AC,[-1] ;AC SHOULD HAVE ALL BITS SET. ERR AC1,RAN MOVE AC,RAN ;RESTORE AC. TDOA AC,AC1 ;SHOULD SKIP. ER AC,[ASCII /TST/] CAME AC,[-1] ;AC SHOULD HAVE ALL BITS SET. ERR AC1,RAN LOOP TDOA2,TDOA3 ;TEST TDO,TDOA. CHECK SKIP/NO SKIP AND ;CORRECT DATA IN AC FOR RAN TO RAN CONDITION. AC=2 TDOAA: SETUP 40,0 TDOAB: RANDOM TDOAC: TDO AC,AC ;SHOULD NOT SKIP. JRST .+2 ER AC,[ASCII /TST/] ;TDO SKIPPED. TDOA AC,AC ;SHOULD SKIP. ER AC,[ASCII /TST/] CAME AC,RAN ;C(AC) SHOULD NOT HAVE CHANGED. EERR ,RAN LOOP TDOAB,TDOAC ;TEST TDO, TDOA. CHECK FOR SKIP/NO SKIP ;AND CORRECT DATA IN AC FOR RAN1 TO RAN CONDITION. AC=2 TDOB1: SETUP 400,3 TDOB2: RANDOM TDOB3: MOVS AC1,AC ;MAKE AC1 ANOTHER RAN NUM. MOVE AC2,AC ;SIMULATE XOR AC2,AC1 ;A IOR AC2,AC ;TDO INST. TDO AC,AC1 ;SHOULD NOT SKIP. CAME AC,AC2 ;C(AC) = SIM. ANS? ERR AC1,RAN ;NO. MOVE AC,RAN ;RESTORE AC. TDOA AC,AC1 ;SHOULD SKIP. ER AC,[ASCII /TST/] CAME AC,AC2 ;C(AC) = SIM ANS? ERR AC1,RAN ;NO. LOOP TDOB2,TDOB3 ;TEST TDOE,TDON. ROT A MASK BIT IN E AND SET THAT ;BIT IN AC BEFORE TDO. CHECK FOR SKIP/NO SKIP ;AND PROPER DATA IN AC. AC=2 TDOE1: SETUP 40,0 MOVEI AC1,1 ;SETUP A MASK BIT IN "E". TDOE2: RANDOM ROT AC1, ;ROT MASK BIT TO TEST NEXT BIT. TDOE3: IOR AC,AC1 ;SET MASK BIT IN AC. MOVE AC2,AC ;SAVE AC IN AC2. TDOE AC,AC1 ;C(E) + C(AC) NOT = 0. NO SKIP. JRST .+2 ER AC,[ASCII /TST/];TDOE SKIPPED. TDON AC,AC1 ;C(E) + C(AC) NOT = 0..SKIP. ER AC,[ASCII /TST/] CAME AC,AC2 ;C(AC) SHOULD NOT CHANGE. ERR AC1,AC2 LOOP TDOE2,TDOE3 ;TEST TDOE,TDON. ROT A MASK BIT IN E AND CLEAR THAT ;BIT IN AC BEFORE TDO. CHECK FOR SKIP/NO SKIP ;AND PROPER DATA IN AC. AC=3 TDOEA: SETUP 40,0 MOVEI AC1,1 ;SETUP MASK BIT IN"E". TDOEB: RANDOM ROT AC1,1 ;ROT MASK BIT TO TEST NEXT BIT. TDOEC: ANDCM AC,AC1 ;CLEAR MASK BIT IN AC. MOVE RAN1,AC ;SAVE AC. MOVE AC2,AC ;SIMULATE IOR AC2,AC1 ;A TDO. TDOE AC,AC1 ;C(E) + C(AC) = 0. SKIP. ER AC,[ASCII /TST/] CAME AC,AC2 ;C(AC) = SIM ANS? ERR AC1,RAN1 ;NO. MOVE AC,RAN1 ;RESTORE AC. TDON AC,AC1 ;C(E) + C(AC) = 0..NO SKIP. CAME AC,AC2 ;C(AC) = SIM. ANS? ERR AC1,RAN1 ;NO. LOOP TDOEB,TDOEC ;TEST TDOE,TDON. ROT A MASK BIT IN AC AND CLEAR THAT ;BIT IN E BEFORE TDO. CHECK FOR SKIP/NO SKIP ;AND PROPER DATA IN AC. AC=4 TDONA: SETUP 40,0 MOVEI AC1,1 ;SETUP A MASK BIT IN AC. TDONB: RANDOM ROT AC1,1 ;ROT BIT TO TEST NEXT BIT. MOVE AC2,AC1 ;SAVE MASK BIT SO IN CASE TDONC: MOVE AC1,AC2 ;OF ERROR IT CAN BE RESTORED. ANDCM AC,AC1 ;CLEAR MASK BIT IN E. JUMPE AC,TDONB ;REJECT IF C(AC) = 0. MOVE AC3,AC ;SIMULATE IOR AC3,AC1 ;TDO. TDOE AC1,AC ;C(E) + C(AC) = 0...SKIP. ER AC1,[ASCII /TST/];TDOE DID NOT SKIP. CAME AC1,AC3 ;C(AC) SHOULD = SIM. ANS. ERR AC,AC2 TDON AC1,AC ;C(E) + C(AC) NOT = 0...SKIP. ER AC1,[ASCII /TST/] CAME AC1,AC3 ;C(AC) SHOULD = SIM. ANS. ERR AC,AC2 MOVE AC1,AC2 ;RESTORE AC. LOOP TDONB,TDONC ;TEST TDOE,TDON. ROT A MASK BIT IN AC AND SET ;THAT BIT IN E BEFORE TDO. CHECK FOR SKIP/ NO SKIP ;AND CORRECT DATA IN AC. AC=5 TDON1: SETUP 40,0 MOVEI AC1,1 ;SETUP AC TO CONTAIN A MASK BIT. TDON2: RANDOM ROT AC1,1 ;ROT TO TEST NEXT BIT. MOVE AC2,AC1 ;SAVE C(AC) SO IT CAN BE TDON3: MOVE AC1,AC2 ;RESTORED IN CASE OF ERROR. IOR AC,AC1 ;SET MASK BIT IN E. TDOE AC1,AC ;C(E) + C(AC) NOT = 0...NO SKIP. JRST .+2 ER AC1,[ASCII /TST/];TDOE SKIPPED. TDON AC1,AC ;C(E) + C(AC) NOT = 0...SKIP. ER AC1,[ASCII /TST/] CAME AC1,AC ;C(AC) SHOULD = C(E). ERR AC,AC2 MOVE AC1,AC2 ;RESTORE AC. LOOP TDON2,TDON3 ;TEST TDC. CHECK FOR SKIP/NO SKIP AND CORRECT ;DATA FOR NOT RAN TO RAN CONDITION. AC=6 TDC1: SETUP 100,0 TDC2: RANDOM TDC3: SETCM AC1,RAN ;MAKE C("E") = COMP. OF RAN. TDC AC,AC1 ;NO SKIP. CAME AC,[-1] ;C(AC) SHOULD = A -1. ERR AC1,RAN SETO RAN1, ;SET RAN1 FOR ERROR MESSAGE. TDC AC,AC1 ;NO SKIP. CAME AC,RAN ;C(AC) SHOULD = RAN AGAIN. ERR AC1,RAN1 LOOP TDC2,TDC3 ;TEST TDCA. CHECKING FOR SKIP/ NO SKIP AND ;CORRECT DATA IN AC FOR NOT RAN TO RAN CONDITION. AC=10 TDCA1: SETUP 100,0 TDCA2: RANDOM TDCA3: SETCM AC1,RAN ;MAKE C("E") = COMP OF RAN. TDC AC,AC1 ;SHOULD NOT SKIP. JRST .+2 ER AC,[ASCII /TST/];TDC SKIPPED. TDCA AC,AC1 ;SHOULD SKIP. ER AC,[ASCII /TST/] CAME AC,RAN ;TWO TDC'S SHOULD RETURN C(AC) ;TO IT'S ORIGINAL VALUE. ERR AC1,RAN LOOP TDCA2,TDCA3 ;TEST TDCE. CHECKING FOR SKIP/NO SKIP AND ;CORRECT DATA IN AC FOR RAN TO 0 CONDITION. AC=11 TDCE1: SETUP 100,0 TDCE2: RANDOM TDCE3: SETZB AC1,RAN1 ;CLEAR BOTH AC AND RAN1. TDCE AC1,AC ;C(E) + C(AC) = 0. SKIP. ER AC1,[ASCII /TST/] CAME AC1,RAN ;C(AC) SHOULD = RAN. EERR ,RAN1 LOOP TDCE2,TDCE3 ;TEST TDCE,TDCN. CHECKING FOR SKIP/NO SKIP AND ;CORRECT DATA IN AC FOR 0 TO RAN CONDITION. AC=11 TDCEA: SETUP 100,0 TDCEB: RANDOM TDCEC: SETZ AC1, ;CLEAR C(E). TDCN AC,AC1 ;C(E) + C(AC) = 0...NO SKIP. JRST .+2 ER AC,[ASCII /TST/];TDCN SKIPPED. TDCE AC,AC1 ;C(E) + C(AC) = 0. SKIP. ER AC,[ASCII /TST/] CAME AC,RAN ;C(AC) SHOULD STILL = RAN. ERR AC1,RAN LOOP TDCEB,TDCEC ;TEST TDCE. CHECKING FOR SKIP/NO SKIP AND ;CORRECT DATA IN AC FOR RAN TO -1 CONDITION. AC=10 TDCE4: SETUP 100,0 TDCE5: RANDOM JUMPE AC,TDCE5 ;REJECT IF RAN = 0. TDCE6: SETOB AC1,RAN1 ;SET C(AC) TO ALL ONES. SETCM AC2,AC ;SIMULATE A TDC. TDCE AC1,AC ;C(E) + C(AC) NOT = 0. NO SKIP. CAME AC1,AC2 ;C(AC) = SIM.. ANS? ERR AC,RAN1 ;NO. LOOP TDCE5,TDCE6 ;TEST TDCE,TDCN. CHECKING FOR SKIP/NO SKIP AND ;CORRECT DATA IN AC FOR -1 TO RAN CONDITION. AC=10 TDCED: SETUP 100,0 TDCEE: RANDOM JUMPE AC,TDCEE ;REJECT IF RAN = 0. CAMN AC,[-1] ;C(AC) = -1? JRST TDCEE ;YES. REJECT. TDCEF: SETOB AC1,RAN1 ;SET C(E) TO ALL ONES. TDCE AC,AC1 ;C(E) + C(AC) NOT = 0. NO SKIP. JRST .+2 ER AC,[ASCII /TST/];TDCE SKIPPED. TDCN AC,AC1 ;C(E) + C(AC) NOT = 0..SKIP. ER AC,[ASCII /TST/] CAME AC,RAN ;C(AC) SHOULD = ORIG C(AC). ERR RAN1,RAN LOOP TDCEE,TDCEF ;TEST TDCE. CHECKING FOR SKIP/NO SKIP AND ;CORRECT DATA IN AC FOR RAN TO RAN CONDITION. AC=10 TDCE7: SETUP 100,0 TDCE8: RANDOM JUMPE AC,TDCE8 ;REJECT IF RAN = 0. TDCE9: MOVE AC1,RAN ;MAKE C("AC") = C("E"). TDCE AC1,AC ;C(E) + C(AC) NOT = 0. NO SKIP. CAME AC1,[0] ;C(AC) SHOULD = 0. ERR AC,AC LOOP TDCE8,TDCE9 ;TEST TDCE. CHECKING FOR SKIP/NO SKIP AND ;CORRECT DATA IN AC FOR RAN TO NOT RAN. AC=10 TDCEG: SETUP 100,0 TDCEH: RANDOM TDCEI: SETCM AC1,AC ;MAKE C("AC") = TO COMP OF RAN. MOVE RAN1,AC1 ;SAVE C(AC) IN CASE OF ERROR. TDCE AC1,AC ;C(E) + C(AC) = 0. SKIP. ER AC1,[ASCII /TST/] CAME AC1,[-1] ;C(AC) SHOULD = -1. ERR AC,RAN1 LOOP TDCEH,TDCEI JRST BEGEND ;REPEAT TEST