2310 lines
52 KiB
Text
2310 lines
52 KiB
Text
;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=<AC+1>&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=<AC+1>&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=<AC+1>&17
|
|
AC1=<AC+1>&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=<AC+1>&17
|
|
AC1=<AC+1>&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=<AC+1>&17
|
|
AC1=<AC+1>&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=<AC+1>&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=<AC+1>&17
|
|
AC1=<AC+1>&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=<AC+1>&17
|
|
AC1=<AC+1>&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=<AC+1>&17
|
|
AC1=<AC+1>&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=<AC+1>&17
|
|
AC1=<AC+1>&17
|
|
AC2=<AC+2>&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 <MOVEM AC,AC1> FOLLOWED BY
|
|
;<MOVEM AC1,AC>, 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
|
|
|