diff --git a/MASH-0_1-0_M-Unit_Test_140923.KID b/MASH_1P4.KID
similarity index 55%
rename from MASH-0_1-0_M-Unit_Test_140923.KID
rename to MASH_1P4.KID
index 364d2d2..2c0ef4f 100644
--- a/MASH-0_1-0_M-Unit_Test_140923.KID
+++ b/MASH_1P4.KID
@@ -1,181 +1,199 @@
-KIDS Distribution saved on Sep 23, 2014@08:59:41
-TRY 4
-**KIDS**:MASH*0.1*0^
+KIDS Distribution saved on Feb 27, 2016@13:57:55
+T6 
+**KIDS**:MASH 1.4^
 
 **INSTALL NAME**
-MASH*0.1*0
-"BLD",8938,0)
-MASH*0.1*0^MASH UTILITIES^0^3140923^y
-"BLD",8938,1,0)
-^^2^2^3140829^
-"BLD",8938,1,1,0)
-M-Unit Test functionality to provide basic unit testing framework for M 
-"BLD",8938,1,2,0)
-development.
-"BLD",8938,4,0)
+MASH 1.4
+"BLD",8966,0)
+MASH 1.4^MASH UTILITIES^0^3160227^n
+"BLD",8966,1,0)
+^^5^5^3160227^
+"BLD",8966,1,1,0)
+Updated version of the open source M Advanced Shell (MASH) package.  
+"BLD",8966,1,2,0)
+This version includes the M-Unit testing functionality and adds 
+"BLD",8966,1,3,0)
+the capability of performing coverage analysis in Intersystems Cache 
+"BLD",8966,1,4,0)
+systems to the previous ability to perform such analyses in GT.M 
+"BLD",8966,1,5,0)
+systems.
+"BLD",8966,4,0)
 ^9.64PA^17.9001^1
-"BLD",8938,4,17.9001,0)
+"BLD",8966,4,17.9001,0)
 17.9001
-"BLD",8938,4,17.9001,222)
-y^y^f^^n^^y^o^n
-"BLD",8938,4,"B",17.9001,17.9001)
+"BLD",8966,4,17.9001,222)
+y^y^f^^n^^y^m^n
+"BLD",8966,4,"B",17.9001,17.9001)
 
-"BLD",8938,6.3)
-4
-"BLD",8938,"ABPKG")
+"BLD",8966,6.3)
+6
+"BLD",8966,"ABPKG")
 n
-"BLD",8938,"INI")
+"BLD",8966,"INI")
 ZZUTPRE
-"BLD",8938,"INID")
+"BLD",8966,"INID")
 ^n^n
-"BLD",8938,"INIT")
+"BLD",8966,"INIT")
 ZZUTPOST
-"BLD",8938,"KRN",0)
-^9.67PA^8989.52^19
-"BLD",8938,"KRN",.4,0)
+"BLD",8966,"KRN",0)
+^9.67PA^779.2^20
+"BLD",8966,"KRN",.4,0)
 .4
-"BLD",8938,"KRN",.401,0)
+"BLD",8966,"KRN",.401,0)
 .401
-"BLD",8938,"KRN",.402,0)
+"BLD",8966,"KRN",.402,0)
 .402
-"BLD",8938,"KRN",.403,0)
+"BLD",8966,"KRN",.403,0)
 .403
-"BLD",8938,"KRN",.5,0)
+"BLD",8966,"KRN",.5,0)
 .5
-"BLD",8938,"KRN",.84,0)
+"BLD",8966,"KRN",.84,0)
 .84
-"BLD",8938,"KRN",3.6,0)
+"BLD",8966,"KRN",3.6,0)
 3.6
-"BLD",8938,"KRN",3.8,0)
+"BLD",8966,"KRN",3.8,0)
 3.8
-"BLD",8938,"KRN",9.2,0)
+"BLD",8966,"KRN",9.2,0)
 9.2
-"BLD",8938,"KRN",9.8,0)
+"BLD",8966,"KRN",9.8,0)
 9.8
-"BLD",8938,"KRN",9.8,"NM",0)
-^9.68A^9^9
-"BLD",8938,"KRN",9.8,"NM",1,0)
-ut^^0^B257937062
-"BLD",8938,"KRN",9.8,"NM",2,0)
-ut1^^0^B87092328
-"BLD",8938,"KRN",9.8,"NM",3,0)
-utt1^^0^B25860592
-"BLD",8938,"KRN",9.8,"NM",4,0)
-utt2^^0^B473823
-"BLD",8938,"KRN",9.8,"NM",5,0)
-utt3^^0^B1493136
-"BLD",8938,"KRN",9.8,"NM",6,0)
-utt4^^0^B1419637
-"BLD",8938,"KRN",9.8,"NM",7,0)
-utt5^^0^B22421637
-"BLD",8938,"KRN",9.8,"NM",8,0)
-utt6^^0^B29243478
-"BLD",8938,"KRN",9.8,"NM",9,0)
-uttcovr^^0^B2835727
-"BLD",8938,"KRN",9.8,"NM","B","ut",1)
+"BLD",8966,"KRN",9.8,"NM",0)
+^9.68A^10^10
+"BLD",8966,"KRN",9.8,"NM",1,0)
+ut^^0^B249153555
+"BLD",8966,"KRN",9.8,"NM",2,0)
+ut1^^0^B226313375
+"BLD",8966,"KRN",9.8,"NM",3,0)
+utcover^^0^B52893402
+"BLD",8966,"KRN",9.8,"NM",4,0)
+utt1^^0^B40989891
+"BLD",8966,"KRN",9.8,"NM",5,0)
+utt2^^0^B501728
+"BLD",8966,"KRN",9.8,"NM",6,0)
+utt3^^0^B1628564
+"BLD",8966,"KRN",9.8,"NM",7,0)
+utt4^^0^B1568129
+"BLD",8966,"KRN",9.8,"NM",8,0)
+utt5^^0^B23054235
+"BLD",8966,"KRN",9.8,"NM",9,0)
+utt6^^0^B39118749
+"BLD",8966,"KRN",9.8,"NM",10,0)
+uttcovr^^0^B186023122
+"BLD",8966,"KRN",9.8,"NM","B","ut",1)
 
-"BLD",8938,"KRN",9.8,"NM","B","ut1",2)
+"BLD",8966,"KRN",9.8,"NM","B","ut1",2)
 
-"BLD",8938,"KRN",9.8,"NM","B","utt1",3)
+"BLD",8966,"KRN",9.8,"NM","B","utcover",3)
 
-"BLD",8938,"KRN",9.8,"NM","B","utt2",4)
+"BLD",8966,"KRN",9.8,"NM","B","utt1",4)
 
-"BLD",8938,"KRN",9.8,"NM","B","utt3",5)
+"BLD",8966,"KRN",9.8,"NM","B","utt2",5)
 
-"BLD",8938,"KRN",9.8,"NM","B","utt4",6)
+"BLD",8966,"KRN",9.8,"NM","B","utt3",6)
 
-"BLD",8938,"KRN",9.8,"NM","B","utt5",7)
+"BLD",8966,"KRN",9.8,"NM","B","utt4",7)
 
-"BLD",8938,"KRN",9.8,"NM","B","utt6",8)
+"BLD",8966,"KRN",9.8,"NM","B","utt5",8)
 
-"BLD",8938,"KRN",9.8,"NM","B","uttcovr",9)
+"BLD",8966,"KRN",9.8,"NM","B","utt6",9)
 
-"BLD",8938,"KRN",19,0)
+"BLD",8966,"KRN",9.8,"NM","B","uttcovr",10)
+
+"BLD",8966,"KRN",19,0)
 19
-"BLD",8938,"KRN",19,"NM",0)
+"BLD",8966,"KRN",19,"NM",0)
 ^9.68A^3^3
-"BLD",8938,"KRN",19,"NM",1,0)
+"BLD",8966,"KRN",19,"NM",1,0)
 utMUNIT^^0
-"BLD",8938,"KRN",19,"NM",2,0)
+"BLD",8966,"KRN",19,"NM",2,0)
 utMUNIT GROUP EDIT^^0
-"BLD",8938,"KRN",19,"NM",3,0)
+"BLD",8966,"KRN",19,"NM",3,0)
 utMUNIT GROUP RUN^^0
-"BLD",8938,"KRN",19,"NM","B","utMUNIT",1)
+"BLD",8966,"KRN",19,"NM","B","utMUNIT",1)
 
-"BLD",8938,"KRN",19,"NM","B","utMUNIT GROUP EDIT",2)
+"BLD",8966,"KRN",19,"NM","B","utMUNIT GROUP EDIT",2)
 
-"BLD",8938,"KRN",19,"NM","B","utMUNIT GROUP RUN",3)
+"BLD",8966,"KRN",19,"NM","B","utMUNIT GROUP RUN",3)
 
-"BLD",8938,"KRN",19.1,0)
+"BLD",8966,"KRN",19.1,0)
 19.1
-"BLD",8938,"KRN",101,0)
+"BLD",8966,"KRN",101,0)
 101
-"BLD",8938,"KRN",409.61,0)
+"BLD",8966,"KRN",409.61,0)
 409.61
-"BLD",8938,"KRN",771,0)
+"BLD",8966,"KRN",771,0)
 771
-"BLD",8938,"KRN",870,0)
+"BLD",8966,"KRN",779.2,0)
+779.2
+"BLD",8966,"KRN",870,0)
 870
-"BLD",8938,"KRN",8989.51,0)
+"BLD",8966,"KRN",8989.51,0)
 8989.51
-"BLD",8938,"KRN",8989.52,0)
+"BLD",8966,"KRN",8989.52,0)
 8989.52
-"BLD",8938,"KRN",8994,0)
+"BLD",8966,"KRN",8994,0)
 8994
-"BLD",8938,"KRN",8994,"NM",0)
+"BLD",8966,"KRN",8994,"NM",0)
 ^9.68A^3^3
-"BLD",8938,"KRN",8994,"NM",1,0)
+"BLD",8966,"KRN",8994,"NM",1,0)
 utMUNIT-TEST GROUP LOAD^^0
-"BLD",8938,"KRN",8994,"NM",2,0)
+"BLD",8966,"KRN",8994,"NM",2,0)
 utMUNIT-TEST LOAD^^0
-"BLD",8938,"KRN",8994,"NM",3,0)
+"BLD",8966,"KRN",8994,"NM",3,0)
 utMUNIT-TEST NEXT^^0
-"BLD",8938,"KRN",8994,"NM","B","utMUNIT-TEST GROUP LOAD",1)
+"BLD",8966,"KRN",8994,"NM","B","utMUNIT-TEST GROUP LOAD",1)
 
-"BLD",8938,"KRN",8994,"NM","B","utMUNIT-TEST LOAD",2)
+"BLD",8966,"KRN",8994,"NM","B","utMUNIT-TEST LOAD",2)
 
-"BLD",8938,"KRN",8994,"NM","B","utMUNIT-TEST NEXT",3)
+"BLD",8966,"KRN",8994,"NM","B","utMUNIT-TEST NEXT",3)
 
-"BLD",8938,"KRN","B",.4,.4)
+"BLD",8966,"KRN","B",.4,.4)
 
-"BLD",8938,"KRN","B",.401,.401)
+"BLD",8966,"KRN","B",.401,.401)
 
-"BLD",8938,"KRN","B",.402,.402)
+"BLD",8966,"KRN","B",.402,.402)
 
-"BLD",8938,"KRN","B",.403,.403)
+"BLD",8966,"KRN","B",.403,.403)
 
-"BLD",8938,"KRN","B",.5,.5)
+"BLD",8966,"KRN","B",.5,.5)
 
-"BLD",8938,"KRN","B",.84,.84)
+"BLD",8966,"KRN","B",.84,.84)
 
-"BLD",8938,"KRN","B",3.6,3.6)
+"BLD",8966,"KRN","B",3.6,3.6)
 
-"BLD",8938,"KRN","B",3.8,3.8)
+"BLD",8966,"KRN","B",3.8,3.8)
 
-"BLD",8938,"KRN","B",9.2,9.2)
+"BLD",8966,"KRN","B",9.2,9.2)
 
-"BLD",8938,"KRN","B",9.8,9.8)
+"BLD",8966,"KRN","B",9.8,9.8)
 
-"BLD",8938,"KRN","B",19,19)
+"BLD",8966,"KRN","B",19,19)
 
-"BLD",8938,"KRN","B",19.1,19.1)
+"BLD",8966,"KRN","B",19.1,19.1)
 
-"BLD",8938,"KRN","B",101,101)
+"BLD",8966,"KRN","B",101,101)
 
-"BLD",8938,"KRN","B",409.61,409.61)
+"BLD",8966,"KRN","B",409.61,409.61)
 
-"BLD",8938,"KRN","B",771,771)
+"BLD",8966,"KRN","B",771,771)
 
-"BLD",8938,"KRN","B",870,870)
+"BLD",8966,"KRN","B",779.2,779.2)
 
-"BLD",8938,"KRN","B",8989.51,8989.51)
+"BLD",8966,"KRN","B",870,870)
 
-"BLD",8938,"KRN","B",8989.52,8989.52)
+"BLD",8966,"KRN","B",8989.51,8989.51)
 
-"BLD",8938,"KRN","B",8994,8994)
+"BLD",8966,"KRN","B",8989.52,8989.52)
 
-"BLD",8938,"QUES",0)
+"BLD",8966,"KRN","B",8994,8994)
+
+"BLD",8966,"QDEF")
+^^^^NO^^^^NO^^NO
+"BLD",8966,"QUES",0)
 ^9.62^^
+"BLD",8966,"REQB",0)
+^9.611^^
 "DATA",17.9001,1,0)
 TESTS FOR UNIT TEST ROUTINES
 "DATA",17.9001,1,1,0)
@@ -190,6 +208,16 @@ TESTS FOR UNIT TEST ROUTINES
 %utt4
 "DATA",17.9001,1,1,5,0)
 %utt5
+"DATA",17.9001,1,2,0)
+^^4^4^3141008^
+"DATA",17.9001,1,2,1,0)
+This group will run all of the unit tests associated with the M-Unit
+"DATA",17.9001,1,2,2,0)
+code.  In addition, the routine %utt6 should be run as a regular routine
+"DATA",17.9001,1,2,3,0)
+from the top, and it will run all of the unit tests and,if on a G.TM
+"DATA",17.9001,1,2,4,0)
+system will run coverage analysis as well.
 "FIA",17.9001)
 M-UNIT TEST GROUP
 "FIA",17.9001,0)
@@ -197,7 +225,7 @@ M-UNIT TEST GROUP
 "FIA",17.9001,0,0)
 17.9001
 "FIA",17.9001,0,1)
-y^y^f^^n^^y^o^n
+y^y^f^^n^^y^m^n
 "FIA",17.9001,0,10)
 
 "FIA",17.9001,0,11)
@@ -205,7 +233,7 @@ y^y^f^^n^^y^o^n
 "FIA",17.9001,0,"RLRO")
 
 "FIA",17.9001,0,"VR")
-0.1^MASH
+1.4^MASH
 "FIA",17.9001,17.9001)
 0
 "FIA",17.9001,17.90011)
@@ -216,77 +244,77 @@ y^y^f^^n^^y^o^n
 ZZUTPRE
 "INIT")
 ZZUTPOST
-"KRN",19,11790,-1)
+"KRN",19,11758,-1)
 0^1
-"KRN",19,11790,0)
+"KRN",19,11758,0)
 utMUNIT^M-Unit Tester^^B^^^^^^^^
-"KRN",19,11790,1,0)
+"KRN",19,11758,1,0)
 ^^1^1^3140805^
-"KRN",19,11790,1,1,0)
+"KRN",19,11758,1,1,0)
 This is the context option for M-Unit Test functionality.
-"KRN",19,11790,"RPC",0)
+"KRN",19,11758,"RPC",0)
 ^19.05P^3^3
-"KRN",19,11790,"RPC",1,0)
+"KRN",19,11758,"RPC",1,0)
 utMUNIT-TEST GROUP LOAD
-"KRN",19,11790,"RPC",2,0)
+"KRN",19,11758,"RPC",2,0)
 utMUNIT-TEST LOAD
-"KRN",19,11790,"RPC",3,0)
+"KRN",19,11758,"RPC",3,0)
 utMUNIT-TEST NEXT
-"KRN",19,11790,"U")
+"KRN",19,11758,"U")
 M-UNIT TESTER
-"KRN",19,11791,-1)
+"KRN",19,11759,-1)
 0^2
-"KRN",19,11791,0)
+"KRN",19,11759,0)
 utMUNIT GROUP EDIT^M-Unit Test Group Edit^^E^^^^^^^^TOOLKIT
-"KRN",19,11791,1,0)
+"KRN",19,11759,1,0)
 ^19.06^6^6^3031030^^^
-"KRN",19,11791,1,1,0)
+"KRN",19,11759,1,1,0)
 This option can be used to maintain a listing of unit tests related to a 
-"KRN",19,11791,1,2,0)
+"KRN",19,11759,1,2,0)
 specific topic.  The Group identifies the topic, and the unit tests 
-"KRN",19,11791,1,3,0)
+"KRN",19,11759,1,3,0)
 related to that topic are added in the multiple.  Unit Tests can be run 
-"KRN",19,11791,1,4,0)
+"KRN",19,11759,1,4,0)
 by selecting a group, and all unit tests included in the multiple will be 
-"KRN",19,11791,1,5,0)
+"KRN",19,11759,1,5,0)
 used for the test.  In addition, any other references under the XTROU tag 
-"KRN",19,11791,1,6,0)
+"KRN",19,11759,1,6,0)
 in any of the included test routines will be included in the run.
-"KRN",19,11791,30)
+"KRN",19,11759,30)
 %ut(17.9001,
-"KRN",19,11791,31)
+"KRN",19,11759,31)
 AEMQL
-"KRN",19,11791,50)
+"KRN",19,11759,50)
 17.9001
-"KRN",19,11791,51)
+"KRN",19,11759,51)
 .01;1
-"KRN",19,11791,"U")
+"KRN",19,11759,"U")
 M-UNIT TEST GROUP EDIT
-"KRN",19,11792,-1)
+"KRN",19,11760,-1)
 0^3
-"KRN",19,11792,0)
+"KRN",19,11760,0)
 utMUNIT GROUP RUN^Run M-Unit Tests From Test Groups^^R^^^^^^^^TOOLKIT
-"KRN",19,11792,1,0)
+"KRN",19,11760,1,0)
 ^^2^2^3031030^
-"KRN",19,11792,1,1,0)
+"KRN",19,11760,1,1,0)
 Provides a means of initiating a unit test run from the menu system based 
-"KRN",19,11792,1,2,0)
+"KRN",19,11760,1,2,0)
 on entries in the M-UNIT TEST GROUP file (#17.9001).
-"KRN",19,11792,25)
+"KRN",19,11760,25)
 PICKSET^%ut
-"KRN",19,11792,"U")
+"KRN",19,11760,"U")
 RUN M-UNIT TESTS FROM TEST GRO
-"KRN",8994,2928,-1)
+"KRN",8994,2927,-1)
 0^1
-"KRN",8994,2928,0)
+"KRN",8994,2927,0)
 utMUNIT-TEST GROUP LOAD^GUISET^%ut^4^^^^1
-"KRN",8994,2929,-1)
+"KRN",8994,2928,-1)
 0^2
-"KRN",8994,2929,0)
+"KRN",8994,2928,0)
 utMUNIT-TEST LOAD^GUILOAD^%ut^4^^^^1
-"KRN",8994,2930,-1)
+"KRN",8994,2929,-1)
 0^3
-"KRN",8994,2930,0)
+"KRN",8994,2929,0)
 utMUNIT-TEST NEXT^GUINEXT^%ut^4^^^^1
 "MBREQ")
 0
@@ -298,24 +326,30 @@ REMOTE PROCEDURE
 19;18;;;OPT^XPDTA;OPTF1^XPDIA;OPTE1^XPDIA;OPTF2^XPDIA;;OPTDEL^XPDIA
 "ORD",18,19,0)
 OPTION
-"PKG",219,-1)
+"PKG",218,-1)
 1^1
-"PKG",219,0)
+"PKG",218,0)
 MASH UTILITIES^%u^Utilities associated with the M Advanced Shell
-"PKG",219,20,0)
+"PKG",218,20,0)
 ^9.402P^^
-"PKG",219,22,0)
+"PKG",218,22,0)
 ^9.49I^1^1
-"PKG",219,22,1,0)
-0.1
-"PKG",219,22,1,"PAH",1,0)
-0^3140923^173
-"PKG",219,22,1,"PAH",1,1,0)
-^^2^2^3140923
-"PKG",219,22,1,"PAH",1,1,1,0)
-M-Unit Test functionality to provide basic unit testing framework for M 
-"PKG",219,22,1,"PAH",1,1,2,0)
-development.
+"PKG",218,22,1,0)
+1.4^3160227
+"PKG",218,22,1,1,0)
+^^5^5^3160227
+"PKG",218,22,1,1,1,0)
+Updated version of the open source M Advanced Shell (MASH) package.  
+"PKG",218,22,1,1,2,0)
+This version includes the M-Unit testing functionality and adds 
+"PKG",218,22,1,1,3,0)
+the capability of performing coverage analysis in Intersystems Cache 
+"PKG",218,22,1,1,4,0)
+systems to the previous ability to perform such analyses in GT.M 
+"PKG",218,22,1,1,5,0)
+systems.
+"PKG",218,"VERSION")
+1.4
 "QUES","XPF1",0)
 Y
 "QUES","XPF1","??")
@@ -387,1405 +421,1331 @@ NO
 "QUES","XPZ2","M")
 D XPZ2^XPDIQ
 "RTN")
-11
+12
 "RTN","ZZUTPOST")
-0^^B30449799
+0^^B16212231
 "RTN","ZZUTPOST",1,0)
-ut01POST ;VEN-SMH/JLI - post install for M-Unit Test software ;08/28/14  12:29
+%utPOST ;VEN-SMH/JLI - post install for M-Unit Test software ;09/14/15  12:39
 "RTN","ZZUTPOST",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","ZZUTPOST",3,0)
- N X,I
+ ; Submitted to OSEHRA Sep 14, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","ZZUTPOST",4,0)
- I +$SY=47 D  R X:$G(DTIME,300) D MES^XPDUTL(" ")
+ ; Original routine authored by Sam H. Habiel 07/2013-04/2014
 "RTN","ZZUTPOST",5,0)
- . S X(1)=" "
+ ; Additions and modifications made by Joel L. Ivey 05/2014-08/2015
 "RTN","ZZUTPOST",6,0)
- . S X(2)="In the next section, as it tries to copy the ut* routines"
+ ;
 "RTN","ZZUTPOST",7,0)
- . S X(3)="to %ut* routines watch for text that indicates the following:"
+ N X,I
 "RTN","ZZUTPOST",8,0)
- . S X(4)=" "
-"RTN","ZZUTPOST",9,0)
- . S X(5)="cp: cannot create regular file `/_ut.m': Permission denied"
-"RTN","ZZUTPOST",10,0)
- . S X(6)=" "
-"RTN","ZZUTPOST",11,0)
- . S X(7)="If this is seen, respond Yes at the prompt after the attempt:"
-"RTN","ZZUTPOST",12,0)
- . S X(8)="   Press ENTER to continue: "
-"RTN","ZZUTPOST",13,0)
- . F I=1:1:18 D MES^XPDUTL(" ") ; create a blank screen for text
-"RTN","ZZUTPOST",14,0)
- . D MES^XPDUTL(.X)
-"RTN","ZZUTPOST",15,0)
- . Q
-"RTN","ZZUTPOST",16,0)
  D RENAME
-"RTN","ZZUTPOST",17,0)
- I +$SY=47 D  R X:$G(DTIME,300) I "Yy"[$E($G(X)) D GTMPROB
-"RTN","ZZUTPOST",18,0)
- . K X
-"RTN","ZZUTPOST",19,0)
- . S X(1)=" "
-"RTN","ZZUTPOST",20,0)
- . S X(2)="  Your entry on the next line may not echo"
-"RTN","ZZUTPOST",21,0)
- . S X(3)="If error text was seen enter Y (and RETURN):  NO// "
-"RTN","ZZUTPOST",22,0)
- . D MES^XPDUTL(.X)
-"RTN","ZZUTPOST",23,0)
- . Q
-"RTN","ZZUTPOST",24,0)
- Q
-"RTN","ZZUTPOST",25,0)
- ;
-"RTN","ZZUTPOST",26,0)
-RENAME ;
-"RTN","ZZUTPOST",27,0)
- N %S,%D ; Source, destination
-"RTN","ZZUTPOST",28,0)
- S U="^"
-"RTN","ZZUTPOST",29,0)
- S %S="ut^ut1^utt1^utt2^utt3^utt4^utt5^utt6^uttcovr"
-"RTN","ZZUTPOST",30,0)
- S %D="%ut^%ut1^%utt1^%utt2^%utt3^%utt4^%utt5^%utt6^%uttcovr"
-"RTN","ZZUTPOST",31,0)
- ;
-"RTN","ZZUTPOST",32,0)
-MOVE ; rename % routines
-"RTN","ZZUTPOST",33,0)
- N %,X,Y,M
-"RTN","ZZUTPOST",34,0)
- F %=1:1:$L(%D,"^") D  D MES(M) I +$SY=47 D MES(" ")
-"RTN","ZZUTPOST",35,0)
- . S M="",X=$P(%S,U,%) ; from
-"RTN","ZZUTPOST",36,0)
- . S Y=$P(%D,U,%) ; to
-"RTN","ZZUTPOST",37,0)
- . Q:X=""
-"RTN","ZZUTPOST",38,0)
- . S M="Routine: "_$J(X,8)
-"RTN","ZZUTPOST",39,0)
- . Q:Y=""  I $T(^@X)=""  S M=M_"  Missing" Q
-"RTN","ZZUTPOST",40,0)
- . S M=M_" Loaded, "
-"RTN","ZZUTPOST",41,0)
- . D COPY(X,Y)
-"RTN","ZZUTPOST",42,0)
- . S M=M_"Saved as "_$J(Y,8)
-"RTN","ZZUTPOST",43,0)
- ;
-"RTN","ZZUTPOST",44,0)
- QUIT  ; END
-"RTN","ZZUTPOST",45,0)
- ;
-"RTN","ZZUTPOST",46,0)
-COPY(FROM,TO) ;
-"RTN","ZZUTPOST",47,0)
- N XVAL
-"RTN","ZZUTPOST",48,0)
- I +$SYSTEM=0 S XVAL="ZL @FROM ZS @TO" X XVAL QUIT
-"RTN","ZZUTPOST",49,0)
- I +$SYSTEM=47 DO  QUIT
-"RTN","ZZUTPOST",50,0)
- . S FROM=$$PATH(FROM)
-"RTN","ZZUTPOST",51,0)
- . S TO=$$PATH(TO,"WRITE")
-"RTN","ZZUTPOST",52,0)
- . N CMD S CMD="cp "_FROM_" "_TO
-"RTN","ZZUTPOST",53,0)
- . O "cp":(shell="/bin/sh":command=CMD:WRITEONLY)::"PIPE"
-"RTN","ZZUTPOST",54,0)
- . U "cp" C "cp"
-"RTN","ZZUTPOST",55,0)
+"RTN","ZZUTPOST",9,0)
  QUIT
-"RTN","ZZUTPOST",56,0)
+"RTN","ZZUTPOST",10,0)
  ;
-"RTN","ZZUTPOST",57,0)
+"RTN","ZZUTPOST",11,0)
+RENAME ;
+"RTN","ZZUTPOST",12,0)
+ N %S,%D ; Source, destination
+"RTN","ZZUTPOST",13,0)
+ S U="^"
+"RTN","ZZUTPOST",14,0)
+ S %S="ut^ut1^utcover^utt1^utt2^utt3^utt4^utt5^utt6^uttcovr"
+"RTN","ZZUTPOST",15,0)
+ S %D="%ut^%ut1^%utcover^%utt1^%utt2^%utt3^%utt4^%utt5^%utt6^%uttcovr"
+"RTN","ZZUTPOST",16,0)
+ ;
+"RTN","ZZUTPOST",17,0)
+MOVE ; rename % routines
+"RTN","ZZUTPOST",18,0)
+ N %,X,Y,M
+"RTN","ZZUTPOST",19,0)
+ F %=1:1:$L(%D,"^") D  D MES(M) I +$SY=47 D MES(" ")
+"RTN","ZZUTPOST",20,0)
+ . S M="",X=$P(%S,U,%) ; from
+"RTN","ZZUTPOST",21,0)
+ . S Y=$P(%D,U,%) ; to
+"RTN","ZZUTPOST",22,0)
+ . Q:X=""
+"RTN","ZZUTPOST",23,0)
+ . S M="Routine: "_$J(X,8)
+"RTN","ZZUTPOST",24,0)
+ . Q:Y=""  I $T(^@X)=""  S M=M_"  Missing" Q
+"RTN","ZZUTPOST",25,0)
+ . S M=M_" Loaded, "
+"RTN","ZZUTPOST",26,0)
+ . D COPY(X,Y)
+"RTN","ZZUTPOST",27,0)
+ . S M=M_"Saved as "_$J(Y,8)
+"RTN","ZZUTPOST",28,0)
+ ;
+"RTN","ZZUTPOST",29,0)
+ QUIT  ; END
+"RTN","ZZUTPOST",30,0)
+ ;
+"RTN","ZZUTPOST",31,0)
+COPY(FROM,TO) ;
+"RTN","ZZUTPOST",32,0)
+ N XVAL
+"RTN","ZZUTPOST",33,0)
+ I +$SYSTEM=0 S XVAL="ZL @FROM ZS @TO" X XVAL QUIT
+"RTN","ZZUTPOST",34,0)
+ I +$SYSTEM=47 DO  QUIT
+"RTN","ZZUTPOST",35,0)
+ . S FROM=$$PATH(FROM)
+"RTN","ZZUTPOST",36,0)
+ . S TO=$$PATH(TO,"WRITE")
+"RTN","ZZUTPOST",37,0)
+ . N CMD S CMD="cp "_FROM_" "_TO
+"RTN","ZZUTPOST",38,0)
+ . O "cp":(shell="/bin/sh":command=CMD:WRITEONLY)::"PIPE"
+"RTN","ZZUTPOST",39,0)
+ . U "cp" C "cp"
+"RTN","ZZUTPOST",40,0)
+ QUIT
+"RTN","ZZUTPOST",41,0)
+ ;
+"RTN","ZZUTPOST",42,0)
 PATH(ROUTINE,MODE) ; for GT.M return source file with path for a routine
-"RTN","ZZUTPOST",58,0)
+"RTN","ZZUTPOST",43,0)
  ;input: ROUTINE=Name of routine
-"RTN","ZZUTPOST",59,0)
+"RTN","ZZUTPOST",44,0)
  ;       MODE="READ" or "WRITE" defaults to READ
-"RTN","ZZUTPOST",60,0)
+"RTN","ZZUTPOST",45,0)
  ;output: Full filename
+"RTN","ZZUTPOST",46,0)
+ ;
+"RTN","ZZUTPOST",47,0)
+ S MODE=$G(MODE,"READ") ;set MODE to default value
+"RTN","ZZUTPOST",48,0)
+ N FILE S FILE=$TR(ROUTINE,"%","_")_".m" ;convert rtn name to filename
+"RTN","ZZUTPOST",49,0)
+ N ZRO S ZRO=$ZRO
+"RTN","ZZUTPOST",50,0)
+ ;
+"RTN","ZZUTPOST",51,0)
+ ; Get source routine
+"RTN","ZZUTPOST",52,0)
+ N %ZR
+"RTN","ZZUTPOST",53,0)
+ I MODE="READ" D SILENT^%RSEL(ROUTINE,"SRC") Q %ZR(ROUTINE)_FILE
+"RTN","ZZUTPOST",54,0)
+ ;
+"RTN","ZZUTPOST",55,0)
+ ; We are writing. Parse directories and get 1st routine directory
+"RTN","ZZUTPOST",56,0)
+ N DIRS
+"RTN","ZZUTPOST",57,0)
+ D PARSEZRO(.DIRS,ZRO)
+"RTN","ZZUTPOST",58,0)
+ N PATH S PATH=$$ZRO1ST(.DIRS)
+"RTN","ZZUTPOST",59,0)
+ ;
+"RTN","ZZUTPOST",60,0)
+ QUIT PATH_FILE ;end of PATH return directory and filename
 "RTN","ZZUTPOST",61,0)
  ;
 "RTN","ZZUTPOST",62,0)
- S MODE=$G(MODE,"READ") ;set MODE to default value
+ ;
 "RTN","ZZUTPOST",63,0)
- N FILE S FILE=$TR(ROUTINE,"%","_")_".m" ;convert rtn name to filename
+PARSEZRO(DIRS,ZRO) ; Parse $zroutines properly into an array
 "RTN","ZZUTPOST",64,0)
- N ZRO S ZRO=$ZRO
+ N PIECE
 "RTN","ZZUTPOST",65,0)
- ;
+ N I
 "RTN","ZZUTPOST",66,0)
- ; Get source routine
+ F I=1:1:$L(ZRO," ") S PIECE(I)=$P(ZRO," ",I)
 "RTN","ZZUTPOST",67,0)
- N %ZR
+ N CNT S CNT=1
 "RTN","ZZUTPOST",68,0)
- I MODE="READ" D SILENT^%RSEL(ROUTINE,"SRC") Q %ZR(ROUTINE)_FILE
+ F I=0:0 S I=$O(PIECE(I)) Q:'I  D
 "RTN","ZZUTPOST",69,0)
- ;
+ . S DIRS(CNT)=$G(DIRS(CNT))_PIECE(I)
 "RTN","ZZUTPOST",70,0)
- ; We are writing. Parse directories and get 1st routine directory
+ . I DIRS(CNT)["("&(DIRS(CNT)[")") S CNT=CNT+1 QUIT
 "RTN","ZZUTPOST",71,0)
- N DIRS
+ . I DIRS(CNT)'["("&(DIRS(CNT)'[")") S CNT=CNT+1 QUIT
 "RTN","ZZUTPOST",72,0)
- D PARSEZRO(.DIRS,ZRO)
+ . S DIRS(CNT)=DIRS(CNT)_" " ; prep for next piece
 "RTN","ZZUTPOST",73,0)
- N PATH S PATH=$$ZRO1ST(.DIRS)
+ QUIT
 "RTN","ZZUTPOST",74,0)
  ;
 "RTN","ZZUTPOST",75,0)
- QUIT PATH_FILE ;end of PATH return directory and filename
+ZRO1ST(DIRS) ; $$ Get first routine directory
 "RTN","ZZUTPOST",76,0)
- ;
+ N OUT ; $$ return
 "RTN","ZZUTPOST",77,0)
- ;
+ N %1 S %1=DIRS(1) ; 1st directory
 "RTN","ZZUTPOST",78,0)
-PARSEZRO(DIRS,ZRO) ; Parse $zroutines properly into an array
+ ; Parse with (...)
 "RTN","ZZUTPOST",79,0)
- N PIECE
+ I %1["(" DO
 "RTN","ZZUTPOST",80,0)
- N I
+ . S OUT=$P(%1,"(",2)
 "RTN","ZZUTPOST",81,0)
- F I=1:1:$L(ZRO," ") S PIECE(I)=$P(ZRO," ",I)
+ . I OUT[" " S OUT=$P(OUT," ")
 "RTN","ZZUTPOST",82,0)
- N CNT S CNT=1
+ . E  S OUT=$P(OUT,")")
 "RTN","ZZUTPOST",83,0)
- F I=0:0 S I=$O(PIECE(I)) Q:'I  D
+ ; no parens
 "RTN","ZZUTPOST",84,0)
- . S DIRS(CNT)=$G(DIRS(CNT))_PIECE(I)
+ E  S OUT=%1
 "RTN","ZZUTPOST",85,0)
- . I DIRS(CNT)["("&(DIRS(CNT)[")") S CNT=CNT+1 QUIT
+ ;
 "RTN","ZZUTPOST",86,0)
- . I DIRS(CNT)'["("&(DIRS(CNT)'[")") S CNT=CNT+1 QUIT
+ ; Add trailing slash
 "RTN","ZZUTPOST",87,0)
- . S DIRS(CNT)=DIRS(CNT)_" " ; prep for next piece
+ I $E(OUT,$L(OUT))'="/" S OUT=OUT_"/"
 "RTN","ZZUTPOST",88,0)
- QUIT
+ QUIT OUT
 "RTN","ZZUTPOST",89,0)
  ;
 "RTN","ZZUTPOST",90,0)
-ZRO1ST(DIRS) ; $$ Get first routine directory
-"RTN","ZZUTPOST",91,0)
- N OUT ; $$ return
-"RTN","ZZUTPOST",92,0)
- N %1 S %1=DIRS(1) ; 1st directory
-"RTN","ZZUTPOST",93,0)
- ; Parse with (...)
-"RTN","ZZUTPOST",94,0)
- I %1["(" DO
-"RTN","ZZUTPOST",95,0)
- . S OUT=$P(%1,"(",2)
-"RTN","ZZUTPOST",96,0)
- . I OUT[" " S OUT=$P(OUT," ")
-"RTN","ZZUTPOST",97,0)
- . E  S OUT=$P(OUT,")")
-"RTN","ZZUTPOST",98,0)
- ; no parens
-"RTN","ZZUTPOST",99,0)
- E  S OUT=%1
-"RTN","ZZUTPOST",100,0)
- ;
-"RTN","ZZUTPOST",101,0)
- ; Add trailing slash
-"RTN","ZZUTPOST",102,0)
- I $E(OUT,$L(OUT))'="/" S OUT=OUT_"/"
-"RTN","ZZUTPOST",103,0)
- QUIT OUT
-"RTN","ZZUTPOST",104,0)
- ;
-"RTN","ZZUTPOST",105,0)
 MES(T,B) ;Write message.
-"RTN","ZZUTPOST",106,0)
+"RTN","ZZUTPOST",91,0)
  S B=$G(B)
-"RTN","ZZUTPOST",107,0)
+"RTN","ZZUTPOST",92,0)
  I $L($T(BMES^XPDUTL)) D BMES^XPDUTL(T):B,MES^XPDUTL(T):'B Q
-"RTN","ZZUTPOST",108,0)
+"RTN","ZZUTPOST",93,0)
  W:B ! W !,T
-"RTN","ZZUTPOST",109,0)
+"RTN","ZZUTPOST",94,0)
  Q
-"RTN","ZZUTPOST",110,0)
+"RTN","ZZUTPOST",95,0)
  ;
-"RTN","ZZUTPOST",111,0)
+"RTN","ZZUTPOST",96,0)
 TEST ; @TEST - TESTING TESTING
+"RTN","ZZUTPOST",97,0)
+ ;
+"RTN","ZZUTPOST",98,0)
+ N ZR S ZR="o(p r) /var/abc(/var/abc/r/) /abc/def $gtm_dist/libgtmutl.so vista.so"
+"RTN","ZZUTPOST",99,0)
+ N DIRS D PARSEZRO(.DIRS,ZR)
+"RTN","ZZUTPOST",100,0)
+ N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+"RTN","ZZUTPOST",101,0)
+ I FIRSTDIR'="p" S $EC=",U1,"
+"RTN","ZZUTPOST",102,0)
+ ;
+"RTN","ZZUTPOST",103,0)
+ N ZR S ZR="/var/abc(/var/abc/r/) o(p r) /abc/def $gtm_dist/libgtmutl.so vista.so"
+"RTN","ZZUTPOST",104,0)
+ N DIRS D PARSEZRO(.DIRS,ZR)
+"RTN","ZZUTPOST",105,0)
+ N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+"RTN","ZZUTPOST",106,0)
+ I FIRSTDIR'="/var/abc/r/" S $EC=",U1,"
+"RTN","ZZUTPOST",107,0)
+ ;
+"RTN","ZZUTPOST",108,0)
+ N ZR S ZR="/abc/def /var/abc(/var/abc/r/) o(p r) $gtm_dist/libgtmutl.so vista.so"
+"RTN","ZZUTPOST",109,0)
+ N DIRS D PARSEZRO(.DIRS,ZR)
+"RTN","ZZUTPOST",110,0)
+ N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+"RTN","ZZUTPOST",111,0)
+ I FIRSTDIR'="/abc/def" S $EC=",U1,"
 "RTN","ZZUTPOST",112,0)
  ;
 "RTN","ZZUTPOST",113,0)
- N ZR S ZR="o(p r) /var/abc(/var/abc/r/) /abc/def $gtm_dist/libgtmutl.so vista.so"
-"RTN","ZZUTPOST",114,0)
- N DIRS D PARSEZRO(.DIRS,ZR)
-"RTN","ZZUTPOST",115,0)
- N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
-"RTN","ZZUTPOST",116,0)
- I FIRSTDIR'="p" S $EC=",U1,"
-"RTN","ZZUTPOST",117,0)
- ;
-"RTN","ZZUTPOST",118,0)
- N ZR S ZR="/var/abc(/var/abc/r/) o(p r) /abc/def $gtm_dist/libgtmutl.so vista.so"
-"RTN","ZZUTPOST",119,0)
- N DIRS D PARSEZRO(.DIRS,ZR)
-"RTN","ZZUTPOST",120,0)
- N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
-"RTN","ZZUTPOST",121,0)
- I FIRSTDIR'="/var/abc/r/" S $EC=",U1,"
-"RTN","ZZUTPOST",122,0)
- ;
-"RTN","ZZUTPOST",123,0)
- N ZR S ZR="/abc/def /var/abc(/var/abc/r/) o(p r) $gtm_dist/libgtmutl.so vista.so"
-"RTN","ZZUTPOST",124,0)
- N DIRS D PARSEZRO(.DIRS,ZR)
-"RTN","ZZUTPOST",125,0)
- N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
-"RTN","ZZUTPOST",126,0)
- I FIRSTDIR'="/abc/def" S $EC=",U1,"
-"RTN","ZZUTPOST",127,0)
- ;
-"RTN","ZZUTPOST",128,0)
  WRITE "All tests have run successfully!",!
-"RTN","ZZUTPOST",129,0)
+"RTN","ZZUTPOST",114,0)
  QUIT
-"RTN","ZZUTPOST",130,0)
+"RTN","ZZUTPOST",115,0)
+ ;
+"RTN","ZZUTPOST",116,0)
+PREKIDS ; Ready for KIDS - Move % routines to non-percent version
+"RTN","ZZUTPOST",117,0)
+ N %S,%D ; Source, destination
+"RTN","ZZUTPOST",118,0)
+ S U="^"
+"RTN","ZZUTPOST",119,0)
+ S %D="ut^ut1^utcover^utt1^utt2^utt3^utt4^utt5^utt6^uttcovr"
+"RTN","ZZUTPOST",120,0)
+ S %S="%ut^%ut1^%utcover^%utt1^%utt2^%utt3^%utt4^%utt5^%utt6^%uttcovr"
+"RTN","ZZUTPOST",121,0)
+ D MOVE
+"RTN","ZZUTPOST",122,0)
+ QUIT
+"RTN","ZZUTPOST",123,0)
  ;
-"RTN","ZZUTPOST",131,0)
-GTMPROB ; come here in case of error trying to run unit tests - checks whether renaming worked
-"RTN","ZZUTPOST",132,0)
- N X
-"RTN","ZZUTPOST",133,0)
- S X(1)=" "
-"RTN","ZZUTPOST",134,0)
- S X(2)="*** An error occurred during renaming of routines to %ut*."
-"RTN","ZZUTPOST",135,0)
- S X(3)="*** The renaming has been seen to fail on one type of Linux system."
-"RTN","ZZUTPOST",136,0)
- S X(4)="*** In this case, at the Linux command line copy each ut*.m routine"
-"RTN","ZZUTPOST",137,0)
- S X(5)="*** (ut.m, ut1.m, utt1.m, utt2.m, utt3.m, utt4.m, utt5.m, utt6.m, and "
-"RTN","ZZUTPOST",138,0)
- S X(6)="*** uttcovr.m) to _ut*.m (e.g., 'cp ut.m _ut.m', 'cp ut1.m _ut1.m',"
-"RTN","ZZUTPOST",139,0)
- S X(7)="*** 'cp utt1.m _utt1.m', etc., to 'cp uttcovr.m _uttcovr.m').  Then in GT.M"
-"RTN","ZZUTPOST",140,0)
- S X(8)="*** use the command 'ZLINK %ut', then 'ZLINK %ut1', etc., these may"
-"RTN","ZZUTPOST",141,0)
- S X(9)="*** indicate an undefined local variable error, but continue doing it."
-"RTN","ZZUTPOST",142,0)
- S X(10)="*** When complete, use the M command 'DO ^%utt1' to run the unit tests on"
-"RTN","ZZUTPOST",143,0)
- S X(11)="*** the %ut and %ut1 routines to confirm they are working"
-"RTN","ZZUTPOST",144,0)
- S X(12)=" "
-"RTN","ZZUTPOST",145,0)
- S X(13)="  Press Enter to continue: "
-"RTN","ZZUTPOST",146,0)
- D MES^XPDUTL(.X)
-"RTN","ZZUTPOST",147,0)
- R X:$G(DTIME,300)
-"RTN","ZZUTPOST",148,0)
- Q
 "RTN","ZZUTPRE")
-0^^B6404122
+0^^B7236366
 "RTN","ZZUTPRE",1,0)
-ut01PRE ;VEN/JLI - pre installation routine to set up MASH UTILITIES package and assign %ut routines and globals ;08/22/14  13:02
+%utPRE ;VEN/SMH/JLI - pre installation routine to set up MASH UTILITIES package and assign %ut routines and globals ;12/16/15  08:59
 "RTN","ZZUTPRE",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","ZZUTPRE",3,0)
- ;
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","ZZUTPRE",4,0)
- ; The following is used to create, if it does not exist, the MASH UTILITIES
+ ; Original routine authored by Sam H. Habiel 07/2013-04/2014
 "RTN","ZZUTPRE",5,0)
- ; package, and to assign the %u namespace to this package.  This special
+ ;
 "RTN","ZZUTPRE",6,0)
- ; processing is necessary, since the input transform currently will not accept a
+ ;
 "RTN","ZZUTPRE",7,0)
- ; % or lower case character in the namespace.
+ ; The following is used to create, if it does not exist, the MASH UTILITIES
 "RTN","ZZUTPRE",8,0)
- I '$D(^DIC(9.4,"B","MASH UTILITIES")) N DIC,X S DIC="^DIC(9.4,",DIC(0)="",X="MASH UTILITIES",DIC("DR")="1////%u;2///Utilities associated with the M Advanced Shell" D FILE^DICN
+ ; package, and to assign the %u namespace to this package.  This special
 "RTN","ZZUTPRE",9,0)
- ; and if necessary, as in CACHE, map %ut routine and namespace in the current account.
+ ; processing is necessary, since the input transform currently will not accept a
 "RTN","ZZUTPRE",10,0)
- I +$SY=0 D CACHEMAP ; This routine is CACHE specific
+ ; % or lower case character in the namespace.
 "RTN","ZZUTPRE",11,0)
- Q
+ I '$D(^DIC(9.4,"B","MASH UTILITIES")) N DIC,X S DIC="^DIC(9.4,",DIC(0)="",X="MASH UTILITIES",DIC("DR")="1////%u;2///Utilities associated with the M Advanced Shell" D FILE^DICN
 "RTN","ZZUTPRE",12,0)
- ; The following code was provided by Sam Habiel to map %
+ ; and if necessary, as in CACHE, map %ut routine and namespace in the current account.
 "RTN","ZZUTPRE",13,0)
-CACHEMAP ; Map %ut* Globals and Routines away from %SYS in Cache
+ I +$SY=0 D CACHEMAP ; This routine is CACHE specific
 "RTN","ZZUTPRE",14,0)
- ; Get current namespace
+ Q
 "RTN","ZZUTPRE",15,0)
- N NMSP
+ ; The following code was provided by Sam Habiel to map %
 "RTN","ZZUTPRE",16,0)
- I $P($P($ZV,") ",2),"(")<2012 S NMSP=$ZU(5)
+CACHEMAP ; Map %ut* Globals and Routines away from %SYS in Cache
 "RTN","ZZUTPRE",17,0)
- I $P($P($ZV,") ",2),"(")>2011 S NMSP=$NAMESPACE
+ ; Get current namespace
 "RTN","ZZUTPRE",18,0)
- ;
+ N NMSP
 "RTN","ZZUTPRE",19,0)
- N $ET S $ET="ZN NMSP D ^%ZTER S $EC="""""
+ I $P($P($ZV,") ",2),"(")<2012 S NMSP=$ZU(5)
 "RTN","ZZUTPRE",20,0)
- ;
+ I $P($P($ZV,") ",2),"(")>2011 S NMSP=$NAMESPACE
 "RTN","ZZUTPRE",21,0)
- ZN "%SYS" ; Go to SYS
+ ;
 "RTN","ZZUTPRE",22,0)
- ;
+ N $ET S $ET="ZN NMSP D ^%ZTER S $EC="""""
 "RTN","ZZUTPRE",23,0)
- ; Props
-"RTN","ZZUTPRE",24,0)
- N % S %=##Class(Config.Namespaces).Get(NMSP,.PROP) ; Get all namespace properties
-"RTN","ZZUTPRE",25,0)
- I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) S $EC=",U-CONFIG-FAIL," QUIT
-"RTN","ZZUTPRE",26,0)
  ;
+"RTN","ZZUTPRE",24,0)
+ ZN "%SYS" ; Go to SYS
+"RTN","ZZUTPRE",25,0)
+ ;
+"RTN","ZZUTPRE",26,0)
+ ; Props
 "RTN","ZZUTPRE",27,0)
- N DBG S DBG=PROP("Globals")  ; get the database globals location
+ N % S %=##Class(Config.Namespaces).Get(NMSP,.PROP) ; Get all namespace properties
 "RTN","ZZUTPRE",28,0)
- N DBR S DBR=PROP("Routines") ; get the database routines location
+ I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) S $EC=",U-CONFIG-FAIL," QUIT
 "RTN","ZZUTPRE",29,0)
  ;
 "RTN","ZZUTPRE",30,0)
- ; Map %ut globals away from %SYS
+ N DBG S DBG=PROP("Globals")  ; get the database globals location
 "RTN","ZZUTPRE",31,0)
- N % S %=##class(Config.Configuration).GetGlobalMapping(NMSP,"%ut*","",DBG,DBG)
+ N DBR S DBR=PROP("Routines") ; get the database routines location
 "RTN","ZZUTPRE",32,0)
- I '% S %=##class(Config.Configuration).AddGlobalMapping(NMSP,"%ut*","",DBG,DBG)
+ S PROP("Database")=DBG ; needed for call to MapGlobals.Create below
 "RTN","ZZUTPRE",33,0)
- I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) S $EC=",U-CONFIG-FAIL," QUIT
-"RTN","ZZUTPRE",34,0)
  ;
+"RTN","ZZUTPRE",34,0)
+ ; Map %ut globals away from %SYS
 "RTN","ZZUTPRE",35,0)
- ; Map %ut routines away from %SYS
+ N %
 "RTN","ZZUTPRE",36,0)
- N PROPRTN S PROPRTN("Database")=DBR
+ S %=##class(Config.Configuration).GetGlobalMapping(NMSP,"%ut*","",DBG,DBG)
 "RTN","ZZUTPRE",37,0)
- N % S %=##Class(Config.MapRoutines).Get(NMSP,"%ut*",.PROPRTN)
+ ;S %=##Class(Config.MapGlobals).Get(NMSP,"%ut*",.PROP)
 "RTN","ZZUTPRE",38,0)
- N PROPRTN S PROPRTN("Database")=DBR  ; Cache seems to like deleting this
+ I '% S %=##class(Config.Configuration).AddGlobalMapping(NMSP,"%ut*","",DBG,DBG)
 "RTN","ZZUTPRE",39,0)
- I '% S %=##Class(Config.MapRoutines).Create(NMSP,"%ut*",.PROPRTN)
+ ;I '% S %=##Class(Config.MapGlobals).Create(NMSP,"%ut",.PROP) ; doesn't work with "%ut*"
 "RTN","ZZUTPRE",40,0)
- I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) S $EC=",U-CONFIG-FAIL," QUIT
+ ;
 "RTN","ZZUTPRE",41,0)
- ZN NMSP ; Go back
+ I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) S $EC=",U-CONFIG-FAIL," QUIT
 "RTN","ZZUTPRE",42,0)
+ ;
+"RTN","ZZUTPRE",43,0)
+ ; Map %ut routines away from %SYS
+"RTN","ZZUTPRE",44,0)
+ N PROPRTN S PROPRTN("Database")=DBR
+"RTN","ZZUTPRE",45,0)
+ N % S %=##Class(Config.MapRoutines).Get(NMSP,"%ut*",.PROPRTN)
+"RTN","ZZUTPRE",46,0)
+ N PROPRTN S PROPRTN("Database")=DBR  ; Cache seems to like deleting this
+"RTN","ZZUTPRE",47,0)
+ I '% S %=##Class(Config.MapRoutines).Create(NMSP,"%ut*",.PROPRTN)
+"RTN","ZZUTPRE",48,0)
+ I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) S $EC=",U-CONFIG-FAIL," QUIT
+"RTN","ZZUTPRE",49,0)
+ ZN NMSP ; Go back
+"RTN","ZZUTPRE",50,0)
  QUIT
 "RTN","ut")
-0^1^B257937062
+0^1^B249153555
 "RTN","ut",1,0)
-%ut ;VEN-SMH/JLI - PRIMARY PROGRAM FOR M-UNIT TESTING ;08/29/14  09:31
+%ut ;VEN-SMH/JLI - PRIMARY PROGRAM FOR M-UNIT TESTING ;2015-12-31  10:46 PM
 "RTN","ut",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","ut",3,0)
- ;
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","ut",4,0)
- ; This routine and its companion, %ut1, provide the basic functionality for
+ ; Original routine authored by Joel L. Ivey as XTMUNIT while working for U.S. Department of Veterans Affairs 2003-2012
 "RTN","ut",5,0)
- ; running unit tests on parts of M programs either at the command line level
+ ; Includes addition of %utVERB and %utBREAK arguments and code related to them as well as other substantial additions authored by Sam Habiel 07/2013-04/2014
 "RTN","ut",6,0)
- ; or via the M-Unit GUI application for windows operating systems.
+ ; Additional work by Joel L. Ivey 05/14-12/15
 "RTN","ut",7,0)
  ;
 "RTN","ut",8,0)
- ; Original by Dr. Joel Ivey
+ ; This routine and its companion, %ut1, provide the basic functionality for
 "RTN","ut",9,0)
- ; Contributions by Dr. Sam Habiel
+ ; running unit tests on parts of M programs either at the command line level
 "RTN","ut",10,0)
- ;
+ ; or via the M-Unit GUI application for windows operating systems.
 "RTN","ut",11,0)
- ; 100622 JLI - corrected typo in comments where %utINPT was listed as %utINP
-"RTN","ut",12,0)
- ; 100622 JLI - removed a comment which indicated data could potentially be returned from the called routine
-"RTN","ut",13,0)
- ;              in the %utINPT array.
-"RTN","ut",14,0)
- ; 100622 JLI - added code to handle STARTUP and SHUTDOWN from GUI app
-"RTN","ut",15,0)
- ; 110719 JLI - modified separators in GUI handling from ^ to ~~^~~
-"RTN","ut",16,0)
- ;              in the variable XTGUISEP if using a newer version of the
-"RTN","ut",17,0)
- ;              GUI app (otherwise, it is simply set to ^) since results
-"RTN","ut",18,0)
- ;              with a series of ^ embedded disturbed the output reported
-"RTN","ut",19,0)
- ; 130726 SMH - Fixed SETUP and TEARDOWN so that they run before/after each
-"RTN","ut",20,0)
- ;              test rather than once. General refactoring.
-"RTN","ut",21,0)
- ; 130726 SMH - SETUT initialized IO in case it's not there to $P. Inits vars
-"RTN","ut",22,0)
- ;              using DT^DICRW.
-"RTN","ut",23,0)
- ; 131217 SMH - Change call in SETUP to S U="^" instead of DT^DICRW
-"RTN","ut",24,0)
- ; 131218 SMH - Any checks to $ZE will also check $ZS for GT.M.
-"RTN","ut",25,0)
- ; 131218 SMH - Remove calls to %ZISUTL to manage devices to prevent dependence on VISTA.
-"RTN","ut",26,0)
- ;              Use %utNIT("DEV","OLD") for old devices
-"RTN","ut",27,0)
- ; 140109 SMH - Add parameter %utBREAK - Break upon error
-"RTN","ut",28,0)
- ; 1402   SMH - Break will cause the break to happen even on failed tests.
-"RTN","ut",29,0)
- ; 140401 SMH - Added Succeed entry point for take it into your hands tester.
-"RTN","ut",30,0)
- ; 140401 SMH - Reformatted the output of M-Unit so that the test's name
-"RTN","ut",31,0)
- ;              will print BEFORE the execution of the test. This has been
-"RTN","ut",32,0)
- ;              really confusing for beginning users of M-Unit, so this was
-"RTN","ut",33,0)
- ;              necessary.
-"RTN","ut",34,0)
- ; 140401 SMH - OK message gets printed at the end of --- as [OK].
-"RTN","ut",35,0)
- ; 140401 SMH - FAIL message now prints. Previously, OK failed to be printed.
-"RTN","ut",36,0)
- ;              Unfortunately, that's rather passive aggressive. Now it
-"RTN","ut",37,0)
- ;              explicitly says that a test failed.
-"RTN","ut",38,0)
- ; 140503 SMH - Fixed IO issues all over the routine. Much simpler now.
-"RTN","ut",39,0)
- ; 140731 JLI - Combined routine changes between JLI and SMH
-"RTN","ut",40,0)
- ;              Moved routines from %utNIT and %utNIT1 to %ut and %ut1
-"RTN","ut",41,0)
- ;              Updated unit test routines (%utt1 to %utt6)
-"RTN","ut",42,0)
- ;              Created M-UNIT TEST GROUP file at 17.9001 based on the 17.9001 file
-"RTN","ut",43,0)
- Q
-"RTN","ut",44,0)
  ;
-"RTN","ut",45,0)
-EN(%utRNAM,%utVERB,%utBREAK) ; .SR Entry point with primary test routine name, optional 1 for verbose output
-"RTN","ut",46,0)
- N %utLIST,%utROU,%ut
-"RTN","ut",47,0)
- I '+$G(%utVERB) S %utVERB=0
-"RTN","ut",48,0)
- S %utLIST=1,%utROU(%utLIST)=%utRNAM
-"RTN","ut",49,0)
- D SETUT
-"RTN","ut",50,0)
- D EN1(.%utROU,%utLIST)
-"RTN","ut",51,0)
+"RTN","ut",12,0)
+ ; Original by Dr. Joel Ivey
+"RTN","ut",13,0)
+ ; Contributions by Dr. Sam Habiel
+"RTN","ut",14,0)
+ ;   comments moved to %ut1 due to space requirements
+"RTN","ut",15,0)
+ ;
+"RTN","ut",16,0)
+ D ^%utt6 ; runs unit tests on all of it
+"RTN","ut",17,0)
  Q
+"RTN","ut",18,0)
+ ;
+"RTN","ut",19,0)
+EN(%utRNAM,%utVERB,%utBREAK) ; .SR Entry point with primary test routine name
+"RTN","ut",20,0)
+ ; %utRNAM: (Required) Routine name that contians the tags with @TEST in them or the tag XTROU
+"RTN","ut",21,0)
+ ; %utVERB: (optional) 1 for verbose output or 2 for verbose and timing info.
+"RTN","ut",22,0)
+ ; %utBREAK:(optional) bool - Break upon error or upon failure
+"RTN","ut",23,0)
+ N %utLIST,%utROU,%ut
+"RTN","ut",24,0)
+ S %utLIST=1,%utROU(%utLIST)=%utRNAM
+"RTN","ut",25,0)
+ K ^TMP("%ut",$J,"UTVALS")
+"RTN","ut",26,0)
+ D SETUT
+"RTN","ut",27,0)
+ D EN1(.%utROU,%utLIST)
+"RTN","ut",28,0)
+ Q
+"RTN","ut",29,0)
+ ;
+"RTN","ut",30,0)
+SETUT ;
+"RTN","ut",31,0)
+ ; VEN/SMH 26JUL2013
+"RTN","ut",32,0)
+ I '($D(IO)#2) S IO=$P
+"RTN","ut",33,0)
+ S U="^"
+"RTN","ut",34,0)
+ ; VEN/SMH 26JUL2013 END
+"RTN","ut",35,0)
+ ;
+"RTN","ut",36,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",37,0)
+ S %ut("IO")=IO
+"RTN","ut",38,0)
+ S %ut=1 ; set to identify unit test being run check with $$ISUTEST^%ut()
+"RTN","ut",39,0)
+ ;
+"RTN","ut",40,0)
+ ; ZEXCEPT: %utBREAK
+"RTN","ut",41,0)
+ I $G(%utBREAK) S %ut("BREAK")=1
+"RTN","ut",42,0)
+ Q
+"RTN","ut",43,0)
+ ;
+"RTN","ut",44,0)
+EN1(%utROU,%utLIST) ;
+"RTN","ut",45,0)
+ ; VEN/SMH 26JUL2013 - This block is refactored to fix problems with
+"RTN","ut",46,0)
+ ; SETUP and TEARDOWN not happening at the right time
+"RTN","ut",47,0)
+ N %utERRL,%utK,%utI,%utJ,%utSTRT
+"RTN","ut",48,0)
+ ; ZEXCEPT: %utVERB   -- ARGUMENT TO EN
+"RTN","ut",49,0)
+ I '+$G(%utVERB) S %utVERB=0
+"RTN","ut",50,0)
+ ; ZEXCEPT: %utGUI      -- CONDITIONALLY DEFINED BY GUINEXT
+"RTN","ut",51,0)
+ ; ZEXCEPT: %ut  -- NEWED IN EN
 "RTN","ut",52,0)
  ;
 "RTN","ut",53,0)
-SETUT ;
-"RTN","ut",54,0)
- ; VEN/SMH 26JUL2013
-"RTN","ut",55,0)
- I '($D(IO)#2) S IO=$P
-"RTN","ut",56,0)
- S U="^"
-"RTN","ut",57,0)
- ; VEN/SMH 26JUL2013 END
-"RTN","ut",58,0)
- ;
-"RTN","ut",59,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"RTN","ut",60,0)
- S %ut("IO")=IO
-"RTN","ut",61,0)
- S %ut=1 ; set to identify unit test being run check with $$ISUTEST^%ut()
-"RTN","ut",62,0)
- ;
-"RTN","ut",63,0)
- ; ZEXCEPT: %utBREAK
-"RTN","ut",64,0)
- I $G(%utBREAK) S %ut("BREAK")=1
-"RTN","ut",65,0)
- Q
-"RTN","ut",66,0)
- ;
-"RTN","ut",67,0)
-EN1(%utROU,%utLIST) ;
-"RTN","ut",68,0)
- ; VEN/SMH 26JUL2013 - This block is refactored to fix problems with
-"RTN","ut",69,0)
- ; SETUP and TEARDOWN not happening at the right time
-"RTN","ut",70,0)
- N %utERRL,%utK,%utI,%utJ,%utSTRT
-"RTN","ut",71,0)
- ; ZEXCEPT: %utVERB   -- ARGUMENT TO EN
-"RTN","ut",72,0)
- ; ZEXCEPT: %utGUI      -- CONDITIONALLY DEFINED BY GUINEXT
-"RTN","ut",73,0)
- ; ZEXCEPT: %ut  -- NEWED IN EN
-"RTN","ut",74,0)
- ;
-"RTN","ut",75,0)
  ; Structure map for %ut
-"RTN","ut",76,0)
+"RTN","ut",54,0)
  ; -- CURR = Counter for routine number. Used as sub in %utROU
-"RTN","ut",77,0)
+"RTN","ut",55,0)
  ; -- ECNT = Entry point count in loop (cf. NERT); VEN/SMH - Needed?
-"RTN","ut",78,0)
+"RTN","ut",56,0)
  ; -- FAIL = Number of failures
-"RTN","ut",79,0)
+"RTN","ut",57,0)
  ; -- CHK  = Number of checks ran (TF/EQ/FAIL)
-"RTN","ut",80,0)
+"RTN","ut",58,0)
  ; -- NENT = Number of entry points ran
-"RTN","ut",81,0)
+"RTN","ut",59,0)
  ; -- ERRN = Number of errors
-"RTN","ut",82,0)
+"RTN","ut",60,0)
  S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
-"RTN","ut",83,0)
+"RTN","ut",61,0)
  ;
-"RTN","ut",84,0)
+"RTN","ut",62,0)
  ; -- GET LIST OF ROUTINES --
-"RTN","ut",85,0)
+"RTN","ut",63,0)
  ; first get any tree of routines from this one
-"RTN","ut",86,0)
+"RTN","ut",64,0)
  D GETTREE^%ut1(.%utROU,.%utLIST)
-"RTN","ut",87,0)
+"RTN","ut",65,0)
  ;
-"RTN","ut",88,0)
- ; -- STARTUP --
-"RTN","ut",89,0)
- ; 070224 - following code added to allow one overall STARTUP code JLI
-"RTN","ut",90,0)
- F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D  I $G(%utSTRT)'="" D @%utSTRT Q
-"RTN","ut",91,0)
- . I $T(@("STARTUP^"_%utROU(%ut("CURR"))))'="" S %utSTRT="STARTUP^"_%utROU(%ut("CURR"))
-"RTN","ut",92,0)
- . Q
-"RTN","ut",93,0)
- ; 070224 - end of addition JLI
-"RTN","ut",94,0)
- ;
-"RTN","ut",95,0)
- ;
-"RTN","ut",96,0)
+"RTN","ut",66,0)
  ; Now process each routine that has been referenced
-"RTN","ut",97,0)
+"RTN","ut",67,0)
+ N CURRROU
+"RTN","ut",68,0)
  S %ut("CURR")=0
-"RTN","ut",98,0)
- F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D
-"RTN","ut",99,0)
+"RTN","ut",69,0)
+ F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  S CURRROU=%utROU(%ut("CURR")) D  I $T(@("SHUTDOWN^"_CURRROU))'="" D @("SHUTDOWN^"_CURRROU)
+"RTN","ut",70,0)
+ . ; 141018 - add ability to run STARTUP and SHUTDOWN in each routine JLI
+"RTN","ut",71,0)
+ . I $T(@("STARTUP^"_CURRROU))'="" D @("STARTUP^"_CURRROU) ; 141018
+"RTN","ut",72,0)
  . N %utETRY ; Test list to run
-"RTN","ut",100,0)
+"RTN","ut",73,0)
  . ;
-"RTN","ut",101,0)
+"RTN","ut",74,0)
  . ; Collect Test list.
-"RTN","ut",102,0)
+"RTN","ut",75,0)
  . D CHEKTEST^%ut1(%utROU(%ut("CURR")),.%ut,.%utETRY)
-"RTN","ut",103,0)
+"RTN","ut",76,0)
  . ;
-"RTN","ut",104,0)
+"RTN","ut",77,0)
  . ; if a SETUP entry point exists, save it off in %ut
-"RTN","ut",105,0)
+"RTN","ut",78,0)
+ . S %ut("SETUP")="" ; 141018 need to clear any previous values JLI
+"RTN","ut",79,0)
  . N %utSETUP S %utSETUP="SETUP^"_%utROU(%ut("CURR"))
-"RTN","ut",106,0)
+"RTN","ut",80,0)
  . S %ut("LINE")=$T(@%utSETUP) I %ut("LINE")'="" S %ut("SETUP")=%utSETUP
-"RTN","ut",107,0)
+"RTN","ut",81,0)
  . K %utSETUP ; we're done!
-"RTN","ut",108,0)
+"RTN","ut",82,0)
  . ;
-"RTN","ut",109,0)
+"RTN","ut",83,0)
  . ; if a TEARDOWN entry point exists, ditto
-"RTN","ut",110,0)
+"RTN","ut",84,0)
+ . S %ut("TEARDOWN")="" ; 141018 need to clear any previous values JLI
+"RTN","ut",85,0)
  . N %utTEARDOWN S %utTEARDOWN="TEARDOWN^"_%utROU(%ut("CURR"))
-"RTN","ut",111,0)
+"RTN","ut",86,0)
  . S %ut("LINE")=$T(@%utTEARDOWN) I %ut("LINE")'="" S %ut("TEARDOWN")=%utTEARDOWN
-"RTN","ut",112,0)
+"RTN","ut",87,0)
  . K %utTEARDOWN ; done here.
-"RTN","ut",113,0)
+"RTN","ut",88,0)
  . ;
-"RTN","ut",114,0)
+"RTN","ut",89,0)
  . ; VEN/SMH 26JUL2013 - this block changed to correct running of setup and teardown
-"RTN","ut",115,0)
+"RTN","ut",90,0)
  . ; run each of the specified entry points
-"RTN","ut",116,0)
+"RTN","ut",91,0)
  . ;
-"RTN","ut",117,0)
+"RTN","ut",92,0)
  . ; == THIS FOR/DO BLOCK IS THE CENTRAL TEST RUNNER ==
-"RTN","ut",118,0)
+"RTN","ut",93,0)
  . S %utI=0
-"RTN","ut",119,0)
+"RTN","ut",94,0)
  . F  S %utI=$O(%utETRY(%utI)) Q:%utI'>0  S %ut("ENUM")=%ut("ERRN")+%ut("FAIL") D
-"RTN","ut",120,0)
+"RTN","ut",95,0)
  . . N $ETRAP S $ETRAP="D ERROR^%ut"
-"RTN","ut",121,0)
+"RTN","ut",96,0)
  . . ;
-"RTN","ut",122,0)
+"RTN","ut",97,0)
  . . ; Run Set-up Code (only if present)
-"RTN","ut",123,0)
+"RTN","ut",98,0)
  . . S %ut("ENT")=$G(%ut("SETUP")) ; Current entry
-"RTN","ut",124,0)
+"RTN","ut",99,0)
  . . S %ut("NAME")="Set-up Code"
-"RTN","ut",125,0)
+"RTN","ut",100,0)
  . . D:%ut("ENT")]"" @%ut("ENT")
-"RTN","ut",126,0)
+"RTN","ut",101,0)
  . . ;
-"RTN","ut",127,0)
+"RTN","ut",102,0)
  . . ; Run actual test
-"RTN","ut",128,0)
+"RTN","ut",103,0)
  . . S %ut("ECNT")=%ut("ECNT")+1
-"RTN","ut",129,0)
+"RTN","ut",104,0)
  . . S %ut("NAME")=%utETRY(%utI,"NAME")
-"RTN","ut",130,0)
+"RTN","ut",105,0)
  . . S %ut("ENT")=%utETRY(%utI)_"^"_%utROU(%ut("CURR"))
-"RTN","ut",131,0)
+"RTN","ut",106,0)
  . . I %utVERB,'$D(%utGUI) D VERBOSE1(.%utETRY,%utI) ; Say what we executed.
-"RTN","ut",132,0)
+"RTN","ut",107,0)
+ . . ;
+"RTN","ut",108,0)
+ . . I %utVERB=2 N %utStart D  ; Time Start
+"RTN","ut",109,0)
+ . . . I +$SY=0  S %utStart=$P($SYSTEM.Process.GetCPUTime(),",")+$P($SYSTEM.Process.GetCPUTime(),",",2)
+"RTN","ut",110,0)
+ . . . I +$SY=47 S %utStart=$ZGETJPI("","CPUTIM")*10
+"RTN","ut",111,0)
+ . . ;
+"RTN","ut",112,0)
+ . . ; Run the test!
+"RTN","ut",113,0)
  . . D @%ut("ENT")
-"RTN","ut",133,0)
+"RTN","ut",114,0)
  . . ;
-"RTN","ut",134,0)
+"RTN","ut",115,0)
+ . . I %utVERB=2 N %utEnd,%utElapsed D  ; Time End
+"RTN","ut",116,0)
+ . . . I +$SY=0  S %utEnd=$P($SYSTEM.Process.GetCPUTime(),",")+$P($SYSTEM.Process.GetCPUTime(),",",2)
+"RTN","ut",117,0)
+ . . . I +$SY=47 S %utEnd=$ZGETJPI("","CPUTIM")*10
+"RTN","ut",118,0)
+ . . . S %utElapsed=%utEnd-%utStart_"ms"
+"RTN","ut",119,0)
+ . . ;
+"RTN","ut",120,0)
  . . ; Run Teardown Code (only if present)
-"RTN","ut",135,0)
+"RTN","ut",121,0)
  . . S %ut("ENT")=$G(%ut("TEARDOWN"))
-"RTN","ut",136,0)
+"RTN","ut",122,0)
  . . S %ut("NAME")="Teardown Code"
-"RTN","ut",137,0)
+"RTN","ut",123,0)
  . . D:%ut("ENT")]"" @%ut("ENT")
-"RTN","ut",138,0)
+"RTN","ut",124,0)
  . . ;
-"RTN","ut",139,0)
+"RTN","ut",125,0)
  . . ; ENUM = Number of errors + failures
-"RTN","ut",140,0)
+"RTN","ut",126,0)
  . . ; Only print out the success message [OK] If our error number remains
-"RTN","ut",141,0)
+"RTN","ut",127,0)
  . . ; the same as when we started the loop.
-"RTN","ut",142,0)
+"RTN","ut",128,0)
  . . I %utVERB,'$D(%utGUI) D
-"RTN","ut",143,0)
- . . . I %ut("ENUM")=(%ut("ERRN")+%ut("FAIL")) D VERBOSE(.%utETRY,%utI,1) I 1
-"RTN","ut",144,0)
- . . . E  D VERBOSE(.%utETRY,%utI,0)
-"RTN","ut",145,0)
- . ;
-"RTN","ut",146,0)
- . ;
-"RTN","ut",147,0)
+"RTN","ut",129,0)
+ . . . I %ut("ENUM")=(%ut("ERRN")+%ut("FAIL")) D VERBOSE(.%utETRY,1,%utVERB,$G(%utElapsed)) I 1
+"RTN","ut",130,0)
+ . . . E  D VERBOSE(.%utETRY,0,%utVERB,$G(%utElapsed))
+"RTN","ut",131,0)
+ . . . Q
+"RTN","ut",132,0)
+ . . Q
+"RTN","ut",133,0)
  . ; keep a %utCNT of number of entry points executed across all routines
-"RTN","ut",148,0)
+"RTN","ut",134,0)
  . S %ut("NENT")=%ut("NENT")+%ut("ENTN")
-"RTN","ut",149,0)
+"RTN","ut",135,0)
  . Q
-"RTN","ut",150,0)
+"RTN","ut",136,0)
  ;
-"RTN","ut",151,0)
+"RTN","ut",137,0)
  ; -- SHUTDOWN --
-"RTN","ut",152,0)
- ; 070224 - following code added to allow one overall SHUTDOWN code JLI
-"RTN","ut",153,0)
- N XTFINISH
-"RTN","ut",154,0)
- S %ut("CURR")=0
-"RTN","ut",155,0)
- F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D  I $G(XTFINISH)'="" D @XTFINISH Q
-"RTN","ut",156,0)
- . I $T(@("SHUTDOWN^"_%utROU(%ut("CURR"))))'="" S XTFINISH="SHUTDOWN^"_%utROU(%ut("CURR"))
-"RTN","ut",157,0)
- . Q
-"RTN","ut",158,0)
- ; 070224 - End of addition JLI
-"RTN","ut",159,0)
- ; and output the results
-"RTN","ut",160,0)
- D SETIO
-"RTN","ut",161,0)
+"RTN","ut",138,0)
+ D SETIO^%ut1
+"RTN","ut",139,0)
  W !!,"Ran ",%utLIST," Routine",$S(%utLIST>1:"s",1:""),", ",%ut("NENT")," Entry Tag",$S(%ut("NENT")>1:"s",1:"")
-"RTN","ut",162,0)
+"RTN","ut",140,0)
  W !,"Checked ",%ut("CHK")," test",$S(%ut("CHK")>1:"s",1:""),", with ",%ut("FAIL")," failure",$S(%ut("FAIL")'=1:"s",1:"")," and encountered ",%ut("ERRN")," error",$S(%ut("ERRN")'=1:"s",1:""),"."
-"RTN","ut",163,0)
- D RESETIO
-"RTN","ut",164,0)
+"RTN","ut",141,0)
+ S ^TMP("%ut",$J,"UTVALS")=%utLIST_U_%ut("NENT")_U_%ut("CHK")_U_%ut("FAIL")_U_%ut("ERRN") ; JLI 150621 so programs running several sets of unit tests can generate totals
+"RTN","ut",142,0)
+ D RESETIO^%ut1
+"RTN","ut",143,0)
  Q
-"RTN","ut",165,0)
+"RTN","ut",144,0)
  ; -- end EN1
+"RTN","ut",145,0)
+VERBOSE(%utETRY,SUCCESS,%utVERB,%utElapsed) ; Say whether we succeeded or failed.
+"RTN","ut",146,0)
+ ; ZEXCEPT: %ut - NEWED IN EN
+"RTN","ut",147,0)
+ D SETIO^%ut1
+"RTN","ut",148,0)
+ N RM S RM=73 ; Right Margin
+"RTN","ut",149,0)
+ I %utVERB=2,$G(%utElapsed)]"" S RM=RM-$L(%utElapsed)-1
+"RTN","ut",150,0)
+ N I F I=$X+3:1:RM W "-"
+"RTN","ut",151,0)
+ W ?RM
+"RTN","ut",152,0)
+ I $G(SUCCESS) W "[OK]"
+"RTN","ut",153,0)
+ E  W "[FAIL]"
+"RTN","ut",154,0)
+ I %utVERB=2,$G(%utElapsed)]"" W " ",%utElapsed
+"RTN","ut",155,0)
+ D RESETIO^%ut1
+"RTN","ut",156,0)
+ Q
+"RTN","ut",157,0)
+ ;
+"RTN","ut",158,0)
+VERBOSE1(%utETRY,%utI) ; Print out the entry point info
+"RTN","ut",159,0)
+ ; ZEXCEPT: %ut - NEWED IN EN
+"RTN","ut",160,0)
+ D SETIO^%ut1
+"RTN","ut",161,0)
+ W !,%utETRY(%utI) I $G(%utETRY(%utI,"NAME"))'="" W " - ",%utETRY(%utI,"NAME")
+"RTN","ut",162,0)
+ D RESETIO^%ut1
+"RTN","ut",163,0)
+ Q
+"RTN","ut",164,0)
+ ;
+"RTN","ut",165,0)
+CHKTF(XTSTVAL,XTERMSG) ; Entry point for checking True or False values
 "RTN","ut",166,0)
-VERBOSE(%utETRY,%utI,SUCCESS) ; Say whether we succeeded or failed.
+ ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
 "RTN","ut",167,0)
  ; ZEXCEPT: %ut - NEWED IN EN
 "RTN","ut",168,0)
- D SETIO
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
 "RTN","ut",169,0)
- N I F I=$X+3:1:73 W "-"
+ I '$D(XTSTVAL) D NVLDARG^%ut1("CHKTF") Q
 "RTN","ut",170,0)
- W ?73
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
 "RTN","ut",171,0)
- I $G(SUCCESS) W "[OK]"
-"RTN","ut",172,0)
- E  W "[FAIL]"
-"RTN","ut",173,0)
- D RESETIO
-"RTN","ut",174,0)
- Q
-"RTN","ut",175,0)
- ;
-"RTN","ut",176,0)
-VERBOSE1(%utETRY,%utI) ; Print out the entry point info
-"RTN","ut",177,0)
- ; ZEXCEPT: %ut - NEWED IN EN
-"RTN","ut",178,0)
- D SETIO
-"RTN","ut",179,0)
- W !,%utETRY(%utI) I $G(%utETRY(%utI,"NAME"))'="" W " - ",%utETRY(%utI,"NAME")
-"RTN","ut",180,0)
- D RESETIO
-"RTN","ut",181,0)
- Q
-"RTN","ut",182,0)
-CHKTF(XTSTVAL,XTERMSG) ; Entry point for checking True or False values
-"RTN","ut",183,0)
- ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
-"RTN","ut",184,0)
- ; ZEXCEPT: %ut - NEWED IN EN
-"RTN","ut",185,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
-"RTN","ut",186,0)
- I '$D(XTSTVAL) D NVLDARG Q
-"RTN","ut",187,0)
- I $G(XTERMSG)="" S XTERMSG="no failure message provided"
-"RTN","ut",188,0)
  S %ut("CHK")=$G(%ut("CHK"))+1
-"RTN","ut",189,0)
+"RTN","ut",172,0)
  I '$D(%utGUI) D
-"RTN","ut",190,0)
- . D SETIO
-"RTN","ut",191,0)
+"RTN","ut",173,0)
+ . D SETIO^%ut1
+"RTN","ut",174,0)
  . I 'XTSTVAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " D
-"RTN","ut",192,0)
+"RTN","ut",175,0)
  . . W XTERMSG,! S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
-"RTN","ut",193,0)
+"RTN","ut",176,0)
  . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-"RTN","ut",194,0)
+"RTN","ut",177,0)
  . . Q
-"RTN","ut",195,0)
+"RTN","ut",178,0)
  . I XTSTVAL W "."
-"RTN","ut",196,0)
- . D RESETIO
-"RTN","ut",197,0)
+"RTN","ut",179,0)
+ . D RESETIO^%ut1
+"RTN","ut",180,0)
  . Q
-"RTN","ut",198,0)
+"RTN","ut",181,0)
  I $D(%utGUI),'XTSTVAL S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG,%ut("FAIL")=%ut("FAIL")+1
-"RTN","ut",199,0)
+"RTN","ut",182,0)
  Q
-"RTN","ut",200,0)
+"RTN","ut",183,0)
  ;
-"RTN","ut",201,0)
+"RTN","ut",184,0)
 CHKEQ(XTEXPECT,XTACTUAL,XTERMSG) ; Entry point for checking values to see if they are EQUAL
-"RTN","ut",202,0)
+"RTN","ut",185,0)
  N FAILMSG
-"RTN","ut",203,0)
+"RTN","ut",186,0)
  ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
-"RTN","ut",204,0)
+"RTN","ut",187,0)
  ; ZEXCEPT: %ut  -- NEWED IN EN
-"RTN","ut",205,0)
+"RTN","ut",188,0)
  ; ZEXCEPT: XTGUISEP - newed in GUINEXT
-"RTN","ut",206,0)
- I '$D(XTEXPECT)!'$D(XTACTUAL) D NVLDARG Q  ; JLI 140824 changed from AND to OR, since both necessary, but only one might be entered
-"RTN","ut",207,0)
+"RTN","ut",189,0)
+ I '$D(XTEXPECT)!'$D(XTACTUAL) D NVLDARG^%ut1("CHKEQ") Q
+"RTN","ut",190,0)
  S XTACTUAL=$G(XTACTUAL),XTEXPECT=$G(XTEXPECT)
-"RTN","ut",208,0)
+"RTN","ut",191,0)
  I $G(XTERMSG)="" S XTERMSG="no failure message provided"
-"RTN","ut",209,0)
+"RTN","ut",192,0)
  S %ut("CHK")=%ut("CHK")+1
-"RTN","ut",210,0)
+"RTN","ut",193,0)
  I XTEXPECT'=XTACTUAL S FAILMSG="<"_XTEXPECT_"> vs <"_XTACTUAL_"> - "
-"RTN","ut",211,0)
+"RTN","ut",194,0)
  I '$D(%utGUI) D
-"RTN","ut",212,0)
- . D SETIO
-"RTN","ut",213,0)
+"RTN","ut",195,0)
+ . D SETIO^%ut1
+"RTN","ut",196,0)
  . I XTEXPECT'=XTACTUAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W FAILMSG,XTERMSG,! D
-"RTN","ut",214,0)
+"RTN","ut",197,0)
  . . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
-"RTN","ut",215,0)
+"RTN","ut",198,0)
      . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-"RTN","ut",216,0)
+"RTN","ut",199,0)
  . . Q
-"RTN","ut",217,0)
+"RTN","ut",200,0)
  . E  W "."
-"RTN","ut",218,0)
- . D RESETIO
-"RTN","ut",219,0)
+"RTN","ut",201,0)
+ . D RESETIO^%ut1
+"RTN","ut",202,0)
  . Q
-"RTN","ut",220,0)
+"RTN","ut",203,0)
  I $D(%utGUI),XTEXPECT'=XTACTUAL S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_FAILMSG_XTERMSG,%ut("FAIL")=%ut("FAIL")+1
-"RTN","ut",221,0)
+"RTN","ut",204,0)
  Q
+"RTN","ut",205,0)
+ ;
+"RTN","ut",206,0)
+FAIL(XTERMSG) ; Entry point for generating a failure message
+"RTN","ut",207,0)
+ D FAIL^%ut1($G(XTERMSG))
+"RTN","ut",208,0)
+ Q
+"RTN","ut",209,0)
+ ;
+"RTN","ut",210,0)
+SUCCEED ; Entry point for forcing a success (Thx David Whitten)
+"RTN","ut",211,0)
+ ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
+"RTN","ut",212,0)
+ ; ZEXCEPT: %ut - NEWED IN EN
+"RTN","ut",213,0)
+ ; Switch IO and write out the dot for activity
+"RTN","ut",214,0)
+ I '$D(%utGUI) D
+"RTN","ut",215,0)
+ . D SETIO^%ut1
+"RTN","ut",216,0)
+ . W "."
+"RTN","ut",217,0)
+ . D RESETIO^%ut1
+"RTN","ut",218,0)
+ ;
+"RTN","ut",219,0)
+ ; Increment test counter
+"RTN","ut",220,0)
+ S %ut("CHK")=%ut("CHK")+1
+"RTN","ut",221,0)
+ QUIT
 "RTN","ut",222,0)
  ;
 "RTN","ut",223,0)
-FAIL(XTERMSG) ; Entry point for generating a failure message
+CHKLEAKS(%utCODE,%utLOC,%utINPT) ; functionality to check for variable leaks on executing a section of code
 "RTN","ut",224,0)
- ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+ ; %utCODE - A string that specifies the code that is to be XECUTED and checked for leaks.
 "RTN","ut",225,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ ;            this should be a complete piece of code (e.g., "S X=$$NOW^XLFDT()" or "D EN^%ut(""ROUNAME"")")
 "RTN","ut",226,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ ; %utLOC  - A string that is used to indicate the code tested for variable leaks
 "RTN","ut",227,0)
- I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+ ; %utINPT - An optional variable which may be passed by reference.  This may
 "RTN","ut",228,0)
- S %ut("CHK")=%ut("CHK")+1
+ ;           be used to pass any variable values, etc. into the code to be
 "RTN","ut",229,0)
- I '$D(%utGUI) D
+ ;           XECUTED.  In this case, set the subscript to the variable name and the
 "RTN","ut",230,0)
- . D SETIO
+ ;           value of the subscripted variable to the desired value of the subscript.
 "RTN","ut",231,0)
- . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+ ;              e.g., (using NAME as my current namespace)
 "RTN","ut",232,0)
- . . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
+ ;                   S CODE="S %utINPT=$$ENTRY^ROUTINE(ZZVALUE1,ZZVALUE2)"
 "RTN","ut",233,0)
- . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+ ;                   S NAMELOC="ENTRY^ROUTINE leak test"   (or simply "ENTRY^ROUTINE")
 "RTN","ut",234,0)
- . . Q
+ ;                   S NAMEINPT("ZZVALUE1")=ZZVALUE1
 "RTN","ut",235,0)
- . D RESETIO
+ ;                   S NAMEINPT("ZZVALUE2")=ZZVALUE2
 "RTN","ut",236,0)
- . Q
+ ;                   D CHKLEAKS^%ut(CODE,NAMELOC,.NAMEINPT)
 "RTN","ut",237,0)
- I $D(%utGUI) S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG,%ut("FAIL")=%ut("FAIL")+1
+ ;
 "RTN","ut",238,0)
- Q
+ ;           If part of a unit test, any leaked variables in ENTRY^ROUTINE which result
 "RTN","ut",239,0)
-SUCCEED ; Entry point for forcing a success (Thx David Whitten)
+ ;           from running the code with the variables indicated will be shown as FAILUREs.
 "RTN","ut",240,0)
- ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
+ ;
 "RTN","ut",241,0)
- ; ZEXCEPT: %ut - NEWED IN EN
+ ;           If called outside of a unit test, any leaked variables will be printed to the
 "RTN","ut",242,0)
- ; Switch IO and write out the dot for activity
+ ;           current device.
 "RTN","ut",243,0)
- I '$D(%utGUI) D
+ ;
 "RTN","ut",244,0)
- . D SETIO
+ N (%utCODE,%utLOC,%utINPT,DUZ,IO,U,%utERRL,%ut,%utGUI,%utERR,%utI,%utJ,%utK,%utLIST,%utROU,%utSTRT,XTGUISEP)
 "RTN","ut",245,0)
- . W "."
+ ; ZEXCEPT: %ut - part of exclusive NEW TESTS FOR EXISTENCE ONLY
 "RTN","ut",246,0)
- . D RESETIO
+ ; ZEXCEPT: %utVAR - handled by exclusive NEW
 "RTN","ut",247,0)
  ;
 "RTN","ut",248,0)
- ; Increment test counter
-"RTN","ut",249,0)
- S %ut("CHK")=%ut("CHK")+1
-"RTN","ut",250,0)
- QUIT
-"RTN","ut",251,0)
- ;
-"RTN","ut",252,0)
-CHKLEAKS(%utCODE,%utLOC,%utINPT) ; functionality to check for variable leaks on executing a section of code
-"RTN","ut",253,0)
- ; %utCODE - A string that specifies the code that is to be XECUTED and checked for leaks.
-"RTN","ut",254,0)
- ;            this should be a complete piece of code (e.g., "S X=$$NOW^XLFDT()" or "D EN^%ut(""ROUNAME"")")
-"RTN","ut",255,0)
- ; %utLOC  - A string that is used to indicate the code tested for variable leaks
-"RTN","ut",256,0)
- ; %utINPT - An optional variable which may be passed by reference.  This may
-"RTN","ut",257,0)
- ;           be used to pass any variable values, etc. into the code to be
-"RTN","ut",258,0)
- ;           XECUTED.  In this case, set the subscript to the variable name and the
-"RTN","ut",259,0)
- ;           value of the subscripted variable to the desired value of the subscript.
-"RTN","ut",260,0)
- ;              e.g., (using NAME as my current namespace)
-"RTN","ut",261,0)
- ;                   S CODE="S %utINPT=$$ENTRY^ROUTINE(ZZVALUE1,ZZVALUE2)"
-"RTN","ut",262,0)
- ;                   S NAMELOC="ENTRY^ROUTINE leak test"   (or simply "ENTRY^ROUTINE")
-"RTN","ut",263,0)
- ;                   S NAMEINPT("ZZVALUE1")=ZZVALUE1
-"RTN","ut",264,0)
- ;                   S NAMEINPT("ZZVALUE2")=ZZVALUE2
-"RTN","ut",265,0)
- ;                   D CHKLEAKS^%ut(CODE,NAMELOC,.NAMEINPT)
-"RTN","ut",266,0)
- ;
-"RTN","ut",267,0)
- ;           If part of a unit test, any leaked variables in ENTRY^ROUTINE which result
-"RTN","ut",268,0)
- ;           from running the code with the variables indicated will be shown as FAILUREs.
-"RTN","ut",269,0)
- ;
-"RTN","ut",270,0)
- ;           If called outside of a unit test, any leaked variables will be printed to the
-"RTN","ut",271,0)
- ;           current device.
-"RTN","ut",272,0)
- ;
-"RTN","ut",273,0)
- N (%utCODE,%utLOC,%utINPT,DUZ,IO,U,%utERRL,%ut,%utGUI,%utERR,%utI,%utJ,%utK,%utLIST,%utROU,%utSTRT,XTGUISEP)
-"RTN","ut",274,0)
- ; ZEXCEPT: %ut - part of exclusive NEW TESTS FOR EXISTENCE ONLY
-"RTN","ut",275,0)
- ; ZEXCEPT: %utVAR - handled by exclusive NEW
-"RTN","ut",276,0)
- ;
-"RTN","ut",277,0)
  ; ACTIVATE ANY VARIABLES PASSED AS SUBSCRIPTS TO %utINPT TO THEIR VALUES
-"RTN","ut",278,0)
+"RTN","ut",249,0)
  S %utVAR=" " F  S %utVAR=$O(%utINPT(%utVAR)) Q:%utVAR=""  S (@%utVAR)=%utINPT(%utVAR)
-"RTN","ut",279,0)
+"RTN","ut",250,0)
  X %utCODE
-"RTN","ut",280,0)
+"RTN","ut",251,0)
  N ZZUTVAR S ZZUTVAR="%"
-"RTN","ut",281,0)
+"RTN","ut",252,0)
  I $G(%ut)=1 D
-"RTN","ut",282,0)
+"RTN","ut",253,0)
  . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) D FAIL^%ut(%utLOC_" VARIABLE LEAK: "_ZZUTVAR)
-"RTN","ut",283,0)
+"RTN","ut",254,0)
  . F  S ZZUTVAR=$O(@ZZUTVAR) Q:ZZUTVAR=""  I $E(ZZUTVAR,1,3)'="%ut",'$D(%utINPT(ZZUTVAR)),",DUZ,IO,U,DTIME,ZZUTVAR,DT,%ut,XTGUISEP,"'[(","_ZZUTVAR_",") D FAIL^%ut(%utLOC_" VARIABLE LEAK: "_ZZUTVAR)
-"RTN","ut",284,0)
+"RTN","ut",255,0)
  . Q
-"RTN","ut",285,0)
+"RTN","ut",256,0)
  I '($G(%ut)=1) D
-"RTN","ut",286,0)
+"RTN","ut",257,0)
  . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) W !,%utLOC_" VARIABLE LEAK: "_ZZUTVAR
-"RTN","ut",287,0)
+"RTN","ut",258,0)
  . F  S ZZUTVAR=$O(@ZZUTVAR) Q:ZZUTVAR=""  I $E(ZZUTVAR,1,3)'="%ut",'$D(%utINPT(ZZUTVAR)),",DUZ,IO,U,DTIME,ZZUTVAR,DT,%ut,XTGUISEP,"'[(","_ZZUTVAR_",") W !,%utLOC_" VARIABLE LEAK: "_ZZUTVAR
-"RTN","ut",288,0)
+"RTN","ut",259,0)
  . Q
-"RTN","ut",289,0)
+"RTN","ut",260,0)
  Q
+"RTN","ut",261,0)
+ ;
+"RTN","ut",262,0)
+ERROR ; record errors
+"RTN","ut",263,0)
+ ; ZEXCEPT: %utERRL,%utGUI,%utERR -CREATED IN SETUP, KILLED IN END
+"RTN","ut",264,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",265,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut",266,0)
+ S %ut("CHK")=%ut("CHK")+1
+"RTN","ut",267,0)
+ I '$D(%utGUI) D ERROR1
+"RTN","ut",268,0)
+ I $D(%utGUI) D
+"RTN","ut",269,0)
+ . S %ut("CNT")=%ut("CNT")+1
+"RTN","ut",270,0)
+ . S %utERR=%utERR+1
+"RTN","ut",271,0)
+ . S @%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"ERROR"_XTGUISEP_$S(+$SY=47:$ZS,1:$ZE)
+"RTN","ut",272,0)
+ . Q
+"RTN","ut",273,0)
+ S @($S(+$SY=47:"$ZS",1:"$ZE")_"="_""""""),$EC=""
+"RTN","ut",274,0)
+ Q
+"RTN","ut",275,0)
+ ;
+"RTN","ut",276,0)
+ERROR1 ;
+"RTN","ut",277,0)
+ I $G(%ut("BREAK")) BREAK  ; if we are asked to break upon error, please do so!
+"RTN","ut",278,0)
+ ; ZEXCEPT: %utERRL -CREATED IN SETUP, KILLED IN END
+"RTN","ut",279,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",280,0)
+ D SETIO^%ut1
+"RTN","ut",281,0)
+ W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - Error: " W $S(+$SY=47:$ZS,1:$ZE),! D
+"RTN","ut",282,0)
+ . S %ut("ERRN")=%ut("ERRN")+1,%utERRL(%ut("ERRN"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=$S(+$SY=47:$ZS,1:$ZE),%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
+"RTN","ut",283,0)
+ . Q
+"RTN","ut",284,0)
+ D RESETIO^%ut1
+"RTN","ut",285,0)
+ Q
+"RTN","ut",286,0)
+ ;
+"RTN","ut",287,0)
+ISUTEST() ; .SUPPORTED API TO DETERMINE IF CURRENTLY IN UNIT TEST
+"RTN","ut",288,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",289,0)
+ Q $G(%ut)=1
 "RTN","ut",290,0)
  ;
 "RTN","ut",291,0)
-NVLDARG ; generate message for invalid arguments to test
+PICKSET ; .OPT Interactive selection of MUnit Test Group
 "RTN","ut",292,0)
- N XTERMSG
+ N DIC,Y,%utROU,%utLIST,DIR
 "RTN","ut",293,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ I '$$ISUTEST^%ut() S DIC=17.9001,DIC(0)="AEQM" D ^DIC Q:Y'>0  W ! D GETSET(+Y,.%utROU,.%utLIST) N DIC,Y,%ut D SETUT D EN1(.%utROU,%utLIST) S DIR(0)="EA",DIR("A")="Enter RETURN to continue:" D ^DIR K DIR
 "RTN","ut",294,0)
- ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+ Q
 "RTN","ut",295,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ ;
 "RTN","ut",296,0)
- S XTERMSG="NO VALUES INPUT TO CHKEQ^%ut - no evaluation possible"
+RUNSET(SETNAME,VERBOSE) ; .SR Run with Specified Selection of MUnit Test Group
 "RTN","ut",297,0)
- I '$D(%utGUI) D
+ N Y,%utROU,%utLIST,%utVERB
 "RTN","ut",298,0)
- . D SETIO
+ Q:$G(SETNAME)=""
 "RTN","ut",299,0)
- . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+ S %utVERB=$G(VERBOSE,0)
 "RTN","ut",300,0)
- . . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
+ S Y=+$$FIND1^DIC(17.9001,"","X",SETNAME) Q:Y'>0
 "RTN","ut",301,0)
- . . Q
+ D GETSET(Y,.%utROU,.%utLIST)
 "RTN","ut",302,0)
- . D RESETIO
+ N Y,SETNAME,%ut
 "RTN","ut",303,0)
- . Q
+ D SETUT
 "RTN","ut",304,0)
- I $D(%utGUI) S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG,%ut("FAIL")=%ut("FAIL")+1
+ D EN1(.%utROU,%utLIST)
 "RTN","ut",305,0)
  Q
 "RTN","ut",306,0)
  ;
 "RTN","ut",307,0)
-ERROR ; record errors
+ ; DOSET CAN BE USED TO RUN A SET OF TESTS BASED ON THE IEN IN THE MUNIT TEST GROUP file (#17.9001)
 "RTN","ut",308,0)
- ; ZEXCEPT: %utERRL,%utGUI,%utERR -CREATED IN SETUP, KILLED IN END
+DOSET(IEN,%utVERB) ; 140731 JLI added %utVERB as a second argument
 "RTN","ut",309,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ ; IEN - Internal entry number for selected set of tests in the MUNIT TEST GROUP file (#17.9001)
 "RTN","ut",310,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ ; %utVERB - optional input that indicates verbose output is permitted
 "RTN","ut",311,0)
- S %ut("CHK")=%ut("CHK")+1
+ ;
 "RTN","ut",312,0)
- I '$D(%utGUI) D ERROR1
+ N %utROU,%utLIST
 "RTN","ut",313,0)
- I $D(%utGUI) D
+ I '$D(%utVERB) S %utVERB=0
 "RTN","ut",314,0)
- . S %ut("CNT")=%ut("CNT")+1
+ S %utLIST=0
 "RTN","ut",315,0)
- . S %utERR=%utERR+1
+ D GETSET($G(IEN),.%utROU,.%utLIST)
 "RTN","ut",316,0)
- . S @%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"ERROR"_XTGUISEP_$S(+$SY=47:$ZS,1:$ZE)
+ I %utLIST>0  N IEN,%ut D SETUT,EN1(.%utROU,%utLIST)
 "RTN","ut",317,0)
- . Q
+ Q
 "RTN","ut",318,0)
- S @($S(+$SY=47:"$ZS",1:"$ZE")_"="_""""""),$EC=""
+ ;
 "RTN","ut",319,0)
- Q
+GETSET(IEN,%utROU,%utLIST) ;  JLI 140731 - called from PICKSET, RUNSET, DOSET, GUISET
 "RTN","ut",320,0)
- ;
+ N IENS,%utROOT
 "RTN","ut",321,0)
-ERROR1 ;
+ S IENS=IEN_"," D GETS^DIQ(17.9001,IENS,"1*","","%utROOT")
 "RTN","ut",322,0)
- I $G(%ut("BREAK")) BREAK  ; if we are asked to break upon error, please do so!
+ S %utLIST=0,IENS="" F  S IENS=$O(%utROOT(17.90011,IENS)) Q:IENS=""  S %utLIST=%utLIST+1,%utROU(%utLIST)=%utROOT(17.90011,IENS,.01)
 "RTN","ut",323,0)
- ; ZEXCEPT: %utERRL -CREATED IN SETUP, KILLED IN END
+ Q
 "RTN","ut",324,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ ;
 "RTN","ut",325,0)
- D SETIO
+COV(NMSP,COVCODE,VERBOSITY) ; simply make it callable from %ut1 as well (along with other APIs) JLI 150101
 "RTN","ut",326,0)
- W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - Error: " W $S(+$SY=47:$ZS,1:$ZE),! D
+ D COV^%ut1(NMSP,COVCODE,+$G(VERBOSITY)) ; see COV^%ut1 for description of arguments
 "RTN","ut",327,0)
- . S %ut("ERRN")=%ut("ERRN")+1,%utERRL(%ut("ERRN"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=$S(+$SY=47:$ZS,1:$ZE),%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
+ Q
 "RTN","ut",328,0)
- . Q
+ ;
 "RTN","ut",329,0)
- D RESETIO
+MULTAPIS(TESTROUS) ; .SR - RUN TESTS FOR SPECIFIED ROUTINES AND ENTRY POINTS
 "RTN","ut",330,0)
- Q
+ ; input - TESTROUS - passed by reference
 "RTN","ut",331,0)
-SETIO ; Set M-Unit Device to write the results to...
+ ; see TESTONLY in routine %utcover for full description of TESTROUS argument
 "RTN","ut",332,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ D MULTAPIS^%utcover(.TESTROUS) ; RUN TESTS FOR SPECIFIED ROUTINES AND ENTRY POINTS
 "RTN","ut",333,0)
- I $IO'=%ut("IO") S (IO(0),%ut("DEV","OLD"))=$IO USE %ut("IO") SET IO=$IO
-"RTN","ut",334,0)
- QUIT
-"RTN","ut",335,0)
- ;
-"RTN","ut",336,0)
-RESETIO ; Reset $IO back to the original device if we changed it.
-"RTN","ut",337,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"RTN","ut",338,0)
- I $D(%ut("DEV","OLD")) S IO(0)=%ut("IO") U %ut("DEV","OLD") S IO=$IO K %ut("DEV","OLD")
-"RTN","ut",339,0)
- QUIT
-"RTN","ut",340,0)
- ;
-"RTN","ut",341,0)
-ISUTEST() ; .SUPPORTED API TO DETERMINE IF CURRENTLY IN UNIT TEST
-"RTN","ut",342,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"RTN","ut",343,0)
- Q $G(%ut)=1
-"RTN","ut",344,0)
- ;
-"RTN","ut",345,0)
-PICKSET ; .OPT Interactive selection of MUnit Test Group
-"RTN","ut",346,0)
- N DIC,Y,%utROU,%utLIST,DIR
-"RTN","ut",347,0)
- S DIC=17.9001,DIC(0)="AEQM" D ^DIC Q:Y'>0  W !
-"RTN","ut",348,0)
- D GETSET(+Y,.%utROU,.%utLIST)
-"RTN","ut",349,0)
- N DIC,Y,%ut
-"RTN","ut",350,0)
- D SETUT
-"RTN","ut",351,0)
- D EN1(.%utROU,%utLIST)
-"RTN","ut",352,0)
- S DIR(0)="EA",DIR("A")="Enter RETURN to continue:" D ^DIR K DIR
-"RTN","ut",353,0)
  Q
-"RTN","ut",354,0)
+"RTN","ut",334,0)
  ;
+"RTN","ut",335,0)
+COVERAGE(ROUNMSP,TESTROUS,XCLDROUS,RESLTLVL)    ;.SR - run coverage analysis for multiple routines and entry points
+"RTN","ut",336,0)
+ ; input ROUNMSP
+"RTN","ut",337,0)
+ ; input TESTROUS - passed by reference
+"RTN","ut",338,0)
+ ; input XCLDROUS - passed by reference
+"RTN","ut",339,0)
+ ; input RESLTLVL
+"RTN","ut",340,0)
+ ; see COVERAGE in routine %utcover for full description of arguments
+"RTN","ut",341,0)
+ D COVERAGE^%utcover(ROUNMSP,.TESTROUS,.XCLDROUS,+$G(RESLTLVL))
+"RTN","ut",342,0)
+ Q
+"RTN","ut",343,0)
+ ;
+"RTN","ut",344,0)
+GETUTVAL(UTDATA) ; .SR - returns totals for current unit test data in cumulative totals
+"RTN","ut",345,0)
+ ; usage   D GETUTVAL^%ut(.UTDATA)
+"RTN","ut",346,0)
+ ; input - UTDATA - passed by reference
+"RTN","ut",347,0)
+ ;
+"RTN","ut",348,0)
+ ; subscripted values returned:
+"RTN","ut",349,0)
+ ;   1) cumulative number of routines run;  2) cumulative number of entry tags;
+"RTN","ut",350,0)
+ ;   3) cumulative number of tests;         4) cummulative number of failures;
+"RTN","ut",351,0)
+ ;   5) cumulative number of errors
+"RTN","ut",352,0)
+ N VALS,I,VAL
+"RTN","ut",353,0)
+ S VALS=$G(^TMP("%ut",$J,"UTVALS")) I VALS="" Q
+"RTN","ut",354,0)
+ F I=1:1 S VAL=$P(VALS,U,I) Q:VAL=""  S UTDATA(I)=$G(UTDATA(I))+VAL
 "RTN","ut",355,0)
-RUNSET(SETNAME,VERBOSE) ; .SR Run with Specified Selection of MUnit Test Group
+ K ^TMP("%ut",$J,"UTVALS")
 "RTN","ut",356,0)
- N Y,%utROU,%utLIST,%utVERB
+ Q
 "RTN","ut",357,0)
- Q:$G(SETNAME)=""
+ ;
 "RTN","ut",358,0)
- S %utVERB=$G(VERBOSE,0)
+LSTUTVAL(UTDATA) ; .SR - lists cumulative totals in UTDATA array
 "RTN","ut",359,0)
- S Y=+$$FIND1^DIC(17.9001,"","X",SETNAME) Q:Y'>0
+ ; usage   D LSTUTVAL^%ut(.UTDATA)
 "RTN","ut",360,0)
- D GETSET(Y,.%utROU,.%utLIST)
+ ; input - UTDATA - passed by reference
 "RTN","ut",361,0)
- N Y,SETNAME,%ut
+ W !!!,"------------ SUMMARY ------------"
 "RTN","ut",362,0)
- D SETUT
+ W !,"Ran ",UTDATA(1)," Routine",$S(UTDATA(1)>1:"s",1:""),", ",UTDATA(2)," Entry Tag",$S(UTDATA(2)>1:"s",1:"")
 "RTN","ut",363,0)
- D EN1(.%utROU,%utLIST)
+ W !,"Checked ",UTDATA(3)," test",$S(UTDATA(3)>1:"s",1:""),", with ",UTDATA(4)," failure",$S(UTDATA(4)'=1:"s",1:"")," and encountered ",UTDATA(5)," error",$S(UTDATA(5)'=1:"s",1:""),"."
 "RTN","ut",364,0)
  Q
 "RTN","ut",365,0)
  ;
 "RTN","ut",366,0)
- ; DOSET CAN BE USED TO RUN A SET OF TESTS BASED ON THE IEN IN THE MUNIT TEST GROUP file (#17.9001)
+ ;
 "RTN","ut",367,0)
-DOSET(IEN,%utVERB) ; 140731 JLI added %utVERB as a second argument
-"RTN","ut",368,0)
- ; IEN - Internal entry number for selected set of tests in the MUNIT TEST GROUP file (#17.9001)
-"RTN","ut",369,0)
- ; %utVERB - optional input that indicates verbose output is permitted
-"RTN","ut",370,0)
- ;
-"RTN","ut",371,0)
- N %utROU,%utLIST
-"RTN","ut",372,0)
- I '$D(%utVERB) S %utVERB=0
-"RTN","ut",373,0)
- S %utLIST=0
-"RTN","ut",374,0)
- D GETSET($G(IEN),.%utROU,.%utLIST)
-"RTN","ut",375,0)
- I %utLIST>0  N IEN,%ut D SETUT,EN1(.%utROU,%utLIST)
-"RTN","ut",376,0)
- Q
-"RTN","ut",377,0)
- ;
-"RTN","ut",378,0)
-GETSET(IEN,%utROU,%utLIST) ;  JLI 140731 - called from PICKSET, RUNSET, DOSET, GUISET
-"RTN","ut",379,0)
- N IENS,%utROOT
-"RTN","ut",380,0)
- S IENS=IEN_"," D GETS^DIQ(17.9001,IENS,"1*","","%utROOT")
-"RTN","ut",381,0)
- S %utLIST=0,IENS="" F  S IENS=$O(%utROOT(17.90011,IENS)) Q:IENS=""  S %utLIST=%utLIST+1,%utROU(%utLIST)=%utROOT(17.90011,IENS,.01)
-"RTN","ut",382,0)
- Q
-"RTN","ut",383,0)
- ;
-"RTN","ut",384,0)
 GUISET(%utRSLT,XTSET) ; Entry point for GUI start with selected Test Set IEN - called by %ut-TEST GROUP LOAD rpc
-"RTN","ut",385,0)
+"RTN","ut",368,0)
  N %utROU,%utLIST,%ut
-"RTN","ut",386,0)
+"RTN","ut",369,0)
  D SETUT
-"RTN","ut",387,0)
+"RTN","ut",370,0)
  S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
-"RTN","ut",388,0)
+"RTN","ut",371,0)
  D GETSET(XTSET,.%utROU,.%utLIST)
-"RTN","ut",389,0)
+"RTN","ut",372,0)
  D GETLIST(.%utROU,%utLIST,%ut("RSLT"))
-"RTN","ut",390,0)
+"RTN","ut",373,0)
  S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
-"RTN","ut",391,0)
+"RTN","ut",374,0)
  S %utRSLT=%ut("RSLT")
-"RTN","ut",392,0)
+"RTN","ut",375,0)
  Q
-"RTN","ut",393,0)
+"RTN","ut",376,0)
  ;
-"RTN","ut",394,0)
+"RTN","ut",377,0)
 GUILOAD(%utRSLT,%utROUN) ; Entry point for GUI start with %utROUN containing primary routine name - called by %ut-TEST LOAD rpc
-"RTN","ut",395,0)
+"RTN","ut",378,0)
  N %utROU,%ut
-"RTN","ut",396,0)
+"RTN","ut",379,0)
  D SETUT
-"RTN","ut",397,0)
+"RTN","ut",380,0)
  S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
-"RTN","ut",398,0)
+"RTN","ut",381,0)
  S %utROU(1)=%utROUN
-"RTN","ut",399,0)
+"RTN","ut",382,0)
  D GETLIST(.%utROU,1,%ut("RSLT"))
-"RTN","ut",400,0)
+"RTN","ut",383,0)
  S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
-"RTN","ut",401,0)
+"RTN","ut",384,0)
  S %utRSLT=%ut("RSLT")
-"RTN","ut",402,0)
+"RTN","ut",385,0)
  Q
-"RTN","ut",403,0)
+"RTN","ut",386,0)
  ;
-"RTN","ut",404,0)
+"RTN","ut",387,0)
 GETLIST(%utROU,%utLIST,%utRSLT) ; called from GUISET, GUILOAD
-"RTN","ut",405,0)
+"RTN","ut",388,0)
  N I,%utROUL,%utROUN,%ut,XTCOMNT,XTVALUE,%utCNT
-"RTN","ut",406,0)
+"RTN","ut",389,0)
  S XTVALUE=$NA(^TMP("GUI-MUNIT",$J)) K @XTVALUE
-"RTN","ut",407,0)
+"RTN","ut",390,0)
  S %utCNT=0,XTCOMNT=""
-"RTN","ut",408,0)
+"RTN","ut",391,0)
  D GETTREE^%ut1(.%utROU,%utLIST)
-"RTN","ut",409,0)
+"RTN","ut",392,0)
  F I=1:1 Q:'$D(%utROU(I))  S %utROUL(%utROU(I))=""
-"RTN","ut",410,0)
+"RTN","ut",393,0)
  S %utROUN="" F  S %utROUN=$O(%utROUL(%utROUN)) Q:%utROUN=""  D LOAD(%utROUN,.%utCNT,XTVALUE,XTCOMNT,.%utROUL)
-"RTN","ut",411,0)
+"RTN","ut",394,0)
  M @%utRSLT=@XTVALUE
-"RTN","ut",412,0)
+"RTN","ut",395,0)
  K @%utRSLT@("SHUTDOWN")
-"RTN","ut",413,0)
+"RTN","ut",396,0)
  K @%utRSLT@("STARTUP")
-"RTN","ut",414,0)
+"RTN","ut",397,0)
  S @XTVALUE@("LASTROU")="" ; Use this to keep track of place in routines
+"RTN","ut",398,0)
+ Q
+"RTN","ut",399,0)
+ ;
+"RTN","ut",400,0)
+ ; generate list of unit test routines, entry points and comments on test for entry point
+"RTN","ut",401,0)
+LOAD(%utROUN,%utNCNT,XTVALUE,XTCOMNT,%utROUL) ; called from GETLIST, and recursively from LOAD
+"RTN","ut",402,0)
+ I $T(@("^"_%utROUN))="" S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_"^^*** ERROR - ROUTINE NAME NOT FOUND" Q
+"RTN","ut",403,0)
+ S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_U_XTCOMNT
+"RTN","ut",404,0)
+ ;N %utI,XTX1,XTX2,LINE
+"RTN","ut",405,0)
+ N %utI,XTX1,XTX2,LINE,LIST,I
+"RTN","ut",406,0)
+ ; 100622 JLI added code to identify STARTUP and TEARDOWN
+"RTN","ut",407,0)
+ I $T(@("STARTUP^"_%utROUN))'="",'$D(@XTVALUE@("STARTUP")) S @XTVALUE@("STARTUP")="STARTUP^"_%utROUN
+"RTN","ut",408,0)
+ I $T(@("SHUTDOWN^"_%utROUN))'="",'$D(@XTVALUE@("SHUTDOWN")) S @XTVALUE@("SHUTDOWN")="SHUTDOWN^"_%utROUN
+"RTN","ut",409,0)
+ ; JLI 140731 handle @TEST identified test tags
+"RTN","ut",410,0)
+ D NEWSTYLE^%ut1(.LIST,%utROUN)
+"RTN","ut",411,0)
+ F I=1:1:LIST S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_LIST(I)
+"RTN","ut",412,0)
+ ; JLI 140731 end of @TEST addition
+"RTN","ut",413,0)
+ F %utI=1:1 S LINE=$T(@("XTENT+"_%utI_"^"_%utROUN)) S XTX1=$P(LINE,";",3) Q:XTX1=""  S XTX2=$P(LINE,";",4),%utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_XTX1_U_XTX2
+"RTN","ut",414,0)
+ F %utI=1:1 S LINE=$T(@("XTROU+"_%utI_"^"_%utROUN)) S XTX1=$P(LINE,";",3) Q:XTX1=""  S XTCOMNT=$P(LINE,";",4) I '$D(%utROUL(XTX1)) S %utROUL(XTX1)="" D LOAD(XTX1,.%utNCNT,XTVALUE,XTCOMNT,.%utROUL)
 "RTN","ut",415,0)
  Q
 "RTN","ut",416,0)
  ;
 "RTN","ut",417,0)
- ; generate list of unit test routines, entry points and comments on test for entry point
-"RTN","ut",418,0)
-LOAD(%utROUN,%utNCNT,XTVALUE,XTCOMNT,%utROUL) ; called from GETLIST, and recursively from LOAD
-"RTN","ut",419,0)
- I $T(@("^"_%utROUN))="" S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_"^^*** ERROR - ROUTINE NAME NOT FOUND" Q
-"RTN","ut",420,0)
- S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_U_XTCOMNT
-"RTN","ut",421,0)
- ;N %utI,XTX1,XTX2,LINE
-"RTN","ut",422,0)
- N %utI,XTX1,XTX2,LINE,LIST,I
-"RTN","ut",423,0)
- ; 100622 JLI added code to identify STARTUP and TEARDOWN
-"RTN","ut",424,0)
- I $T(@("STARTUP^"_%utROUN))'="",'$D(@XTVALUE@("STARTUP")) S @XTVALUE@("STARTUP")="STARTUP^"_%utROUN
-"RTN","ut",425,0)
- I $T(@("SHUTDOWN^"_%utROUN))'="",'$D(@XTVALUE@("SHUTDOWN")) S @XTVALUE@("SHUTDOWN")="SHUTDOWN^"_%utROUN
-"RTN","ut",426,0)
- ; JLI 140731 handle @TEST identified test tags
-"RTN","ut",427,0)
- D NEWSTYLE^%ut1(.LIST,%utROUN)
-"RTN","ut",428,0)
- F I=1:1:LIST S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_LIST(I)
-"RTN","ut",429,0)
- ; JLI 140731 end of @TEST addition
-"RTN","ut",430,0)
- F %utI=1:1 S LINE=$T(@("XTENT+"_%utI_"^"_%utROUN)) S XTX1=$P(LINE,";",3) Q:XTX1=""  S XTX2=$P(LINE,";",4),%utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_XTX1_U_XTX2
-"RTN","ut",431,0)
- F %utI=1:1 S LINE=$T(@("XTROU+"_%utI_"^"_%utROUN)) S XTX1=$P(LINE,";",3) Q:XTX1=""  S XTCOMNT=$P(LINE,";",4) I '$D(%utROUL(XTX1)) S %utROUL(XTX1)="" D LOAD(XTX1,.%utNCNT,XTVALUE,XTCOMNT,.%utROUL)
-"RTN","ut",432,0)
- Q
-"RTN","ut",433,0)
- ;
-"RTN","ut",434,0)
 GUINEXT(%utRSLT,%utLOC,XTGUISEP) ; Entry point for GUI execute next test - called by %ut-TEST NEXT rpc
-"RTN","ut",435,0)
+"RTN","ut",418,0)
  ; XTGUISEP - added 110719 to provide for changing separator for GUI
-"RTN","ut",436,0)
+"RTN","ut",419,0)
  ;            return from ^ to another value ~~^~~  so that data returned
-"RTN","ut",437,0)
+"RTN","ut",420,0)
  ;            is not affected by ^ values in the data - if not present
-"RTN","ut",438,0)
+"RTN","ut",421,0)
  ;            sets value to default ^
-"RTN","ut",439,0)
+"RTN","ut",422,0)
  N %utETRY,%utROUT,XTOLROU,XTVALUE,%utERR,%utGUI
-"RTN","ut",440,0)
+"RTN","ut",423,0)
  N %ut
-"RTN","ut",441,0)
+"RTN","ut",424,0)
  I $G(XTGUISEP)="" S XTGUISEP="^"
-"RTN","ut",442,0)
+"RTN","ut",425,0)
  D SETUT
-"RTN","ut",443,0)
+"RTN","ut",426,0)
  S %ut("LOC")=%utLOC
-"RTN","ut",444,0)
+"RTN","ut",427,0)
  S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
-"RTN","ut",445,0)
+"RTN","ut",428,0)
  S XTVALUE=$NA(^TMP("GUI-MUNIT",$J))
-"RTN","ut",446,0)
+"RTN","ut",429,0)
  S %ut("RSLT")=$NA(^TMP("GUINEXT",$J)) K @%ut("RSLT")
-"RTN","ut",447,0)
+"RTN","ut",430,0)
  S %utRSLT=%ut("RSLT")
-"RTN","ut",448,0)
+"RTN","ut",431,0)
  S %utETRY=$P(%utLOC,U),%utROUT=$P(%utLOC,U,2),XTOLROU=$G(@XTVALUE@("LASTROU"))
-"RTN","ut",449,0)
+"RTN","ut",432,0)
  S %utGUI=1
-"RTN","ut",450,0)
+"RTN","ut",433,0)
  S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
-"RTN","ut",451,0)
+"RTN","ut",434,0)
  ; I %utROUT'=XTOLROU D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ;140731 JLI - commented out
-"RTN","ut",452,0)
+"RTN","ut",435,0)
  ;D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ; 140731 JLI - replaced previous line - moves check for SHUTDOWN at end of processing
-"RTN","ut",453,0)
- D  I %utROUT="" S @%utRSLT@(1)="" Q  ; 140829 JLI - Have to leave XTVALUE intact, in case they simply run again for STARTUP, etc.
-"RTN","ut",454,0)
+"RTN","ut",436,0)
+ D  I %utROUT="" S @%utRSLT@(1)="" Q  ; 141018 JLI - Have to leave XTVALUE intact, in case they simply run again for STARTUP, etc.
+"RTN","ut",437,0)
  . I XTOLROU="",$D(@XTVALUE@("STARTUP")) D
-"RTN","ut",455,0)
+"RTN","ut",438,0)
  . . S %ut("LOC")=@XTVALUE@("STARTUP")
-"RTN","ut",456,0)
+"RTN","ut",439,0)
  . . N $ETRAP S $ETRAP="D ERROR^%ut"
-"RTN","ut",457,0)
+"RTN","ut",440,0)
  . . D @(@XTVALUE@("STARTUP"))
-"RTN","ut",458,0)
+"RTN","ut",441,0)
  . . Q
-"RTN","ut",459,0)
+"RTN","ut",442,0)
  . S @XTVALUE@("LASTROU")=%utROUT I %utROUT'="",$T(@("SETUP^"_%utROUT))'="" D
-"RTN","ut",460,0)
+"RTN","ut",443,0)
  . . S %ut("LOC")="SETUP^"_%utROUT
-"RTN","ut",461,0)
+"RTN","ut",444,0)
  . . N $ETRAP S $ETRAP="D ERROR^%ut"
-"RTN","ut",462,0)
+"RTN","ut",445,0)
  . . D @("SETUP^"_%utROUT)
-"RTN","ut",463,0)
+"RTN","ut",446,0)
  . . Q
-"RTN","ut",464,0)
+"RTN","ut",447,0)
  . I %utROUT="",$D(@XTVALUE@("SHUTDOWN")) D
-"RTN","ut",465,0)
+"RTN","ut",448,0)
  . . S %ut("LOC")=@XTVALUE@("SHUTDOWN")
-"RTN","ut",466,0)
+"RTN","ut",449,0)
  . . N $ETRAP S $ETRAP="D ERROR^%ut"
-"RTN","ut",467,0)
+"RTN","ut",450,0)
  . . D @(@XTVALUE@("SHUTDOWN"))
-"RTN","ut",468,0)
+"RTN","ut",451,0)
  . . Q
-"RTN","ut",469,0)
+"RTN","ut",452,0)
  . Q
-"RTN","ut",470,0)
+"RTN","ut",453,0)
  S %ut("LOC")=%utLOC
-"RTN","ut",471,0)
+"RTN","ut",454,0)
  S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
-"RTN","ut",472,0)
+"RTN","ut",455,0)
  D  ; to limit range of error trap so we continue through other tests
-"RTN","ut",473,0)
+"RTN","ut",456,0)
  . N $ETRAP S $ETRAP="D ERROR^%ut"
-"RTN","ut",474,0)
+"RTN","ut",457,0)
  . D @%ut("LOC")
-"RTN","ut",475,0)
+"RTN","ut",458,0)
  . Q
-"RTN","ut",476,0)
+"RTN","ut",459,0)
  I $T(@("TEARDOWN^"_%utROUT))'="" D
-"RTN","ut",477,0)
+"RTN","ut",460,0)
  . S %ut("LOC")="TEARDOWN^"_%utROUT
-"RTN","ut",478,0)
+"RTN","ut",461,0)
  . N $ETRAP S $ETRAP="D ERROR^%ut"
-"RTN","ut",479,0)
+"RTN","ut",462,0)
  . D @("TEARDOWN^"_%utROUT)
-"RTN","ut",480,0)
+"RTN","ut",463,0)
  . Q
-"RTN","ut",481,0)
+"RTN","ut",464,0)
  S @%ut("RSLT")@(1)=%ut("CHK")_XTGUISEP_(%ut("CNT")-1-%utERR)_XTGUISEP_%utERR
-"RTN","ut",482,0)
+"RTN","ut",465,0)
+ K ^TMP("%ut",$J,"UTVALS")
+"RTN","ut",466,0)
  Q
-"RTN","ut",483,0)
- ;
-"RTN","ut",484,0)
-TESTCOVR ; entry under coverage analysis
-"RTN","ut",485,0)
- D ENTRY^%uttcovr ; does analysis while running various unit tests
-"RTN","ut",486,0)
- Q
-"RTN","ut",487,0)
+"RTN","ut",467,0)
  ;
 "RTN","ut1")
-0^2^B87092328
+0^2^B226313375
 "RTN","ut1",1,0)
-%ut1 ;VEN/SMH/JLI - CONTINUATION OF M-UNIT PROCESSING ;09/10/14  14:27
+%ut1 ;VEN/SMH/JLI - CONTINUATION OF M-UNIT PROCESSING ;12/16/15  08:38
 "RTN","ut1",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","ut1",3,0)
- ;
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","ut1",4,0)
- ;following is original header from XTMUNIT1 in unreleased patch XT*7.3*81 VA code
+ ; Original routine authored by Joel L. Ivey as XTMUNIT1 while working for U.S. Department of Veterans Affairs 2003-2012
 "RTN","ut1",5,0)
- ;XTMUNIT1    ;JLI/FO-OAK-CONTINUATION OF UNIT TEST ROUTINE ;2014-04-17  5:26 PM
+ ; Includes addition of original COV entry and code related coverage analysis as well as other substantial additions authored by Sam Habiel 07/2013?04/2014
 "RTN","ut1",6,0)
- ;;7.3;TOOLKIT;**81**;APR 25 1995;Build 24
+ ; Additions and modifications made by Joel L. Ivey 05/2014-12/2015
 "RTN","ut1",7,0)
  ;
 "RTN","ut1",8,0)
- ;
+ D ^%utt6 ; runs unit tests from several perspectives
 "RTN","ut1",9,0)
- ; Original by Dr. Joel Ivey
-"RTN","ut1",10,0)
- ; Major contributions by Dr. Sam Habiel
-"RTN","ut1",11,0)
- ;
-"RTN","ut1",12,0)
- ; Changes:
-"RTN","ut1",13,0)
- ; 130726 SMH - Moved test collection logic from %utUNIT to here (multiple places)
-"RTN","ut1",14,0)
- ; 131218 SMH - dependence on XLFSTR removed
-"RTN","ut1",15,0)
- ; 131218 SMH - CHEKTEST refactored to use $TEXT instead of ^%ZOSF("LOAD")
-"RTN","ut1",16,0)
- ; 131218 SMH - CATCHERR now nulls out $ZS if on GT.M
-"RTN","ut1",17,0)
- ;
-"RTN","ut1",18,0)
  Q
+"RTN","ut1",10,0)
+ ;
+"RTN","ut1",11,0)
+ ;following is original header from XTMUNIT1 in unreleased patch XT*7.3*81 VA code
+"RTN","ut1",12,0)
+ ;XTMUNIT1    ;JLI/FO-OAK-CONTINUATION OF UNIT TEST ROUTINE ;2014-04-17  5:26 PM
+"RTN","ut1",13,0)
+ ;;7.3;TOOLKIT;**81**;APR 25 1995;Build 24
+"RTN","ut1",14,0)
+ ;
+"RTN","ut1",15,0)
+ ;
+"RTN","ut1",16,0)
+ ; Original by Dr. Joel Ivey
+"RTN","ut1",17,0)
+ ; Major contributions by Dr. Sam Habiel
+"RTN","ut1",18,0)
+ ;
 "RTN","ut1",19,0)
  ;
 "RTN","ut1",20,0)
@@ -1819,1522 +1779,2958 @@ CHEKTEST(%utROU,%ut,%utUETRY) ; Collect Test list.
 "RTN","ut1",34,0)
  S I=$L($T(@(U_%utROU))) I I<0 Q "-1^Invalid Routine Name"
 "RTN","ut1",35,0)
- ; 140731 JLI - the following SMH code is replaced by the code below
-"RTN","ut1",36,0)
- ; Complexity galore: $TEXT loops through routine
-"RTN","ut1",37,0)
- ; IF tab or space isn't the first character ($C(9,32)) and line contains @TEST
-"RTN","ut1",38,0)
- ; Load that line as a testing entry point
-"RTN","ut1",39,0)
- ; F I=1:1 S LINE=$T(@("+"_I_U_%utROU)) Q:LINE=""  I $C(9,32)'[$E(LINE),$$UP(LINE)["@TEST" D
-"RTN","ut1",40,0)
- ; . N TAGNAME,CHAR,NPAREN S TAGNAME="",NPAREN=0
-"RTN","ut1",41,0)
- ; . F  Q:LINE=""  S CHAR=$E(LINE),LINE=$E(LINE,2,999) Q:CHAR=""  Q:" ("[CHAR  S TAGNAME=TAGNAME_CHAR
-"RTN","ut1",42,0)
- ; . ; should be no paren or arguments
-"RTN","ut1",43,0)
- ; . I CHAR="(" Q
-"RTN","ut1",44,0)
- ; . F  Q:LINE=""  S CHAR=$E(LINE) Q:" ;"'[CHAR  S LINE=$E(LINE,2,999)
-"RTN","ut1",45,0)
- ; . I $$UP($E(LINE,1,5))="@TEST" S LINE=$E(LINE,6,999) D
-"RTN","ut1",46,0)
- ; . . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=TAGNAME
-"RTN","ut1",47,0)
- ; . . F  Q:LINE=""  S CHAR=$E(LINE) Q:CHAR?1AN  S LINE=$E(LINE,2,999)
-"RTN","ut1",48,0)
- ; . . S %utUETRY(%ut("ENTN"),"NAME")=LINE
-"RTN","ut1",49,0)
- ; JLI 140731 - end of code replaced by following code
-"RTN","ut1",50,0)
- ; JLI 140731 - the following code replaces the code above
-"RTN","ut1",51,0)
  D NEWSTYLE(.LIST,%utROU)
-"RTN","ut1",52,0)
+"RTN","ut1",36,0)
  F I=1:1:LIST S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=$P(LIST(I),U),%utUETRY(%ut("ENTN"),"NAME")=$P(LIST(I),U,2,99)
-"RTN","ut1",53,0)
- ; JLI 140731 - end of replacement code
-"RTN","ut1",54,0)
+"RTN","ut1",37,0)
  ;
-"RTN","ut1",55,0)
- ;
-"RTN","ut1",56,0)
+"RTN","ut1",38,0)
  ; This Stanza is to collect XTENT offsets
-"RTN","ut1",57,0)
+"RTN","ut1",39,0)
  N %utUI F %utUI=1:1 S %ut("ELIN")=$T(@("XTENT+"_%utUI_"^"_%utROU)) Q:$P(%ut("ELIN"),";",3)=""  D
-"RTN","ut1",58,0)
+"RTN","ut1",40,0)
  . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=$P(%ut("ELIN"),";",3),%utUETRY(%ut("ENTN"),"NAME")=$P(%ut("ELIN"),";",4)
-"RTN","ut1",59,0)
+"RTN","ut1",41,0)
  . Q
-"RTN","ut1",60,0)
+"RTN","ut1",42,0)
  ;
-"RTN","ut1",61,0)
+"RTN","ut1",43,0)
  QUIT
+"RTN","ut1",44,0)
+ ;
+"RTN","ut1",45,0)
+ ; VEN/SMH 26JUL2013 - Moved GETTREE here.
+"RTN","ut1",46,0)
+GETTREE(%utROU,%utULIST) ;
+"RTN","ut1",47,0)
+ ; first get any other routines this one references for running subsequently
+"RTN","ut1",48,0)
+ ; then any that they refer to as well
+"RTN","ut1",49,0)
+ ; this builds a tree of all routines referred to by any routine including each only once
+"RTN","ut1",50,0)
+ N %utUK,%utUI,%utUJ,%utURNAM,%utURLIN
+"RTN","ut1",51,0)
+ F %utUK=1:1 Q:'$D(%utROU(%utUK))  D
+"RTN","ut1",52,0)
+ . F %utUI=1:1 S %utURLIN=$T(@("XTROU+"_%utUI_"^"_%utROU(%utUK))) S %utURNAM=$P(%utURLIN,";",3) Q:%utURNAM=""  D
+"RTN","ut1",53,0)
+ . . F %utUJ=1:1:%utULIST I %utROU(%utUJ)=%utURNAM S %utURNAM="" Q
+"RTN","ut1",54,0)
+ . . I %utURNAM'="",$T(@("+1^"_%utURNAM))="" W:'$D(XWBOS) "Referenced routine ",%utURNAM," not found.",! Q
+"RTN","ut1",55,0)
+ . . S:%utURNAM'="" %utULIST=%utULIST+1,%utROU(%utULIST)=%utURNAM
+"RTN","ut1",56,0)
+ QUIT
+"RTN","ut1",57,0)
+ ;
+"RTN","ut1",58,0)
+NEWSTYLE(LIST,ROUNAME) ; JLI 140726 identify and return list of newstyle tags or entries for this routine
+"RTN","ut1",59,0)
+ ; LIST - input, passed by reference - returns containing array with list of tags identified as tests
+"RTN","ut1",60,0)
+ ;                   LIST indicates number of tags identified, LIST(n)=tag^test_info where tag is entry point for test
+"RTN","ut1",61,0)
+ ; ROUNAME - input - routine name in which tests should be identified
 "RTN","ut1",62,0)
  ;
 "RTN","ut1",63,0)
- ; VEN/SMH 26JUL2013 - Moved GETTREE here.
-"RTN","ut1",64,0)
-GETTREE(%utROU,%utULIST) ;
-"RTN","ut1",65,0)
- ; first get any other routines this one references for running subsequently
-"RTN","ut1",66,0)
- ; then any that they refer to as well
-"RTN","ut1",67,0)
- ; this builds a tree of all routines referred to by any routine including each only once
-"RTN","ut1",68,0)
- N %utUK,%utUI,%utUJ,%utURNAM,%utURLIN
-"RTN","ut1",69,0)
- F %utUK=1:1 Q:'$D(%utROU(%utUK))  D
-"RTN","ut1",70,0)
- . F %utUI=1:1 S %utURLIN=$T(@("XTROU+"_%utUI_"^"_%utROU(%utUK))) S %utURNAM=$P(%utURLIN,";",3) Q:%utURNAM=""  D
-"RTN","ut1",71,0)
- . . F %utUJ=1:1:%utULIST I %utROU(%utUJ)=%utURNAM S %utURNAM="" Q
-"RTN","ut1",72,0)
- . . I %utURNAM'="",$T(@("+1^"_%utURNAM))="" W:'$D(XWBOS) "Referenced routine ",%utURNAM," not found.",! Q
-"RTN","ut1",73,0)
- . . S:%utURNAM'="" %utULIST=%utULIST+1,%utROU(%utULIST)=%utURNAM
-"RTN","ut1",74,0)
- QUIT
-"RTN","ut1",75,0)
- ;
-"RTN","ut1",76,0)
-NEWSTYLE(LIST,ROUNAME) ; JLI 140726 identify and return list of newstyle tags or entries for this routine
-"RTN","ut1",77,0)
- ; LIST - input, passed by reference - returns containing array with list of tags identified as tests
-"RTN","ut1",78,0)
- ;                   LIST indicates number of tags identified, LIST(n)=tag^test_info where tag is entry point for test
-"RTN","ut1",79,0)
- ; ROUNAME - input - routine name in which tests should be identified
-"RTN","ut1",80,0)
- ;
-"RTN","ut1",81,0)
  N I,VALUE,LINE
-"RTN","ut1",82,0)
+"RTN","ut1",64,0)
  K LIST S LIST=0
-"RTN","ut1",83,0)
+"RTN","ut1",65,0)
  ; search routine by line for a tag and @TEST declaration
-"RTN","ut1",84,0)
+"RTN","ut1",66,0)
  F I=1:1 S LINE=$T(@("+"_I_"^"_ROUNAME)) Q:LINE=""  S VALUE=$$CHECKTAG(LINE) I VALUE'="" S LIST=LIST+1,LIST(LIST)=VALUE
-"RTN","ut1",85,0)
+"RTN","ut1",67,0)
  Q
-"RTN","ut1",86,0)
+"RTN","ut1",68,0)
  ;
-"RTN","ut1",87,0)
+"RTN","ut1",69,0)
 CHECKTAG(LINE) ; JLI 140726 check line to determine @test TAG
-"RTN","ut1",88,0)
+"RTN","ut1",70,0)
  ; LINE - input - Line of code to be checked
-"RTN","ut1",89,0)
+"RTN","ut1",71,0)
  ; returns null line if not @TEST line, otherwise TAG^NOTE
-"RTN","ut1",90,0)
+"RTN","ut1",72,0)
  N TAG,NOTE,CHAR
-"RTN","ut1",91,0)
+"RTN","ut1",73,0)
  I $E(LINE)=" " Q "" ; test entry must have a tag
-"RTN","ut1",92,0)
+"RTN","ut1",74,0)
  I $$UP(LINE)'["@TEST" Q "" ; must have @TEST declaration
-"RTN","ut1",93,0)
+"RTN","ut1",75,0)
  I $P($$UP(LINE),"@TEST")["(" Q "" ; can't have an argument
-"RTN","ut1",94,0)
+"RTN","ut1",76,0)
  S TAG=$P(LINE," "),LINE=$P(LINE," ",2,400),NOTE=$P($$UP(LINE),"@TEST"),LINE=$E(LINE,$L(NOTE)+5+1,$L(LINE))
-"RTN","ut1",95,0)
+"RTN","ut1",77,0)
  F  Q:NOTE=""  S CHAR=$E(NOTE),NOTE=$E(NOTE,2,$L(NOTE)) I " ;"'[CHAR Q  ;
-"RTN","ut1",96,0)
+"RTN","ut1",78,0)
  I $L(NOTE)'=0 Q "" ; @TEST must be first text on line
-"RTN","ut1",97,0)
+"RTN","ut1",79,0)
  F  Q:$E(LINE)'=" "  S LINE=$E(LINE,2,$L(LINE)) ; remove leading spaces from test info
-"RTN","ut1",98,0)
+"RTN","ut1",80,0)
  S TAG=TAG_U_LINE
-"RTN","ut1",99,0)
+"RTN","ut1",81,0)
  Q TAG
+"RTN","ut1",82,0)
+ ;
+"RTN","ut1",83,0)
+FAIL(XTERMSG) ; Entry point for generating a failure message
+"RTN","ut1",84,0)
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+"RTN","ut1",85,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut1",86,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut1",87,0)
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+"RTN","ut1",88,0)
+ S %ut("CHK")=%ut("CHK")+1
+"RTN","ut1",89,0)
+ I '$D(%utGUI) D
+"RTN","ut1",90,0)
+ . D SETIO
+"RTN","ut1",91,0)
+ . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+"RTN","ut1",92,0)
+ . . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
+"RTN","ut1",93,0)
+ . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+"RTN","ut1",94,0)
+ . . Q
+"RTN","ut1",95,0)
+ . D RESETIO
+"RTN","ut1",96,0)
+ . Q
+"RTN","ut1",97,0)
+ I $D(%utGUI) S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG,%ut("FAIL")=%ut("FAIL")+1
+"RTN","ut1",98,0)
+ Q
+"RTN","ut1",99,0)
+ ;
 "RTN","ut1",100,0)
- ;
+NVLDARG(API) ; generate message for invalid arguments to test
 "RTN","ut1",101,0)
- ; VEN/SMH 17DEC2013 - Remove dependence on VISTA - Uppercase here instead of XLFSTR.
+ N XTERMSG
 "RTN","ut1",102,0)
-UP(X) ;
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
 "RTN","ut1",103,0)
- Q $TR(X,"abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
 "RTN","ut1",104,0)
- ;
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
 "RTN","ut1",105,0)
-COV(NMSP,COVCODE,VERBOSITY) ; VEN/SMH - PUBLIC ENTRY POINT; Coverage calculations
+ S XTERMSG="NO VALUES INPUT TO "_API_"^%ut - no evaluation possible"
 "RTN","ut1",106,0)
- ; NMSP: Namespace of the routines to analyze. End with * to include all routines.
+ I '$D(%utGUI) D
 "RTN","ut1",107,0)
- ;       Not using * will only include the routine with NMSP name.
+ . D SETIO
 "RTN","ut1",108,0)
- ;       e.g. PSOM* will include all routines starting with PSOM
+ . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
 "RTN","ut1",109,0)
- ;            PSOM will only include PSOM.
+ . . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
 "RTN","ut1",110,0)
- ; COVCODE: Mumps code to run over which coverage will be calculated. Typically Unit Tests.
+ . . Q
 "RTN","ut1",111,0)
- ; VERBOSITY (optional): Scalar from -1 to 3.
+ . D RESETIO
 "RTN","ut1",112,0)
- ;    - -1 = Global output in ^TMP("%utCOVREPORT",$J)
+ . Q
 "RTN","ut1",113,0)
- ;    - 0 = Print only total coverage
+ I $D(%utGUI) S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG,%ut("FAIL")=%ut("FAIL")+1
 "RTN","ut1",114,0)
- ;    - 1 = Break down by routine
+ Q
 "RTN","ut1",115,0)
- ;    - 2 = Break down by routine and tag
+ ;
 "RTN","ut1",116,0)
- ;    - 3 = Break down by routine and tag, and print lines that didn't execute for each tag.
+SETIO ; Set M-Unit Device to write the results to...
 "RTN","ut1",117,0)
- ;
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
 "RTN","ut1",118,0)
- Q:'(+$SY=47)  ; GT.M only!
+ I $IO'=%ut("IO") S (IO(0),%ut("DEV","OLD"))=$IO USE %ut("IO") SET IO=$IO
 "RTN","ut1",119,0)
- ;
+ QUIT
 "RTN","ut1",120,0)
- ; ZEXCEPT: CTRAP - not really a variable
+ ;
 "RTN","ut1",121,0)
- S VERBOSITY=+$G(VERBOSITY) ; Get 0 if not passed.
+RESETIO ; Reset $IO back to the original device if we changed it.
 "RTN","ut1",122,0)
- N %ZR ; GT.M specific
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
 "RTN","ut1",123,0)
- D SILENT^%RSEL(NMSP,"SRC") ; GT.M specific. On Cache use $O(^$R(RTN)).
+ I $D(%ut("DEV","OLD")) S IO(0)=%ut("IO") U %ut("DEV","OLD") S IO=$IO K %ut("DEV","OLD")
 "RTN","ut1",124,0)
- ;
+ QUIT
 "RTN","ut1",125,0)
- N RN S RN=""
+ ;
 "RTN","ut1",126,0)
- W "Loading routines to test coverage...",!
+ ; VEN/SMH 17DEC2013 - Remove dependence on VISTA - Uppercase here instead of XLFSTR.
 "RTN","ut1",127,0)
- F  S RN=$O(%ZR(RN)) Q:RN=""  W RN," " D
+UP(X) ;
 "RTN","ut1",128,0)
- . N L2 S L2=$T(+2^@RN)
+ Q $TR(X,"abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ")
 "RTN","ut1",129,0)
- . S L2=$TR(L2,$C(9,32)) ; Translate spaces and tabs out
+ ;
 "RTN","ut1",130,0)
- . I $E(L2,1,2)'=";;" K %ZR(RN)  ; Not a human produced routine
+COV(NMSP,COVCODE,VERBOSITY) ; VEN/SMH - PUBLIC ENTRY POINT; Coverage calculations
 "RTN","ut1",131,0)
- ;
+ ; NMSP: Namespace of the routines to analyze. End with * to include all routines.
 "RTN","ut1",132,0)
- N RTNS M RTNS=%ZR
+ ;       Not using * will only include the routine with NMSP name.
 "RTN","ut1",133,0)
- K %ZR
+ ;       e.g. PSOM* will include all routines starting with PSOM
 "RTN","ut1",134,0)
- ;
+ ;            PSOM will only include PSOM.
 "RTN","ut1",135,0)
- N GL
+ ; COVCODE: Mumps code to run over which coverage will be calculated. Typically Unit Tests.
 "RTN","ut1",136,0)
- S GL=$NA(^TMP("%utCOVCOHORT",$J))
+ ; VERBOSITY (optional): Scalar from -1 to 3.
 "RTN","ut1",137,0)
- K @GL
+ ;    - -1 = Global output in ^TMP("%utCOVREPORT",$J)
 "RTN","ut1",138,0)
- D RTNANAL(.RTNS,GL)
+ ;    - 0 = Print only total coverage
 "RTN","ut1",139,0)
- K ^TMP("%utCOVCOHORTSAV",$J)
+ ;    - 1 = Break down by routine
 "RTN","ut1",140,0)
- M ^TMP("%utCOVCOHORTSAV",$J)=^TMP("%utCOVCOHORT",$J)
+ ;    - 2 = Break down by routine and tag
 "RTN","ut1",141,0)
- ;
+ ;    - 3 = Break down by routine and tag, and print lines that didn't execute for each tag.
 "RTN","ut1",142,0)
  ;
 "RTN","ut1",143,0)
- K ^TMP("%utCOVRESULT",$J)
+ ; ZEXCEPT: %utcovxx - SET and KILLED in this code at top level
 "RTN","ut1",144,0)
- VIEW "TRACE":1:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M START PROFILING
+ ; ZEXCEPT: %Monitor,%apiOBJ,DecomposeStatus,LineByLine,Start,Stop,System,class - not variables parts of classes
 "RTN","ut1",145,0)
- DO  ; Run the code, but keep our variables to ourselves.
+ N COVER,COVERSAV,I,NMSP1,RTN,RTNS,ERR,STATUS
 "RTN","ut1",146,0)
- . NEW $ETRAP,$ESTACK
+ I (+$SY=47) D  ; GT.M only!
 "RTN","ut1",147,0)
- . SET $ETRAP="Q:($ES&$Q) -9 Q:$ES  W ""CTRL-C ENTERED"""
+ . N %ZR ; GT.M specific
 "RTN","ut1",148,0)
- . USE $PRINCIPAL:(CTRAP=$C(3))
+ . D SILENT^%RSEL(NMSP,"SRC") ; GT.M specific. On Cache use $O(^$R(RTN)).
 "RTN","ut1",149,0)
- . NEW (DUZ,IO,COVCODE,U,DILOCKTM,DISYS,DT,DTIME,IOBS,IOF,IOM,ION,IOS,IOSL,IOST,IOT,IOXY)
+ . N RN S RN=""
 "RTN","ut1",150,0)
- . XECUTE COVCODE
+ . W !,"Loading routines to test coverage...",!
 "RTN","ut1",151,0)
- VIEW "TRACE":0:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M STOP PROFILING
+ . F  S RN=$O(%ZR(RN)) Q:RN=""  W RN," " D
 "RTN","ut1",152,0)
- ;
+ . . N L2 S L2=$T(+2^@RN)
 "RTN","ut1",153,0)
- D COVCOV($NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J))) ; Venn diagram matching between globals
+ . . S L2=$TR(L2,$C(9,32)) ; Translate spaces and tabs out
 "RTN","ut1",154,0)
- ;
+ . . I $E(L2,1,2)'=";;" K %ZR(RN)  ; Not a human produced routine
 "RTN","ut1",155,0)
- ; Report
+ . ;
 "RTN","ut1",156,0)
- I VERBOSITY=-1 D
+ . M RTNS=%ZR
 "RTN","ut1",157,0)
- . K ^TMP("%utCOVREPORT",$J)
+ . K %ZR
 "RTN","ut1",158,0)
- . D COVRPTGL($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),$NA(^TMP("%utCOVREPORT",$J)))
+ . Q
 "RTN","ut1",159,0)
- E  D COVRPT($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),VERBOSITY)
+ ;
 "RTN","ut1",160,0)
- ;
+ I (+$SY=0) D  ; CACHE SPECIFIC
 "RTN","ut1",161,0)
- QUIT
+ . S NMSP1=NMSP I NMSP["*" S NMSP1=$P(NMSP,"*")
 "RTN","ut1",162,0)
- ;
+ . I $D(^$R(NMSP1)) S RTNS(NMSP1)=""
 "RTN","ut1",163,0)
-RTNANAL(RTNS,GL) ; [Private] - Routine Analysis
+ . I NMSP["*" S RTN=NMSP1 F  S RTN=$O(^$R(RTN)) Q:RTN'[NMSP1  S RTNS(RTN)=""
 "RTN","ut1",164,0)
- ; Create a global similar to the trace global produced by GT.M in GL
+ . Q
 "RTN","ut1",165,0)
- ; Only non-comment lines are stored.
+ ;
 "RTN","ut1",166,0)
- ; A tag is always stored. Tag,0 is stored only if there is code on the tag line (format list or actual code).
+ ; ZEXCEPT: CTRAP - not really a variable
 "RTN","ut1",167,0)
- ; tags by themselves don't count toward the total.
+ S VERBOSITY=+$G(VERBOSITY) ; Get 0 if not passed.
 "RTN","ut1",168,0)
  ;
 "RTN","ut1",169,0)
- N RTN S RTN=""
+ ;
 "RTN","ut1",170,0)
- F  S RTN=$O(RTNS(RTN)) Q:RTN=""  D                       ; for each routine
+ N GL
 "RTN","ut1",171,0)
- . N TAG
+ S GL=$NA(^TMP("%utCOVCOHORT",$J))
 "RTN","ut1",172,0)
- . S TAG=RTN                                              ; start the tags at the first
+ I '$D(^TMP("%utcovrunning",$J)) K @GL
 "RTN","ut1",173,0)
- . N I,LN F I=2:1 S LN=$T(@TAG+I^@RTN) Q:LN=""  D         ; for each line, starting with the 3rd line (2 off the first tag)
+ D RTNANAL(.RTNS,GL) ; save off any current coverage data
 "RTN","ut1",174,0)
- . . I $E(LN)?1A D  QUIT                                  ; formal line
+ I '$D(^TMP("%utcovrunning",$J)) N EXIT S EXIT=0 D  Q:EXIT
 "RTN","ut1",175,0)
- . . . N T                                                ; Terminator
+ . K ^TMP("%utCOVCOHORTSAV",$J)
 "RTN","ut1",176,0)
- . . . N J F J=1:1:$L(LN) S T=$E(LN,J) Q:T'?1AN           ; Loop to...
+ . M ^TMP("%utCOVCOHORTSAV",$J)=^TMP("%utCOVCOHORT",$J)
 "RTN","ut1",177,0)
- . . . S TAG=$E(LN,1,J-1)                                 ; Get tag
+ . K ^TMP("%utCOVRESULT",$J)
 "RTN","ut1",178,0)
- . . . S @GL@(RTN,TAG)=TAG                                ; store line
+ . S ^TMP("%utcovrunning",$J)=1,%utcovxx=1
 "RTN","ut1",179,0)
- . . . I T="(" S @GL@(RTN,TAG,0)=LN                       ; formal list
+ . ;
 "RTN","ut1",180,0)
- . . . E  D                                               ; No formal list
+ . I (+$SY=47) VIEW "TRACE":1:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M START PROFILING
 "RTN","ut1",181,0)
- . . . . N LNTR S LNTR=$P(LN,TAG,2,999),LNTR=$TR(LNTR,$C(9,32)) ; Get rest of line, Remove spaces and tabs
+ . ;
 "RTN","ut1",182,0)
- . . . . I $E(LNTR)=";" QUIT                              ; Comment
+ . I (+$SY=0) D  ; CACHE CODE TO START PROFILING
 "RTN","ut1",183,0)
- . . . . S @GL@(RTN,TAG,0)=LN                             ; Otherwise, store for testing
+ . . S STATUS=##class(%Monitor.System.LineByLine).Start($lb(NMSP),$lb("RtnLine"),$lb($j))
 "RTN","ut1",184,0)
- . . . S I=0                                              ; Start offsets from zero (first one at the for will be 1)
+ . . I +STATUS'=1 D DecomposeStatus^%apiOBJ(STATUS,.ERR,"-d") F I=1:1:ERR W ERR(I),!
 "RTN","ut1",185,0)
- . . I $C(32,9)[$E(LN) D  QUIT                            ; Regular line
+ . . I +STATUS'=1 K ERR S EXIT=1
 "RTN","ut1",186,0)
- . . . N LNTR S LNTR=$TR(LN,$C(32,9))                     ; Remove all spaces and tabs
+ . . Q
 "RTN","ut1",187,0)
- . . . I $E(LNTR)=";" QUIT                                ; Comment line -- don't want.
+ . Q
 "RTN","ut1",188,0)
- . . . S @GL@(RTN,TAG,I)=LN                               ; Record line
+ DO  ; Run the code, but keep our variables to ourselves.
 "RTN","ut1",189,0)
- QUIT
+ . NEW $ETRAP,$ESTACK
 "RTN","ut1",190,0)
- ;
+ . I (+$SY=47) D  ; GT.M SPECIFIC
 "RTN","ut1",191,0)
-ACTLINES(GL) ; [Private] $$ ; Count active lines
+ . . SET $ETRAP="Q:($ES&$Q) -9 Q:$ES  W ""CTRL-C ENTERED"""
 "RTN","ut1",192,0)
- ;
+ . . USE $PRINCIPAL:(CTRAP=$C(3))
 "RTN","ut1",193,0)
- N CNT S CNT=0
+ . . Q
 "RTN","ut1",194,0)
- N REF S REF=GL
+ . NEW (DUZ,IO,COVCODE,U,DILOCKTM,DISYS,DT,DTIME,IOBS,IOF,IOM,ION,IOS,IOSL,IOST,IOT,IOXY)
 "RTN","ut1",195,0)
- N GLQL S GLQL=$QL(GL)
+ . XECUTE COVCODE
 "RTN","ut1",196,0)
- F  S REF=$Q(@REF) Q:REF=""  Q:(GL'=$NA(@REF,GLQL))  D
+ . Q
 "RTN","ut1",197,0)
- . N REFQL S REFQL=$QL(REF)
+ ; GT.M STOP PROFILING if this is the original level that started it
 "RTN","ut1",198,0)
- . N LASTSUB S LASTSUB=$QS(REF,REFQL)
+ I $D(^TMP("%utcovrunning",$J)),$D(%utcovxx) D
 "RTN","ut1",199,0)
- . I LASTSUB?1.N S CNT=CNT+1
+ . I (+$SY=47) VIEW "TRACE":0:$NA(^TMP("%utCOVRESULT",$J)) ; GT.M SPECIFIC
 "RTN","ut1",200,0)
- QUIT CNT
+ . I (+$SY=0) ; CACHE SPECIFIC
 "RTN","ut1",201,0)
- ;
+ . K %utcovxx,^TMP("%utcovrunning",$J)
 "RTN","ut1",202,0)
-COVCOV(C,R) ; [Private] - Analyze coverage Cohort vs Result
+ . Q
 "RTN","ut1",203,0)
- N RTN S RTN=""
+ ;
 "RTN","ut1",204,0)
- F  S RTN=$O(@C@(RTN)) Q:RTN=""  D  ; For each routine in cohort set
+ I '$D(^TMP("%utcovrunning",$J)) D
 "RTN","ut1",205,0)
- . I '$D(@R@(RTN)) QUIT             ; Not present in result set
+ . I (+$SY=0) D  ; CACHE SPECIFIC CODE
 "RTN","ut1",206,0)
- . N TAG S TAG=""
+ . . S COVERSAV=$NA(^TMP("%utCOVCOHORTSAV",$J)) K @COVERSAV
 "RTN","ut1",207,0)
- . F  S TAG=$O(@R@(RTN,TAG)) Q:TAG=""  D  ; For each tag in the routine in the result set
+ . . S COVER=$NA(^TMP("%utCOVCOHORT",$J)) K @COVER
 "RTN","ut1",208,0)
- . . N LN S LN=""
+ . . D CACHECOV(COVERSAV,COVER)
 "RTN","ut1",209,0)
- . . F  S LN=$O(@R@(RTN,TAG,LN)) Q:LN=""  D  ; for each line in the tag in the routine in the result set
+ . . D TOTAGS(COVERSAV,0),TOTAGS(COVER,1)
 "RTN","ut1",210,0)
- . . . I $D(@C@(RTN,TAG,LN)) K ^(LN)  ; if present in cohort, kill off
+ . . D ##class(%Monitor.System.LineByLine).Stop()
 "RTN","ut1",211,0)
- QUIT
+ . . Q
 "RTN","ut1",212,0)
- ;
+ . D COVCOV($NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J))) ; Venn diagram matching between globals
 "RTN","ut1",213,0)
-COVRPT(C,S,R,V) ; [Private] - Coverage Report
+ . ; Report
 "RTN","ut1",214,0)
- ; C = COHORT    - Global name
+ . I VERBOSITY=-1 D
 "RTN","ut1",215,0)
- ; S = SURVIVORS - Global name
+ . . K ^TMP("%utCOVREPORT",$J)
 "RTN","ut1",216,0)
- ; R = RESULT    - Global name
+ . . D COVRPTGL($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),$NA(^TMP("%utCOVREPORT",$J)))
 "RTN","ut1",217,0)
- ; V = Verbosity - Scalar from -1 to 3
+ . . Q
 "RTN","ut1",218,0)
- N ORIGLINES S ORIGLINES=$$ACTLINES(C)
+ . E  D COVRPT($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),VERBOSITY)
 "RTN","ut1",219,0)
- N LEFTLINES S LEFTLINES=$$ACTLINES(S)
+ . Q
 "RTN","ut1",220,0)
- W !!
+ QUIT
 "RTN","ut1",221,0)
- W "ORIG: "_ORIGLINES,!
+ ;
 "RTN","ut1",222,0)
- W "LEFT: "_LEFTLINES,!
+CACHECOV(GLOBSAV,GLOB) ;
 "RTN","ut1",223,0)
- W "COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00),!
+ ; ZEXCEPT: %Monitor,GetMetrics,GetRoutineCount,GetRoutineName,LineByLine,System,class - not variable names, part of classes
 "RTN","ut1",224,0)
- W !!
+ N DIF,I,METRIC,METRICNT,METRICS,MTRICNUM,ROUNAME,ROUNUM,X,XCNP,XXX
 "RTN","ut1",225,0)
- W "BY ROUTINE:",!
+ I $$ISUTEST(),'$D(^TMP("%utt4val",$J)) S ROUNUM=1,METRICS="RtnLine",METRICNT=1,ROUNAME="%ut"
 "RTN","ut1",226,0)
- I V=0 QUIT  ; No verbosity. Don't print routine detail
+ I $D(^TMP("%utt4val",$J))!'$$ISUTEST() S ROUNUM=##class(%Monitor.System.LineByLine).GetRoutineCount(),METRICS=##class(%Monitor.System.LineByLine).GetMetrics(),METRICNT=$l(METRICS,",")
 "RTN","ut1",227,0)
- N RTN S RTN=""
+ ; if only running to do coverage, should be 1
 "RTN","ut1",228,0)
- F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
+ S MTRICNUM=0 F I=1:1:METRICNT S METRIC=$P(METRICS,",",I) I METRIC="RtnLine" S MTRICNUM=I Q
 "RTN","ut1",229,0)
- . N O S O=$$ACTLINES($NA(@C@(RTN)))
+ ;
 "RTN","ut1",230,0)
- . N L S L=$$ACTLINES($NA(@S@(RTN)))
+ F I=1:1:ROUNUM D
 "RTN","ut1",231,0)
- . W ?3,RTN,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+ . I $D(^TMP("%utt4val",$J))!'$$ISUTEST() S ROUNAME=##class(%Monitor.System.LineByLine).GetRoutineName(I)
 "RTN","ut1",232,0)
- . I V=1 QUIT  ; Just print the routine coverage for V=1
+ . ; get routine loaded into location
 "RTN","ut1",233,0)
- . N TAG S TAG=""
+ . S DIF=$NA(@GLOBSAV@(ROUNAME)),DIF=$E(DIF,1,$L(DIF)-1)_",",XCNP=0,X=ROUNAME
 "RTN","ut1",234,0)
- . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
+ . X ^%ZOSF("LOAD")
 "RTN","ut1",235,0)
- . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
+ . M @GLOB@(ROUNAME)=@GLOBSAV@(ROUNAME)
 "RTN","ut1",236,0)
- . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
+ . Q
 "RTN","ut1",237,0)
- . . W ?5,TAG,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+ ;
 "RTN","ut1",238,0)
- . . I V=2 QUIT  ; Just print routine/tags coverage for V=2; V=3 print uncovered lines
+ I $D(^TMP("%utt4val",$J))!'$$ISUTEST() F XXX=1:1:ROUNUM D GETVALS(XXX,GLOB,MTRICNUM)
 "RTN","ut1",239,0)
- . . N LN S LN=""
-"RTN","ut1",240,0)
- . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  W TAG_"+"_LN_": "_^(LN),!
-"RTN","ut1",241,0)
- QUIT
-"RTN","ut1",242,0)
- ;
-"RTN","ut1",243,0)
-COVRPTGL(C,S,R,OUT) ; [Private] - Coverage Global for silent invokers
-"RTN","ut1",244,0)
- ; C = COHORT    - Global name
-"RTN","ut1",245,0)
- ; S = SURVIVORS - Global name
-"RTN","ut1",246,0)
- ; R = RESULT    - Global name
-"RTN","ut1",247,0)
- ; OUT = OUTPUT  - Global name
-"RTN","ut1",248,0)
- ;
-"RTN","ut1",249,0)
- N O S O=$$ACTLINES(C)
-"RTN","ut1",250,0)
- N L S L=$$ACTLINES(S)
-"RTN","ut1",251,0)
- S @OUT=(O-L)_"/"_O
-"RTN","ut1",252,0)
- N RTN,TAG,LN S (RTN,TAG,LN)=""
-"RTN","ut1",253,0)
- F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
-"RTN","ut1",254,0)
- . N O S O=$$ACTLINES($NA(@C@(RTN)))
-"RTN","ut1",255,0)
- . N L S L=$$ACTLINES($NA(@S@(RTN)))
-"RTN","ut1",256,0)
- . S @OUT@(RTN)=(O-L)_"/"_O
-"RTN","ut1",257,0)
- . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
-"RTN","ut1",258,0)
- . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
-"RTN","ut1",259,0)
- . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
-"RTN","ut1",260,0)
- . . S @OUT@(RTN,TAG)=(O-L)_"/"_O
-"RTN","ut1",261,0)
- . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  S @OUT@(RTN,TAG,LN)=@S@(RTN,TAG,LN)
-"RTN","ut1",262,0)
- QUIT
-"RTN","ut1",263,0)
- ;
-"RTN","ut1",264,0)
-TESTCOVR ; entry under coverage analysis
-"RTN","ut1",265,0)
- D ENTRY^%uttcovr ; does analysis while running various unit tests
-"RTN","ut1",266,0)
  Q
+"RTN","ut1",240,0)
+ ;
+"RTN","ut1",241,0)
+GETVALS(ROUNUM,GLOB,MTRICNUM) ; get data on number of times a line seen (set into VAL)
+"RTN","ut1",242,0)
+ ; ZEXCEPT: %Monitor,%New,%ResultSet,Execute,GetData,GetRoutineName,LineByLine,Next,System,class - not variables parts of Cache classes
+"RTN","ut1",243,0)
+ N LINE,MORE,ROUNAME,RSET,VAL,X
+"RTN","ut1",244,0)
+ ;
+"RTN","ut1",245,0)
+ S RSET=##class(%ResultSet).%New("%Monitor.System.LineByLine:Result")
+"RTN","ut1",246,0)
+ S ROUNAME=##class(%Monitor.System.LineByLine).GetRoutineName(ROUNUM)
+"RTN","ut1",247,0)
+ S LINE=RSET.Execute(ROUNAME)
+"RTN","ut1",248,0)
+ F LINE=1:1 S MORE=RSET.Next() Q:'MORE  D
+"RTN","ut1",249,0)
+ . S X=RSET.GetData(1)
+"RTN","ut1",250,0)
+ . S VAL=$LI(X,MTRICNUM)
+"RTN","ut1",251,0)
+ . S @GLOB@(ROUNAME,LINE,"C")=+VAL ; values are 0 if not seen, otherwises positive number
+"RTN","ut1",252,0)
+ . Q
+"RTN","ut1",253,0)
+ D RSET.Close()
+"RTN","ut1",254,0)
+ Q
+"RTN","ut1",255,0)
+ ;
+"RTN","ut1",256,0)
+TOTAGS(GLOBAL,ACTIVE) ; convert to lines from tags and set value only if not seen
+"RTN","ut1",257,0)
+ N ACTIVCOD,LINE,LINENUM,ROU,ROUCODE
+"RTN","ut1",258,0)
+ S ROU="" F  S ROU=$O(@GLOBAL@(ROU)) Q:ROU=""  D
+"RTN","ut1",259,0)
+ . M ROUCODE(ROU)=@GLOBAL@(ROU) K @GLOBAL@(ROU)
+"RTN","ut1",260,0)
+ . N TAG,OFFSET,OLDTAG S TAG="",OFFSET=0,OLDTAG=""
+"RTN","ut1",261,0)
+ . F LINENUM=1:1 Q:'$D(ROUCODE(ROU,LINENUM,0))  D
+"RTN","ut1",262,0)
+ . . S LINE=ROUCODE(ROU,LINENUM,0)
+"RTN","ut1",263,0)
+ . . S ACTIVCOD=$$LINEDATA(LINE,.TAG,.OFFSET)
+"RTN","ut1",264,0)
+ . . I TAG'=OLDTAG S @GLOBAL@(ROU,TAG)=TAG
+"RTN","ut1",265,0)
+ . . I ACTIVE,ACTIVCOD,(+$G(ROUCODE(ROU,LINENUM,"C"))'>0) S @GLOBAL@(ROU,TAG,OFFSET)=LINE
+"RTN","ut1",266,0)
+ . . I 'ACTIVE,ACTIVCOD S @GLOBAL@(ROU,TAG,OFFSET)=LINE
 "RTN","ut1",267,0)
+ . . Q
+"RTN","ut1",268,0)
+ . Q
+"RTN","ut1",269,0)
+ Q
+"RTN","ut1",270,0)
+ ;
+"RTN","ut1",271,0)
+LINEDATA(LINE,TAG,OFFSET) ;
+"RTN","ut1",272,0)
+ ; LINE   - input - the line of code
+"RTN","ut1",273,0)
+ ; TAG    - passed by reference -
+"RTN","ut1",274,0)
+ ; OFFSET - passed by reference
+"RTN","ut1",275,0)
+ N CODE,NEWTAG
+"RTN","ut1",276,0)
+ S NEWTAG=""
+"RTN","ut1",277,0)
+ S OFFSET=$G(OFFSET)+1
+"RTN","ut1",278,0)
+ F  Q:$E(LINE,1)=" "  Q:$E(LINE,1)=$C(9)  Q:LINE=""  S NEWTAG=NEWTAG_$E(LINE,1),LINE=$E(LINE,2,$L(LINE))
+"RTN","ut1",279,0)
+ S NEWTAG=$P(NEWTAG,"(")
+"RTN","ut1",280,0)
+ I NEWTAG'="" S TAG=NEWTAG,OFFSET=0
+"RTN","ut1",281,0)
+ S CODE=1
+"RTN","ut1",282,0)
+ F  S:(LINE="")!($E(LINE)=";") CODE=0 Q:'CODE  Q:(" ."'[$E(LINE))  S LINE=$E(LINE,2,$L(LINE))
+"RTN","ut1",283,0)
+ Q CODE
+"RTN","ut1",284,0)
+ ;
+"RTN","ut1",285,0)
+RTNANAL(RTNS,GL) ; [Private] - Routine Analysis
+"RTN","ut1",286,0)
+ ; Create a global similar to the trace global produced by GT.M in GL
+"RTN","ut1",287,0)
+ ; Only non-comment lines are stored.
+"RTN","ut1",288,0)
+ ; A tag is always stored. Tag,0 is stored only if there is code on the tag line (format list or actual code).
+"RTN","ut1",289,0)
+ ; tags by themselves don't count toward the total.
+"RTN","ut1",290,0)
+ ;
+"RTN","ut1",291,0)
+ N RTN S RTN=""
+"RTN","ut1",292,0)
+ F  S RTN=$O(RTNS(RTN)) Q:RTN=""  D                       ; for each routine
+"RTN","ut1",293,0)
+ . N TAG
+"RTN","ut1",294,0)
+ . S TAG=RTN                                              ; start the tags at the first
+"RTN","ut1",295,0)
+ . N I,LN F I=2:1 S LN=$T(@TAG+I^@RTN) Q:LN=""  D         ; for each line, starting with the 3rd line (2 off the first tag)
+"RTN","ut1",296,0)
+ . . I $E(LN)?1A D  QUIT                                  ; formal line
+"RTN","ut1",297,0)
+ . . . N T                                                ; Terminator
+"RTN","ut1",298,0)
+ . . . N J F J=1:1:$L(LN) S T=$E(LN,J) Q:T'?1AN           ; Loop to...
+"RTN","ut1",299,0)
+ . . . S TAG=$E(LN,1,J-1)                                 ; Get tag
+"RTN","ut1",300,0)
+ . . . S @GL@(RTN,TAG)=TAG                                ; store line
+"RTN","ut1",301,0)
+ . . . ;I T="(" S @GL@(RTN,TAG,0)=LN                      ; formal list
+"RTN","ut1",302,0)
+ . . . I T="(" D                                          ; formal list
+"RTN","ut1",303,0)
+ . . . . N PCNT,STR,CHR S PCNT=0,STR=$E(LN,J+1,$L(LN))
+"RTN","ut1",304,0)
+ . . . . F  S CHR=$E(STR),STR=$E(STR,2,$L(STR)) Q:(PCNT=0)&(CHR=")")  D
+"RTN","ut1",305,0)
+ . . . . . I CHR="(" S PCNT=PCNT+1
+"RTN","ut1",306,0)
+ . . . . . I CHR=")" S PCNT=PCNT-1
+"RTN","ut1",307,0)
+ . . . . . Q
+"RTN","ut1",308,0)
+ . . . . S STR=$TR(STR,$C(9,32))
+"RTN","ut1",309,0)
+ . . . . I $E(STR)=";" QUIT
+"RTN","ut1",310,0)
+ . . . . S @GL@(RTN,TAG,0)=LN
+"RTN","ut1",311,0)
+ . . . . Q
+"RTN","ut1",312,0)
+ . . . E  D                                               ; No formal list
+"RTN","ut1",313,0)
+ . . . . N LNTR S LNTR=$P(LN,TAG,2,999),LNTR=$TR(LNTR,$C(9,32)) ; Get rest of line, Remove spaces and tabs
+"RTN","ut1",314,0)
+ . . . . I $E(LNTR)=";" QUIT                              ; Comment
+"RTN","ut1",315,0)
+ . . . . S @GL@(RTN,TAG,0)=LN                             ; Otherwise, store for testing
+"RTN","ut1",316,0)
+ . . . S I=0                                              ; Start offsets from zero (first one at the for will be 1)
+"RTN","ut1",317,0)
+ . . I $C(32,9)[$E(LN) D  QUIT                            ; Regular line
+"RTN","ut1",318,0)
+ . . . N LNTR S LNTR=$TR(LN,$C(32,9,46))                     ; Remove all spaces and tabs - JLI 150202 remove periods as well
+"RTN","ut1",319,0)
+ . . . I $E(LNTR)=";" QUIT                                ; Comment line -- don't want.
+"RTN","ut1",320,0)
+ . . . S @GL@(RTN,TAG,I)=LN                               ; Record line
+"RTN","ut1",321,0)
+ QUIT
+"RTN","ut1",322,0)
+ ;
+"RTN","ut1",323,0)
+ACTLINES(GL) ; [Private] $$ ; Count active lines
+"RTN","ut1",324,0)
+ ;
+"RTN","ut1",325,0)
+ N CNT S CNT=0
+"RTN","ut1",326,0)
+ N REF S REF=GL
+"RTN","ut1",327,0)
+ N GLQL S GLQL=$QL(GL)
+"RTN","ut1",328,0)
+ F  S REF=$Q(@REF) Q:REF=""  Q:(GL'=$NA(@REF,GLQL))  D
+"RTN","ut1",329,0)
+ . N REFQL S REFQL=$QL(REF)
+"RTN","ut1",330,0)
+ . N LASTSUB S LASTSUB=$QS(REF,REFQL)
+"RTN","ut1",331,0)
+ . I LASTSUB?1.N S CNT=CNT+1
+"RTN","ut1",332,0)
+ QUIT CNT
+"RTN","ut1",333,0)
+ ;
+"RTN","ut1",334,0)
+COVCOV(C,R) ; [Private] - Analyze coverage Cohort vs Result
+"RTN","ut1",335,0)
+ N RTN S RTN=""
+"RTN","ut1",336,0)
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D  ; For each routine in cohort set
+"RTN","ut1",337,0)
+ . I '$D(@R@(RTN)) QUIT             ; Not present in result set
+"RTN","ut1",338,0)
+ . N TAG S TAG=""
+"RTN","ut1",339,0)
+ . F  S TAG=$O(@R@(RTN,TAG)) Q:TAG=""  D  ; For each tag in the routine in the result set
+"RTN","ut1",340,0)
+ . . N LN S LN=""
+"RTN","ut1",341,0)
+ . . F  S LN=$O(@R@(RTN,TAG,LN)) Q:LN=""  D  ; for each line in the tag in the routine in the result set
+"RTN","ut1",342,0)
+ . . . I $D(@C@(RTN,TAG,LN)) K ^(LN)  ; if present in cohort, kill off
+"RTN","ut1",343,0)
+ QUIT
+"RTN","ut1",344,0)
+ ;
+"RTN","ut1",345,0)
+COVRPT(C,S,R,V) ; [Private] - Coverage Report
+"RTN","ut1",346,0)
+ ; C = COHORT    - Global name
+"RTN","ut1",347,0)
+ ; S = SURVIVORS - Global name
+"RTN","ut1",348,0)
+ ; R = RESULT    - Global name
+"RTN","ut1",349,0)
+ ; V = Verbosity - Scalar from -1 to 3
+"RTN","ut1",350,0)
+ ; JLI 150702 -  modified to be able to do unit tests on setting up the text via COVRPTLS
+"RTN","ut1",351,0)
+ N X,I
+"RTN","ut1",352,0)
+ S X=$NA(^TMP("%ut1-covrpt",$J)) K @X
+"RTN","ut1",353,0)
+ D COVRPTLS(C,S,R,V,X)
+"RTN","ut1",354,0)
+ I '$$ISUTEST^%ut() F I=1:1 W:$D(@X@(I)) !,@X@(I) I '$D(@X@(I)) K @X Q
+"RTN","ut1",355,0)
+ Q
+"RTN","ut1",356,0)
+ ;
+"RTN","ut1",357,0)
+COVRPTLS(C,S,R,V,X) ;
+"RTN","ut1",358,0)
+ ;
+"RTN","ut1",359,0)
+ N LINNUM S LINNUM=0
+"RTN","ut1",360,0)
+ N ORIGLINES S ORIGLINES=$$ACTLINES(C)
+"RTN","ut1",361,0)
+ N LEFTLINES S LEFTLINES=$$ACTLINES(S)
+"RTN","ut1",362,0)
+ ;W !!
+"RTN","ut1",363,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="",LINNUM=LINNUM+1,@X@(LINNUM)=""
+"RTN","ut1",364,0)
+ ;W "ORIG: "_ORIGLINES,!
+"RTN","ut1",365,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="ORIG: "_ORIGLINES
+"RTN","ut1",366,0)
+ ;W "LEFT: "_LEFTLINES,!
+"RTN","ut1",367,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="LEFT: "_LEFTLINES
+"RTN","ut1",368,0)
+ ;W "COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00),!
+"RTN","ut1",369,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J((ORIGLINES-LEFTLINES)/ORIGLINES*100,"",2),1:100.00)
+"RTN","ut1",370,0)
+ ;W !!
+"RTN","ut1",371,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="",LINNUM=LINNUM+1,@X@(LINNUM)=""
+"RTN","ut1",372,0)
+ ;W "BY ROUTINE:",!
+"RTN","ut1",373,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="BY ROUTINE:"
+"RTN","ut1",374,0)
+ I V=0 QUIT  ; No verbosity. Don't print routine detail
+"RTN","ut1",375,0)
+ N RTN S RTN=""
+"RTN","ut1",376,0)
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
+"RTN","ut1",377,0)
+ . N O S O=$$ACTLINES($NA(@C@(RTN)))
+"RTN","ut1",378,0)
+ . N L S L=$$ACTLINES($NA(@S@(RTN)))
+"RTN","ut1",379,0)
+ . ;W ?3,RTN,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+"RTN","ut1",380,0)
+ . N XX,XY S XX="  "_RTN_"                    ",XX=$E(XX,1,12)
+"RTN","ut1",381,0)
+ . S XY="        "_$S(O:$J((O-L)/O*100,"",2)_"%",1:"------"),XY=$E(XY,$L(XY)-11,$L(XY))
+"RTN","ut1",382,0)
+ . ;S LINNUM=LINNUM+1,@X@(LINNUM)=XX_$S(O:$J((O-L)/O*100,"",2)_"%",1:"------")_"  "_(O-L)_" out of "_O
+"RTN","ut1",383,0)
+ . S LINNUM=LINNUM+1,@X@(LINNUM)=XX_XY_"  "_(O-L)_" out of "_O
+"RTN","ut1",384,0)
+ . I V=1 QUIT  ; Just print the routine coverage for V=1
+"RTN","ut1",385,0)
+ . N TAG S TAG=""
+"RTN","ut1",386,0)
+ . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
+"RTN","ut1",387,0)
+ . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
+"RTN","ut1",388,0)
+ . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
+"RTN","ut1",389,0)
+ . . ;W ?5,TAG,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+"RTN","ut1",390,0)
+ . . S XX="    "_TAG_"                  ",XX=$E(XX,1,20)
+"RTN","ut1",391,0)
+ . . ;S XY="        ("_(O-L)_"/"_O_")",XY=$E(XY,$L(XY)-11,$L(XY)),XX=XX_XY
+"RTN","ut1",392,0)
+ . . S XY="      "_$S(O:$J((O-L)/O*100,"",2)_"%",1:"------"),XY=$E(XY,$L(XY)-7,$L(XY))
+"RTN","ut1",393,0)
+ . . S LINNUM=LINNUM+1,@X@(LINNUM)=XX_XY_"  "_(O-L)_" out of "_O
+"RTN","ut1",394,0)
+ . . I V=2 QUIT  ; Just print routine/tags coverage for V=2; V=3 print uncovered lines
+"RTN","ut1",395,0)
+ . . N LN S LN=""
+"RTN","ut1",396,0)
+ . . ;F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  W TAG_"+"_LN_": "_^(LN),!
+"RTN","ut1",397,0)
+ . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  S LINNUM=LINNUM+1,@X@(LINNUM)=TAG_"+"_LN_": "_^(LN)
+"RTN","ut1",398,0)
+ . . Q
+"RTN","ut1",399,0)
+ . Q
+"RTN","ut1",400,0)
+ QUIT
+"RTN","ut1",401,0)
+ ;
+"RTN","ut1",402,0)
+COVRPTGL(C,S,R,OUT) ; [Private] - Coverage Global for silent invokers
+"RTN","ut1",403,0)
+ ; C = COHORT    - Global name
+"RTN","ut1",404,0)
+ ; S = SURVIVORS - Global name
+"RTN","ut1",405,0)
+ ; R = RESULT    - Global name
+"RTN","ut1",406,0)
+ ; OUT = OUTPUT  - Global name
+"RTN","ut1",407,0)
+ ;
+"RTN","ut1",408,0)
+ N O S O=$$ACTLINES(C)
+"RTN","ut1",409,0)
+ N L S L=$$ACTLINES(S)
+"RTN","ut1",410,0)
+ S @OUT=(O-L)_"/"_O
+"RTN","ut1",411,0)
+ N RTN,TAG,LN S (RTN,TAG,LN)=""
+"RTN","ut1",412,0)
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
+"RTN","ut1",413,0)
+ . N O S O=$$ACTLINES($NA(@C@(RTN)))
+"RTN","ut1",414,0)
+ . N L S L=$$ACTLINES($NA(@S@(RTN)))
+"RTN","ut1",415,0)
+ . S @OUT@(RTN)=(O-L)_"/"_O
+"RTN","ut1",416,0)
+ . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
+"RTN","ut1",417,0)
+ . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
+"RTN","ut1",418,0)
+ . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
+"RTN","ut1",419,0)
+ . . S @OUT@(RTN,TAG)=(O-L)_"/"_O
+"RTN","ut1",420,0)
+ . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  S @OUT@(RTN,TAG,LN)=@S@(RTN,TAG,LN)
+"RTN","ut1",421,0)
+ QUIT
+"RTN","ut1",422,0)
+ ;
+"RTN","ut1",423,0)
+ISUTEST() ;
+"RTN","ut1",424,0)
+ Q $$ISUTEST^%ut()
+"RTN","utcover")
+0^3^B52893402
+"RTN","utcover",1,0)
+%utcover ;JLI - generic coverage and unit test runner ;12/16/15  08:42
+"RTN","utcover",2,0)
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
+"RTN","utcover",3,0)
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
+"RTN","utcover",4,0)
+ ; Original routine authored by Joel L. Ivey 08/15.  Additional work 08/15-12/15.
+"RTN","utcover",5,0)
+ ;
+"RTN","utcover",6,0)
+ ; Changes:  (Moved from %ut and %ut1)
+"RTN","utcover",7,0)
+ ; 130726 SMH - Moved test collection logic from %utUNIT to here (multiple places)
+"RTN","utcover",8,0)
+ ; 131218 SMH - dependence on XLFSTR removed
+"RTN","utcover",9,0)
+ ; 131218 SMH - CHEKTEST refactored to use $TEXT instead of ^%ZOSF("LOAD")
+"RTN","utcover",10,0)
+ ; 131218 SMH - CATCHERR now nulls out $ZS if on GT.M
+"RTN","utcover",11,0)
+ ;
+"RTN","utcover",12,0)
+ ; ------- COMMENTS moved from %ut due to space requirements
+"RTN","utcover",13,0)
+ ;
+"RTN","utcover",14,0)
+ ; 100622 JLI - corrected typo in comments where %utINPT was listed as %utINP
+"RTN","utcover",15,0)
+ ; 100622 JLI - removed a comment which indicated data could potentially be returned from the called routine
+"RTN","utcover",16,0)
+ ;              in the %utINPT array.
+"RTN","utcover",17,0)
+ ; 100622 JLI - added code to handle STARTUP and SHUTDOWN from GUI app
+"RTN","utcover",18,0)
+ ; 110719 JLI - modified separators in GUI handling from ^ to ~~^~~
+"RTN","utcover",19,0)
+ ;              in the variable XTGUISEP if using a newer version of the
+"RTN","utcover",20,0)
+ ;              GUI app (otherwise, it is simply set to ^) since results
+"RTN","utcover",21,0)
+ ;              with a series of ^ embedded disturbed the output reported
+"RTN","utcover",22,0)
+ ; 130726 SMH - Fixed SETUP and TEARDOWN so that they run before/after each
+"RTN","utcover",23,0)
+ ;              test rather than once. General refactoring.
+"RTN","utcover",24,0)
+ ; 130726 SMH - SETUT initialized IO in case it's not there to $P. Inits vars
+"RTN","utcover",25,0)
+ ;              using DT^DICRW.
+"RTN","utcover",26,0)
+ ; 131217 SMH - Change call in SETUP to S U="^" instead of DT^DICRW
+"RTN","utcover",27,0)
+ ; 131218 SMH - Any checks to $ZE will also check $ZS for GT.M.
+"RTN","utcover",28,0)
+ ; 131218 SMH - Remove calls to %ZISUTL to manage devices to prevent dependence on VISTA.
+"RTN","utcover",29,0)
+ ;              Use %utNIT("DEV","OLD") for old devices
+"RTN","utcover",30,0)
+ ; 140109 SMH - Add parameter %utBREAK - Break upon error
+"RTN","utcover",31,0)
+ ; 1402   SMH - Break will cause the break to happen even on failed tests.
+"RTN","utcover",32,0)
+ ; 140401 SMH - Added Succeed entry point for take it into your hands tester.
+"RTN","utcover",33,0)
+ ; 140401 SMH - Reformatted the output of M-Unit so that the test's name
+"RTN","utcover",34,0)
+ ;              will print BEFORE the execution of the test. This has been
+"RTN","utcover",35,0)
+ ;              really confusing for beginning users of M-Unit, so this was
+"RTN","utcover",36,0)
+ ;              necessary.
+"RTN","utcover",37,0)
+ ; 140401 SMH - OK message gets printed at the end of --- as [OK].
+"RTN","utcover",38,0)
+ ; 140401 SMH - FAIL message now prints. Previously, OK failed to be printed.
+"RTN","utcover",39,0)
+ ;              Unfortunately, that's rather passive aggressive. Now it
+"RTN","utcover",40,0)
+ ;              explicitly says that a test failed.
+"RTN","utcover",41,0)
+ ; 140503 SMH - Fixed IO issues all over the routine. Much simpler now.
+"RTN","utcover",42,0)
+ ; 140731 JLI - Combined routine changes between JLI and SMH
+"RTN","utcover",43,0)
+ ;              Moved routines from %utNIT and %utNIT1 to %ut and %ut1
+"RTN","utcover",44,0)
+ ;              Updated unit test routines (%utt1 to %utt6)
+"RTN","utcover",45,0)
+ ;              Created M-UNIT TEST GROUP file at 17.9001 based on the 17.9001 file
+"RTN","utcover",46,0)
+ ; 141030 JLI - Removed tag TESTCOVR and code under it, not necessary
+"RTN","utcover",47,0)
+ ;              since %uttcovr can handle all of the calling needed
+"RTN","utcover",48,0)
+ ;              Added call to run routine %utt6 if run from the top,
+"RTN","utcover",49,0)
+ ;              since this will run the full range of unit tests
+"RTN","utcover",50,0)
+ ;              Modified STARTUP and SHUTDOWN commands to handle in
+"RTN","utcover",51,0)
+ ;              each routine where they are available, since only
+"RTN","utcover",52,0)
+ ;              running one STARTUP and SHUTDOWN (the first seen by
+"RTN","utcover",53,0)
+ ;              the program) restricted their use in suites of multiple
+"RTN","utcover",54,0)
+ ;              tests.
+"RTN","utcover",55,0)
+ ; 150101 JLI - Added COV entry to %ut (in addition to current in %ut1) so it is easier
+"RTN","utcover",56,0)
+ ;              to remember how to use it.
+"RTN","utcover",57,0)
+ ; 150621 JLI - Added a global location to pick up summary data for a unit test call, so
+"RTN","utcover",58,0)
+ ;              programs running multiple calls can generate a summary if desired.
+"RTN","utcover",59,0)
+ ;
+"RTN","utcover",60,0)
+ ;
+"RTN","utcover",61,0)
+ D EN^%ut("%uttcovr") ; unit tests
+"RTN","utcover",62,0)
+ Q
+"RTN","utcover",63,0)
+ ;
+"RTN","utcover",64,0)
+MULTAPIS(TESTROUS) ; RUN TESTS FOR SPECIFIED ROUTINES AND ENTRY POINTS
+"RTN","utcover",65,0)
+ ; can be run from %ut using D MULTAPIS^%ut(.TESTROUS)
+"RTN","utcover",66,0)
+ ; input TESTROUS - passed by reference - array of routine names to run tests for
+"RTN","utcover",67,0)
+ ;               specify those to be called directly by including ^ as part of
+"RTN","utcover",68,0)
+ ;               TAG^ROUTINE or ^ROUTINE.
+"RTN","utcover",69,0)
+ ;               ROUTINE names without a ^ will be called as EN^%ut("ROUTINE")
+"RTN","utcover",70,0)
+ ;               Sometimes to get complete coverage, different entry points may
+"RTN","utcover",71,0)
+ ;               need to be called (e.g., at top and for VERBOSE), these should each
+"RTN","utcover",72,0)
+ ;               be included.
+"RTN","utcover",73,0)
+ ;               If the subscript is a number, it will take the list of comma separated
+"RTN","utcover",74,0)
+ ;               values as the routines.  If the the subscript is not a number, it will
+"RTN","utcover",75,0)
+ ;               take it as a routine to be added to the list, then if the value of the
+"RTN","utcover",76,0)
+ ;               contains a comma separated list of routines, they will be added as well.
+"RTN","utcover",77,0)
+ ;               Thus a value of
+"RTN","utcover",78,0)
+ ;                 TESTROUS(1)="A^ROU1,^ROU1,^ROU2,ROU3"
+"RTN","utcover",79,0)
+ ;               or a value of
+"RTN","utcover",80,0)
+ ;                 TESTROUS("A^ROU1")="^ROU1,^ROU2,ROU3"
+"RTN","utcover",81,0)
+ ;               will both result in tests for
+"RTN","utcover",82,0)
+ ;                 D A^ROU1,^ROU1,^ROU2,EN^%ut("ROU3")
+"RTN","utcover",83,0)
+ K ^TMP("%utcover",$J,"TESTROUS")
+"RTN","utcover",84,0)
+ M ^TMP("%utcover",$J,"TESTROUS")=TESTROUS
+"RTN","utcover",85,0)
+ D COVENTRY
+"RTN","utcover",86,0)
+ K ^TMP("%utcover",$J,"TESTROUS")
+"RTN","utcover",87,0)
+ Q
+"RTN","utcover",88,0)
+ ;
+"RTN","utcover",89,0)
+COVENTRY ; setup of COVERAGE NEWs most variables, so TESTROUS passed by global
+"RTN","utcover",90,0)
+ ;
+"RTN","utcover",91,0)
+ N I,ROU,VAL,VALS,UTDATA,TESTS,TESTROUS
+"RTN","utcover",92,0)
+ M TESTROUS=^TMP("%utcover",$J,"TESTROUS")
+"RTN","utcover",93,0)
+ S ROU="" F  S ROU=$O(TESTROUS(ROU)) Q:ROU=""  D
+"RTN","utcover",94,0)
+ . I ROU'=+ROU S TESTS(ROU)=""
+"RTN","utcover",95,0)
+ . F I=1:1 S VAL=$P(TESTROUS(ROU),",",I) Q:VAL=""  S TESTS(VAL)=""
+"RTN","utcover",96,0)
+ . Q
+"RTN","utcover",97,0)
+ S ROU="" F  S ROU=$O(TESTS(ROU)) Q:ROU=""  D
+"RTN","utcover",98,0)
+ . W !!,"------------------- RUNNING ",ROU," -------------------"
+"RTN","utcover",99,0)
+ . I ROU[U D @ROU
+"RTN","utcover",100,0)
+ . I ROU'[U D @("EN^%ut("""_ROU_""")")
+"RTN","utcover",101,0)
+ . D GETUTVAL^%ut(.UTDATA)
+"RTN","utcover",102,0)
+ . Q
+"RTN","utcover",103,0)
+ I $D(UTDATA) D LSTUTVAL^%ut(.UTDATA)
+"RTN","utcover",104,0)
+ Q
+"RTN","utcover",105,0)
+ ;
+"RTN","utcover",106,0)
+COVERAGE(ROUNMSP,TESTROUS,XCLDROUS,RESLTLVL) ; run coverage analysis for multiple routines and entry points
+"RTN","utcover",107,0)
+ ; can be run from %ut using D COVERAGE^%ut(ROUNMSP,.TESTROUS,.XCLDROUS,RESLTLVL)
+"RTN","utcover",108,0)
+ ; input ROUNMSP - Namespace for routine(s) to be analyzed
+"RTN","utcover",109,0)
+ ;                 ROUNAME will result in only the routine ROUNAME being analyzed
+"RTN","utcover",110,0)
+ ;                 ROUN* will result in all routines beginning with ROUN being analyzed
+"RTN","utcover",111,0)
+ ; input TESTROUS - passed by reference - see TESTROUS description for JUSTTEST
+"RTN","utcover",112,0)
+ ; input XCLDROUS - passed by reference - routines passed in a manner similar to TESTROUS,
+"RTN","utcover",113,0)
+ ;                  but only the routine names, whether as arguments or a comma separated
+"RTN","utcover",114,0)
+ ;                  list of routines, will be excluded from the analysis of coverage.  These
+"RTN","utcover",115,0)
+ ;                  would normally be names of routines which are only for unit tests, or
+"RTN","utcover",116,0)
+ ;                  others which should not be included in the analysis for some reason.
+"RTN","utcover",117,0)
+ ; input RESLTLVL - This value determines the amount of information to be generated for the
+"RTN","utcover",118,0)
+ ;                  analysis.  A missing or null value will be considered to be level 1
+"RTN","utcover",119,0)
+ ;                     1  -  Listing of analysis only for routine overall
+"RTN","utcover",120,0)
+ ;                     2  -  Listing of analysis for routine overall and for each TAG
+"RTN","utcover",121,0)
+ ;                     3  -  Full analysis for each tag, and lists out those lines which were
+"RTN","utcover",122,0)
+ ;                           not executed during the analysis
+"RTN","utcover",123,0)
+ ;
+"RTN","utcover",124,0)
+ N I,ROU,TYPE,XCLUDE
+"RTN","utcover",125,0)
+ S RESLTLVL=$G(RESLTLVL,1)
+"RTN","utcover",126,0)
+ I (RESLTLVL<1) S RESLTLVL=1
+"RTN","utcover",127,0)
+ I (RESLTLVL>3) S RESLTLVL=3
+"RTN","utcover",128,0)
+ M ^TMP("%utcover",$J,"TESTROUS")=TESTROUS ;
+"RTN","utcover",129,0)
+ D COV^%ut1(ROUNMSP,"D COVENTRY^%utcover",-1)
+"RTN","utcover",130,0)
+ K ^TMP("%utcover",$J,"TESTROUS")
+"RTN","utcover",131,0)
+ S ROU="" F  S ROU=$O(XCLDROUS(ROU)) Q:ROU=""  D SETROUS(.XCLUDE,.XCLDROUS,ROU)
+"RTN","utcover",132,0)
+ N TEXTGLOB S TEXTGLOB=$NA(^TMP("%utcover-text",$J)) K @TEXTGLOB
+"RTN","utcover",133,0)
+ D LIST(.XCLUDE,RESLTLVL,TEXTGLOB)
+"RTN","utcover",134,0)
+ F I=1:1 Q:'$D(@TEXTGLOB@(I))  W !,@TEXTGLOB@(I)
+"RTN","utcover",135,0)
+ K @TEXTGLOB
+"RTN","utcover",136,0)
+ Q
+"RTN","utcover",137,0)
+ ;
+"RTN","utcover",138,0)
+SETROUS(XCLUDE,XCLDROUS,ROU) ;
+"RTN","utcover",139,0)
+ ; XCLUDE   - passed by reference - on return contains array with indices as routines to exclude from analysis
+"RTN","utcover",140,0)
+ ; XCLDROUS - passed by referenc - array may contain a comma-delimited list of routines to exclude from analysis
+"RTN","utcover",141,0)
+ ; ROU      - input - if non-numberic is name of routine to exclude from analysis
+"RTN","utcover",142,0)
+ N I,VAL
+"RTN","utcover",143,0)
+ I ROU'=+ROU S XCLUDE(ROU)=""
+"RTN","utcover",144,0)
+ F I=1:1 S VAL=$P(XCLDROUS(ROU),",",I) Q:VAL=""  S XCLUDE(VAL)=""
+"RTN","utcover",145,0)
+ Q
+"RTN","utcover",146,0)
+ ;
+"RTN","utcover",147,0)
+LIST(XCLDROUS,TYPE,TEXTGLOB,GLOB,LINNUM) ;
+"RTN","utcover",148,0)
+ ; ZEXCEPT: TYPE1  - NEWed and set below for recursion
+"RTN","utcover",149,0)
+ ; input - ROULIST - a comma separated list of routine names that will
+"RTN","utcover",150,0)
+ ;       be used to identify desired routines.  Any name
+"RTN","utcover",151,0)
+ ;       that begins with one of the specified values will
+"RTN","utcover",152,0)
+ ;       be included
+"RTN","utcover",153,0)
+ ; input - TYPE - value indicating amount of detail desired
+"RTN","utcover",154,0)
+ ;       3=full with listing of untouched lines
+"RTN","utcover",155,0)
+ ;       2=moderated with listing by tags
+"RTN","utcover",156,0)
+ ;       1=summary with listing by routine
+"RTN","utcover",157,0)
+ ; input - TEXTGLOB - closed global location in which text is returned
+"RTN","utcover",158,0)
+ ; input - GLOB - used for unit tests - specifies global to work with
+"RTN","utcover",159,0)
+ ;                so that coverage data is not impacted
+"RTN","utcover",160,0)
+ ;
+"RTN","utcover",161,0)
+ N CURRCOV,CURRLIN,LINCOV,LINE,LINTOT,ROULIST,ROUNAME,TAG,TOTCOV,TOTLIN,XVAL
+"RTN","utcover",162,0)
+ ;
+"RTN","utcover",163,0)
+ I '$D(LINNUM) S LINNUM=0 ; initialize on first entry
+"RTN","utcover",164,0)
+ I '$D(GLOB) N GLOB S GLOB=$NA(^TMP("%utCOVREPORT",$J))
+"RTN","utcover",165,0)
+ D TRIMDATA(.XCLDROUS,GLOB) ; remove undesired routines from data
+"RTN","utcover",166,0)
+ ;
+"RTN","utcover",167,0)
+ N JOB,NAME,BASE,TEXT,VAL
+"RTN","utcover",168,0)
+ S TOTCOV=0,TOTLIN=0
+"RTN","utcover",169,0)
+ ; F NAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
+"RTN","utcover",170,0)
+ I TYPE>1 S ROUNAME="" F  S ROUNAME=$O(@GLOB@(ROUNAME)) Q:ROUNAME=""  S XVAL=^(ROUNAME) D
+"RTN","utcover",171,0)
+ . S CURRCOV=$P(XVAL,"/"),CURRLIN=$P(XVAL,"/",2)
+"RTN","utcover",172,0)
+ . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="",LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=""
+"RTN","utcover",173,0)
+ . S TEXT="Routine "_ROUNAME_"              ",TEXT=$E(TEXT,1,20)
+"RTN","utcover",174,0)
+ . I CURRLIN>0 S VAL="     ("_$J((100*CURRCOV)/CURRLIN,"",2),VAL=$E(VAL,$L(VAL)-6,$L(VAL))
+"RTN","utcover",175,0)
+ . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=TEXT_"   "_$S(CURRLIN>0:VAL_"%)",1:"  ------ ")_"   "_CURRCOV_" out of "_CURRLIN_" lines covered"
+"RTN","utcover",176,0)
+ . I TYPE>1 S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="  - "_$S(TYPE=2:"Summary",1:"Detailed Breakdown")
+"RTN","utcover",177,0)
+ . S TAG="" F  S TAG=$O(@GLOB@(ROUNAME,TAG)) Q:TAG=""  S XVAL=^(TAG) D
+"RTN","utcover",178,0)
+ . . S LINCOV=$P(XVAL,"/"),LINTOT=$P(XVAL,"/",2)
+"RTN","utcover",179,0)
+ . . S TEXT=" Tag "_TAG_"^"_ROUNAME_"                ",TEXT=$E(TEXT,1,26)
+"RTN","utcover",180,0)
+ . . I LINTOT>0 S VAL="     ("_$J((100*LINCOV)/LINTOT,"",2),VAL=$E(VAL,$L(VAL)-6,$L(VAL))
+"RTN","utcover",181,0)
+ . . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=TEXT_$S(LINTOT>0:VAL_"%)",1:"  ------ ")_"   "_LINCOV_" out of "_LINTOT_" lines covered"
+"RTN","utcover",182,0)
+ . . I TYPE=2 Q
+"RTN","utcover",183,0)
+ . . I LINCOV=LINTOT Q
+"RTN","utcover",184,0)
+ . . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="   the following is a list of the lines **NOT** covered"
+"RTN","utcover",185,0)
+ . . S LINE="" F  S LINE=$O(@GLOB@(ROUNAME,TAG,LINE)) Q:LINE=""  D
+"RTN","utcover",186,0)
+ . . . I LINE=0 S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="     "_TAG_"  "_@GLOB@(ROUNAME,TAG,LINE) Q
+"RTN","utcover",187,0)
+ . . . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="     "_TAG_"+"_LINE_"  "_@GLOB@(ROUNAME,TAG,LINE)
+"RTN","utcover",188,0)
+ . . . Q
+"RTN","utcover",189,0)
+ . . Q
+"RTN","utcover",190,0)
+ . Q
+"RTN","utcover",191,0)
+ ; for type=3 generate a summary at bottom after detail
+"RTN","utcover",192,0)
+ I TYPE=3 N TYPE1 S TYPE1=2 D LIST(.XCLDROUS,2,TEXTGLOB,GLOB,.LINNUM) K TYPE1
+"RTN","utcover",193,0)
+ I TYPE=2,$G(TYPE1) Q  ; CAME IN FROM ABOVE LINE
+"RTN","utcover",194,0)
+ ; summarize by just routine name
+"RTN","utcover",195,0)
+ S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="",LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=""
+"RTN","utcover",196,0)
+ S ROUNAME="" F  S ROUNAME=$O(@GLOB@(ROUNAME)) Q:ROUNAME=""  S XVAL=^(ROUNAME) D
+"RTN","utcover",197,0)
+ . S CURRCOV=$P(XVAL,"/"),CURRLIN=$P(XVAL,"/",2)
+"RTN","utcover",198,0)
+ . S TOTCOV=TOTCOV+CURRCOV,TOTLIN=TOTLIN+CURRLIN
+"RTN","utcover",199,0)
+ . I CURRLIN>0 S VAL="     ("_$J((100*CURRCOV)/CURRLIN,"",2),VAL=$E(VAL,$L(VAL)-6,$L(VAL))
+"RTN","utcover",200,0)
+ . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="Routine "_ROUNAME_"     "_$S(CURRLIN>0:VAL_"%)",1:"  ------ ")_"   "_CURRCOV_" out of "_CURRLIN_" lines covered"
+"RTN","utcover",201,0)
+ S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="",LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=""
+"RTN","utcover",202,0)
+ S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="Overall Analysis "_TOTCOV_" out of "_TOTLIN_" lines covered"_$S(TOTLIN>0:" ("_$P((100*TOTCOV)/TOTLIN,".")_"% coverage)",1:"")
+"RTN","utcover",203,0)
+ Q
+"RTN","utcover",204,0)
+ ;
+"RTN","utcover",205,0)
+TRIMDATA(ROULIST,GLOB) ;
+"RTN","utcover",206,0)
+ N ROUNAME
+"RTN","utcover",207,0)
+ S ROUNAME="" F  S ROUNAME=$O(ROULIST(ROUNAME)) Q:ROUNAME=""  K @GLOB@(ROUNAME)
+"RTN","utcover",208,0)
+ Q
+"RTN","utcover",209,0)
  ;
 "RTN","utt1")
-0^3^B25860592
+0^4^B40989891
 "RTN","utt1",1,0)
-%utt1 ; VEN/SMH - Testing routines for M-Unit;08/29/14  11:35
+%utt1 ; VEN/SMH-JLI - Testing routines for M-Unit;2015-12-31  10:33 PM
 "RTN","utt1",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","utt1",3,0)
-%utNITT ; VEN/SMH - Testing routines for M-Unit;2014-04-01  2:04 PM
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","utt1",4,0)
- ;
+ ; Original routine authored by Sam H. Habiel 07/2013-04/2014
 "RTN","utt1",5,0)
- ; THIS ROUTINE IS THE UNIFIED UNIT TESTER FOR ALL OF M-UNIT.
+ ; Additions and modifications made by Joel L. Ivey 05/2014-12/2015
 "RTN","utt1",6,0)
  ;
 "RTN","utt1",7,0)
- ; Dear Users,
+ ; THIS ROUTINE IS THE UNIFIED UNIT TESTER FOR ALL OF M-UNIT.
 "RTN","utt1",8,0)
  ;
 "RTN","utt1",9,0)
- ; I know about about the irony of a test suite for the testing suite,
+ ; Dear Users,
 "RTN","utt1",10,0)
- ; so stop snikering. Aside from that, it's actually going to be hard.
-"RTN","utt1",11,0)
  ;
+"RTN","utt1",11,0)
+ ; I know about about the irony of a test suite for the testing suite,
 "RTN","utt1",12,0)
- ; Truly yours,
+ ; so stop snikering. Aside from that, it's actually going to be hard.
 "RTN","utt1",13,0)
  ;
 "RTN","utt1",14,0)
- ; Sam H
+ ; Truly yours,
 "RTN","utt1",15,0)
  ;
 "RTN","utt1",16,0)
- D EN^%ut($T(+0),1) ; Run tests here, be verbose.
+ ; Sam H
 "RTN","utt1",17,0)
- QUIT
+ ;
 "RTN","utt1",18,0)
- ;
+ D EN^%ut($T(+0),1) ; Run tests here, be verbose.
 "RTN","utt1",19,0)
-STARTUP ; M-Unit Start-Up - This runs before anything else.
+        N % S $P(%,"-",80)="-"
 "RTN","utt1",20,0)
- S ^TMP($J,"%ut","STARTUP")=""
+        W !!,%,!,%,!,%,!,%,!!
 "RTN","utt1",21,0)
- S KBANCOUNT=1
+        K %
 "RTN","utt1",22,0)
- QUIT
+ D EN^%ut($T(+0),2) ; Run tests here, be verbose with timings for each piece of code.
 "RTN","utt1",23,0)
- ;
-"RTN","utt1",24,0)
-SHUTDOWN ; M-Unit Shutdown - This runs after everything else is done.
-"RTN","utt1",25,0)
- K ^TMP($J,"%ut","STARTUP")
-"RTN","utt1",26,0)
- K KBANCOUNT
-"RTN","utt1",27,0)
  QUIT
+"RTN","utt1",24,0)
+ ;
+"RTN","utt1",25,0)
+STARTUP ; M-Unit Start-Up - This runs before anything else.
+"RTN","utt1",26,0)
+ ; ZEXCEPT: KBANCOUNT - created here, removed in SHUTDOWN
+"RTN","utt1",27,0)
+ S ^TMP($J,"%ut","STARTUP")=""
 "RTN","utt1",28,0)
- ;
+ S KBANCOUNT=1
 "RTN","utt1",29,0)
- ;
+ QUIT
 "RTN","utt1",30,0)
  ;
 "RTN","utt1",31,0)
-SETUP ; This runs before every test.
+SHUTDOWN ; M-Unit Shutdown - This runs after everything else is done.
 "RTN","utt1",32,0)
- S KBANCOUNT=KBANCOUNT+1
+ ; ZEXCEPT: KBANCOUNT - created in STARTUP, removed here
 "RTN","utt1",33,0)
- QUIT
+ K ^TMP($J,"%ut","STARTUP")
 "RTN","utt1",34,0)
- ;
+ K KBANCOUNT
 "RTN","utt1",35,0)
-TEARDOWN ; This runs after every test
-"RTN","utt1",36,0)
- S KBANCOUNT=KBANCOUNT-1
-"RTN","utt1",37,0)
  QUIT
+"RTN","utt1",36,0)
+ ;
+"RTN","utt1",37,0)
+ ;
 "RTN","utt1",38,0)
  ;
 "RTN","utt1",39,0)
- ;
+SETUP ; This runs before every test.
 "RTN","utt1",40,0)
- ;
+ ; ZEXCEPT: KBANCOUNT - created in STARTUP, removed in SHUTDOWN
 "RTN","utt1",41,0)
-T1 ; @TEST - Make sure Start-up Ran
+ S KBANCOUNT=KBANCOUNT+1
 "RTN","utt1",42,0)
- D CHKTF($D(^TMP($J,"%ut","STARTUP")),"Start-up node on ^TMP must exist")
-"RTN","utt1",43,0)
  QUIT
-"RTN","utt1",44,0)
+"RTN","utt1",43,0)
  ;
+"RTN","utt1",44,0)
+TEARDOWN ; This runs after every test
 "RTN","utt1",45,0)
-T2 ; @TEST - Make sure Set-up runs
+ ; ZEXCEPT: KBANCOUNT - created in STARTUP, removed in SHUTDOWN
 "RTN","utt1",46,0)
- D CHKEQ(KBANCOUNT,2,"KBANCount not incremented properly at SETUP")
+ S KBANCOUNT=KBANCOUNT-1
 "RTN","utt1",47,0)
  QUIT
 "RTN","utt1",48,0)
  ;
 "RTN","utt1",49,0)
-T3 ; @TEST - Make sure Teardown runs
+ ;
 "RTN","utt1",50,0)
- D CHKEQ(KBANCOUNT,2,"KBANCount not decremented properly at TEARDOWN")
+ ;
 "RTN","utt1",51,0)
- QUIT
+T1 ; @TEST - Make sure Start-up Ran
 "RTN","utt1",52,0)
- ;
+ D CHKTF($D(^TMP($J,"%ut","STARTUP")),"Start-up node on ^TMP must exist")
 "RTN","utt1",53,0)
-T4 ; Specified in XTMTAG
+ QUIT
 "RTN","utt1",54,0)
- ; 140731 JLI - note that this will fail when run from the GUI runner, since it calls each tag separately
+ ;
 "RTN","utt1",55,0)
- I $G(%utGUI) D CHKEQ(%utETRY,"T4","T4 should be the value for %utETRY in the GUI Runner")
+T2 ; @TEST - Make sure Set-up runs
 "RTN","utt1",56,0)
- I '$G(%utGUI) D CHKEQ(%utETRY(4),"T4","T4 should be the collected as the fourth entry in %utETRY")
+ ; ZEXCEPT: KBANCOUNT - created in STARTUP, removed in SHUTDOWN
 "RTN","utt1",57,0)
- QUIT
+ D CHKEQ(KBANCOUNT,2,"KBANCount not incremented properly at SETUP")
 "RTN","utt1",58,0)
- ;
+ QUIT
 "RTN","utt1",59,0)
-T5 ; ditto
+ ;
 "RTN","utt1",60,0)
- D CHKTF(0,"This is an intentional failure.")
+T3 ; @TEST - Make sure Teardown runs
 "RTN","utt1",61,0)
- D CHKEQ(%ut("FAIL"),1,"By this point, we should have failed one test")
+ ; ZEXCEPT: KBANCOUNT - created in STARTUP, removed in SHUTDOWN
 "RTN","utt1",62,0)
- D FAIL^%ut("Intentionally throwing a failure")
+ D CHKEQ(KBANCOUNT,2,"KBANCount not decremented properly at TEARDOWN")
 "RTN","utt1",63,0)
- D CHKEQ(%ut("FAIL"),2,"By this point, we should have failed two tests")
+ QUIT
 "RTN","utt1",64,0)
- ; S %ut("FAIL")=0 ; Okay... Boy's and Girls... as the developer I can do that.
+ ;
 "RTN","utt1",65,0)
- QUIT
+T4 ; Specified in XTMTAG
 "RTN","utt1",66,0)
- ;
+ ; 140731 JLI - note that this will fail when run from the GUI runner, since it calls each tag separately
 "RTN","utt1",67,0)
-T6 ; ditto
+ ; ZEXCEPT: %utETRY - newed and created in EN1^%ut
 "RTN","utt1",68,0)
- N TESTCOUNT S TESTCOUNT=%ut("CHK")
+ ; ZEXCEPT: %utGUI      -- CONDITIONALLY DEFINED BY GUINEXT^%ut
 "RTN","utt1",69,0)
- D SUCCEED^%ut
+ I $G(%utGUI) D CHKEQ(%utETRY,"T4","T4 should be the value for %utETRY in the GUI Runner")
 "RTN","utt1",70,0)
- D SUCCEED^%ut
+ I '$G(%utGUI) D CHKEQ(%utETRY(4),"T4","T4 should be the collected as the fourth entry in %utETRY")
 "RTN","utt1",71,0)
- D CHKEQ(%ut("CHK"),TESTCOUNT+2,"Succeed should increment the number of tests")
+ QUIT
 "RTN","utt1",72,0)
- QUIT
+ ;
 "RTN","utt1",73,0)
- ;
+T5 ; ditto
 "RTN","utt1",74,0)
-T7 ; Make sure we write to principal even though we are on another device
+ ; ZEXCEPT: %ut - NEWed and created in EN1^%ut
 "RTN","utt1",75,0)
- ; This is a rather difficult test to carry out for GT.M and Cache...
+ D CHKTF(0,"This is an intentional failure.")
 "RTN","utt1",76,0)
- N D
+ D CHKEQ(%ut("FAIL"),1,"By this point, we should have failed one test")
 "RTN","utt1",77,0)
- I +$SY=47 S D="/tmp/test.txt" ; All GT.M ; VMS not supported.
+ D FAIL^%ut("Intentionally throwing a failure")
 "RTN","utt1",78,0)
- I +$SY=0 D  ; All Cache
+ D CHKEQ(%ut("FAIL"),2,"By this point, we should have failed two tests")
 "RTN","utt1",79,0)
- . I $ZVERSION(1)=2 S D=$SYSTEM.Util.GetEnviron("temp")_"\test.txt" I 1 ; Windows
+ ; S %ut("FAIL")=0 ; Okay... Boy's and Girls... as the developer I can do that.
 "RTN","utt1",80,0)
- . E  S D="/tmp/test.txt" ; not windows; VMS not supported.
-"RTN","utt1",81,0)
- I +$SY=0 O D:"NWS" ; Cache new file
-"RTN","utt1",82,0)
- I +$SY=47 O D:(newversion) ; GT.M new file
-"RTN","utt1",83,0)
- U D
-"RTN","utt1",84,0)
- WRITE "HELLO",!
-"RTN","utt1",85,0)
- WRITE "HELLO",!
-"RTN","utt1",86,0)
- C D
-"RTN","utt1",87,0)
- ;
-"RTN","utt1",88,0)
- ; Now open back the file, and read the hello, but open in read only so
-"RTN","utt1",89,0)
- ; M-Unit will error out if it will write something out there.
-"RTN","utt1",90,0)
- ;
-"RTN","utt1",91,0)
- ; Per VISTA conventions, current IO device should be IO, old is IO(0).
-"RTN","utt1",92,0)
- ;
-"RTN","utt1",93,0)
- I +$SY=0 O D:"R"
-"RTN","utt1",94,0)
- I +$SY=47 O D:(readonly)
-"RTN","utt1",95,0)
- U D
-"RTN","utt1",96,0)
- N X READ X:1
-"RTN","utt1",97,0)
- D CHKTF(X="HELLO")  ; This should write to the screen the dot not to the file.
-"RTN","utt1",98,0)
- D CHKTF(($$LO($IO)=$$LO(D)),"IO device didn't get reset back")       ; $$LO is b/c of a bug in Cache/Windows. $IO is not the same cas D.
-"RTN","utt1",99,0)
- I +$SY=0 C D:"D"
-"RTN","utt1",100,0)
- I +$SY=47 C D:(delete)
-"RTN","utt1",101,0)
- U $P
-"RTN","utt1",102,0)
- S IO=$IO
-"RTN","utt1",103,0)
  QUIT
+"RTN","utt1",81,0)
+ ;
+"RTN","utt1",82,0)
+T6 ; ditto
+"RTN","utt1",83,0)
+ ; ZEXCEPT: %ut - NEWed and created in EN1^%ut
+"RTN","utt1",84,0)
+ N TESTCOUNT S TESTCOUNT=%ut("CHK")
+"RTN","utt1",85,0)
+ D SUCCEED^%ut
+"RTN","utt1",86,0)
+ D SUCCEED^%ut
+"RTN","utt1",87,0)
+ D CHKEQ(%ut("CHK"),TESTCOUNT+2,"Succeed should increment the number of tests")
+"RTN","utt1",88,0)
+ QUIT
+"RTN","utt1",89,0)
+ ;
+"RTN","utt1",90,0)
+T7 ; Make sure we write to principal even though we are on another device
+"RTN","utt1",91,0)
+ ; This is a rather difficult test to carry out for GT.M and Cache...
+"RTN","utt1",92,0)
+ ; ZEXCEPT: GetEnviron,Util,delete,newversion,readonly - not really variables
+"RTN","utt1",93,0)
+ N D
+"RTN","utt1",94,0)
+ I +$SY=47 S D="/tmp/test.txt" ; All GT.M ; VMS not supported.
+"RTN","utt1",95,0)
+ I +$SY=0 D  ; All Cache
+"RTN","utt1",96,0)
+ . I $ZVERSION(1)=2 S D=$SYSTEM.Util.GetEnviron("temp")_"\test.txt" I 1 ; Windows
+"RTN","utt1",97,0)
+ . E  S D="/tmp/test.txt" ; not windows; VMS not supported.
+"RTN","utt1",98,0)
+ I +$SY=0 O D:"NWS" ; Cache new file
+"RTN","utt1",99,0)
+ I +$SY=47 O D:(newversion) ; GT.M new file
+"RTN","utt1",100,0)
+ U D
+"RTN","utt1",101,0)
+ WRITE "HELLO",!
+"RTN","utt1",102,0)
+ WRITE "HELLO",!
+"RTN","utt1",103,0)
+ C D
 "RTN","utt1",104,0)
  ;
 "RTN","utt1",105,0)
- ; At the moment T8^%utt1 throws a fail, with no message
+ ; Now open back the file, and read the hello, but open in read only so
 "RTN","utt1",106,0)
- ; in the GUI runner.  For some reason, both X and Y
+ ; M-Unit will error out if it will write something out there.
 "RTN","utt1",107,0)
- ; variables are returned as null strings, while in the
+ ;
 "RTN","utt1",108,0)
- ; command line runner, Y has a value containing the
+ I +$SY=0 O D:"R"
 "RTN","utt1",109,0)
- ; word being sought
+ I +$SY=47 O D:(readonly)
 "RTN","utt1",110,0)
- ;
+ U D
 "RTN","utt1",111,0)
-T8 ; If IO starts with another device, write to that device as if it's the pricipal device
+ N X READ X:1
 "RTN","utt1",112,0)
- N D
+ D CHKTF(X="HELLO")  ; This should write to the screen the dot not to the file.
 "RTN","utt1",113,0)
- I +$SY=47 S D="/tmp/test.txt" ; All GT.M ; VMS not supported.
+ D CHKTF(($$LO($IO)=$$LO(D)),"IO device didn't get reset back")       ; $$LO is b/c of a bug in Cache/Windows. $IO is not the same cas D.
 "RTN","utt1",114,0)
- I +$SY=0 D  ; All Cache
-"RTN","utt1",115,0)
- . I $ZVERSION(1)=2 S D=$SYSTEM.Util.GetEnviron("temp")_"\test.txt" I 1 ; Windows
-"RTN","utt1",116,0)
- . E  S D="/tmp/test.txt" ; not windows; VMS not supported.
-"RTN","utt1",117,0)
- I +$SY=0 O D:"NWS" ; Cache new file
-"RTN","utt1",118,0)
- I +$SY=47 O D:(newversion) ; GT.M new file
-"RTN","utt1",119,0)
- S IO=D
-"RTN","utt1",120,0)
- U D
-"RTN","utt1",121,0)
- D ^%utt4 ; Run some Unit Tests
-"RTN","utt1",122,0)
- C D
-"RTN","utt1",123,0)
- I +$SY=0 O D:"R" ; Cache read only
-"RTN","utt1",124,0)
- I +$SY=47 O D:(readonly) ; GT.M read only
-"RTN","utt1",125,0)
- U D
-"RTN","utt1",126,0)
- N X,Y,Z R X:1,Y:1,Z:1
-"RTN","utt1",127,0)
  I +$SY=0 C D:"D"
-"RTN","utt1",128,0)
+"RTN","utt1",115,0)
  I +$SY=47 C D:(delete)
+"RTN","utt1",116,0)
+ U $P
+"RTN","utt1",117,0)
+ S IO=$IO
+"RTN","utt1",118,0)
+ QUIT
+"RTN","utt1",119,0)
+ ;
+"RTN","utt1",120,0)
+ ; At the moment T8^%utt1 throws a fail, with no message
+"RTN","utt1",121,0)
+ ; in the GUI runner.  For some reason, both X and Y
+"RTN","utt1",122,0)
+ ; variables are returned as null strings, while in the
+"RTN","utt1",123,0)
+ ; command line runner, Y has a value containing the
+"RTN","utt1",124,0)
+ ; word being sought
+"RTN","utt1",125,0)
+ ;
+"RTN","utt1",126,0)
+T8 ; If IO starts with another device, write to that device as if it's the pricipal device
+"RTN","utt1",127,0)
+ ; ZEXCEPT: GetEnviron,Util,delete,newversion,readonly - not really variables
+"RTN","utt1",128,0)
+ N D
 "RTN","utt1",129,0)
- ;D CHKTF(Y["MAIN") ; JLI 140829 commented out, gui doesn't run verbose
+ I +$SY=47 S D="/tmp/test.txt" ; All GT.M ; VMS not supported.
 "RTN","utt1",130,0)
- D CHKTF((Y["MAIN")!(Z["Ran 1 Routine"),"Write to system during test didn't work")
+ I +$SY=0 D  ; All Cache
 "RTN","utt1",131,0)
- S IO=$P
+ . I $ZVERSION(1)=2 S D=$SYSTEM.Util.GetEnviron("temp")_"\test.txt" I 1 ; Windows
 "RTN","utt1",132,0)
- QUIT
+ . E  S D="/tmp/test.txt" ; not windows; VMS not supported.
 "RTN","utt1",133,0)
- ;
+ I +$SY=0 O D:"NWS" ; Cache new file
 "RTN","utt1",134,0)
-LO(X) Q $TR(X,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")
+ I +$SY=47 O D:(newversion) ; GT.M new file
 "RTN","utt1",135,0)
- ; Shortcut methods for M-Unit
+ S IO=D
 "RTN","utt1",136,0)
-CHKTF(X,Y)   D CHKTF^%ut(X,$G(Y))   QUIT
+ U D
 "RTN","utt1",137,0)
-CHKEQ(A,B,M) D CHKEQ^%ut(A,B,$G(M)) QUIT
+ D ^%utt4 ; Run some Unit Tests
 "RTN","utt1",138,0)
- ;
+ C D
 "RTN","utt1",139,0)
-XTENT ; Entry points
+ I +$SY=0 O D:"R" ; Cache read only
 "RTN","utt1",140,0)
- ;;T4;Entry point using XTMENT
+ I +$SY=47 O D:(readonly) ; GT.M read only
 "RTN","utt1",141,0)
- ;;T5;Error count check
+ U D
 "RTN","utt1",142,0)
- ;;T6;Succeed Entry Point
+ N X,Y,Z R X:1,Y:1,Z:1
 "RTN","utt1",143,0)
- ;;T7;Make sure we write to principal even though we are on another device
+ I +$SY=0 C D:"D"
 "RTN","utt1",144,0)
- ;;T8;If IO starts with another device, write to that device as if it's the pricipal device
+ I +$SY=47 C D:(delete)
 "RTN","utt1",145,0)
- ;
+ ;D CHKTF(Y["MAIN") ; JLI 140829 commented out, gui doesn't run verbose
 "RTN","utt1",146,0)
-XTROU ; Routines containing additional tests
+ D CHKTF((Y["MAIN")!(Z["T2 - Test 2"),"Write to system during test didn't work")
 "RTN","utt1",147,0)
- ;;%utt2; old %utNITU
+ S IO=$P
 "RTN","utt1",148,0)
- ;;%utt4; old %utNITW
-"RTN","utt1",149,0)
- ;;%utt5;
-"RTN","utt1",150,0)
- ;;%utt6;
-"RTN","utt2")
-0^4^B473823
-"RTN","utt2",1,0)
-%utt2 ; VEN/SMH - Bad Ass Continuation of Unit Tests;08/04/14  09:12
-"RTN","utt2",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
-"RTN","utt2",3,0)
-XTMUNITU ; VEN/SMH - Bad Ass Continuation of Unit Tests;2014-04-01  1:03 PM
-"RTN","utt2",4,0)
- ;
-"RTN","utt2",5,0)
-T11 ; @TEST An @TEST Entry point in Another Routine invoked through XTROU offsets
-"RTN","utt2",6,0)
- D CHKTF^%ut(1)
-"RTN","utt2",7,0)
  QUIT
+"RTN","utt1",149,0)
+ ;
+"RTN","utt1",150,0)
+COVRPTGL ;
+"RTN","utt1",151,0)
+ N GL1,GL2,GL3,GL4
+"RTN","utt1",152,0)
+ S GL1=$NA(^TMP("%utCOVCOHORTSAVx",$J)) K @GL1
+"RTN","utt1",153,0)
+ S GL2=$NA(^TMP("%utCOVCOHORTx",$J)) K @GL2
+"RTN","utt1",154,0)
+ S GL3=$NA(^TMP("%utCOVRESULTx",$J)) K @GL3
+"RTN","utt1",155,0)
+ S GL4=$NA(^TMP("%utCOVREPORTx",$J)) K @GL4
+"RTN","utt1",156,0)
+ D SETGLOBS^%uttcovr(GL1,GL2)
+"RTN","utt1",157,0)
+ D COVRPTGL^%ut1(GL1,GL2,GL3,GL4)
+"RTN","utt1",158,0)
+ D CHKEQ($G(@GL4@("%ut1","ACTLINES")),"0/9","Wrong number of lines covered f>>or ACTLINES")
+"RTN","utt1",159,0)
+ D CHKEQ($G(@GL4@("%ut1","ACTLINES",9))," QUIT CNT","Wrong result for last l>>ine not covered for ACTLINES")
+"RTN","utt1",160,0)
+ D CHKEQ($G(@GL4@("%ut1","CHEKTEST")),"8/10","Wrong number of lines covered >>for CHEKTEST")
+"RTN","utt1",161,0)
+ D CHKEQ($G(@GL4@("%ut1","CHEKTEST",39))," . Q","Wrong result for last line >>not covered for CHEKTEST")
+"RTN","utt1",162,0)
+ K @GL1,@GL2,@GL3,@GL4
+"RTN","utt1",163,0)
+ Q
+"RTN","utt1",164,0)
+ ;
+"RTN","utt1",165,0)
+LO(X) Q $TR(X,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")
+"RTN","utt1",166,0)
+ ; Shortcut methods for M-Unit
+"RTN","utt1",167,0)
+CHKTF(X,Y) ;
+"RTN","utt1",168,0)
+ D CHKTF^%ut(X,$G(Y))
+"RTN","utt1",169,0)
+ QUIT
+"RTN","utt1",170,0)
+ ;
+"RTN","utt1",171,0)
+CHKEQ(A,B,M) ;
+"RTN","utt1",172,0)
+ D CHKEQ^%ut(A,B,$G(M))
+"RTN","utt1",173,0)
+ QUIT
+"RTN","utt1",174,0)
+ ;
+"RTN","utt1",175,0)
+XTENT ; Entry points
+"RTN","utt1",176,0)
+ ;;T4;Entry point using XTMENT
+"RTN","utt1",177,0)
+ ;;T5;Error count check
+"RTN","utt1",178,0)
+ ;;T6;Succeed Entry Point
+"RTN","utt1",179,0)
+ ;;T7;Make sure we write to principal even though we are on another device
+"RTN","utt1",180,0)
+ ;;T8;If IO starts with another device, write to that device as if it's the pricipal device
+"RTN","utt1",181,0)
+ ;;COVRPTGL;coverage report returning global
+"RTN","utt1",182,0)
+ ;
+"RTN","utt1",183,0)
+XTROU ; Routines containing additional tests
+"RTN","utt1",184,0)
+ ;;%utt2; old %utNITU
+"RTN","utt1",185,0)
+ ;;%utt4; old %utNITW
+"RTN","utt1",186,0)
+ ;;%utt5;
+"RTN","utt1",187,0)
+ ;;%utt6;
+"RTN","utt1",188,0)
+ ;;%uttcovr;coverage related tests
+"RTN","utt2")
+0^5^B501728
+"RTN","utt2",1,0)
+%utt2 ; VEN/SMH - Bad Ass Continuation of Unit Tests;12/16/15  08:44
+"RTN","utt2",2,0)
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
+"RTN","utt2",3,0)
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
+"RTN","utt2",4,0)
+ ; Original routine authored by Sam H. Habiel
+"RTN","utt2",5,0)
+ ; Modifications made by Joel L. Ivey 05/2014-09/2015
+"RTN","utt2",6,0)
+ ;
+"RTN","utt2",7,0)
+ ;
 "RTN","utt2",8,0)
-T12 ;
+T11 ; @TEST An @TEST Entry point in Another Routine invoked through XTROU offsets
 "RTN","utt2",9,0)
  D CHKTF^%ut(1)
 "RTN","utt2",10,0)
  QUIT
 "RTN","utt2",11,0)
-XTENT ;
+T12 ;
 "RTN","utt2",12,0)
+ D CHKTF^%ut(1)
+"RTN","utt2",13,0)
+ QUIT
+"RTN","utt2",14,0)
+XTENT ;
+"RTN","utt2",15,0)
  ;;T12;An XTENT offset entry point in Another Routine invoked through XTROU offsets
 "RTN","utt3")
-0^5^B1493136
+0^6^B1628564
 "RTN","utt3",1,0)
-%utt3 ; VEN/SMH - Unit Tests Coverage Tests;08/14/14  14:02
+%utt3 ; VEN/SMH-JLI - Unit Tests Coverage Tests;12/16/15  08:45
 "RTN","utt3",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","utt3",3,0)
-XTMUNITV ; VEN/SMH - Unit Tests Coverage Tests;2014-04-16  7:14 PM
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","utt3",4,0)
- ;
+ ; Original routine authored by Sam H. Habiel 07/2013-04/2014
 "RTN","utt3",5,0)
- ; *** BE VERY CAREFUL IN MODIFIYING THIS ROUTINE ***
+ ; Additions and modifications made by Joel L. Ivey 05/2014-08/2015
 "RTN","utt3",6,0)
- ; *** THE UNIT TEST COUNTS ACTIVE AND INACTIVE LINES OF CODE ***
+ ;
 "RTN","utt3",7,0)
- ; *** IF YOU MODIFY THIS, MODIFY XTMUNITW AS WELL ***
+XTMUNITV ; VEN/SMH - Unit Tests Coverage Tests;2014-04-16  7:14 PM
 "RTN","utt3",8,0)
  ;
 "RTN","utt3",9,0)
- ; Coverage tester in %utt4
+ ; *** BE VERY CAREFUL IN MODIFIYING THIS ROUTINE ***
 "RTN","utt3",10,0)
- ; 20 Lines of code
+ ; *** THE UNIT TEST COUNTS ACTIVE AND INACTIVE LINES OF CODE ***
 "RTN","utt3",11,0)
- ; 5 do not run as they are dead code
+ ; *** IF YOU MODIFY THIS, MODIFY XTMUNITW AS WELL ***
 "RTN","utt3",12,0)
- ; Expected Coverage: 15/20 = 75%
+ ;
 "RTN","utt3",13,0)
- ;
+ ; Coverage tester in %utt4
 "RTN","utt3",14,0)
-STARTUP ; Doesn't count
+ ; 20 Lines of code
 "RTN","utt3",15,0)
- N X    ; Counts
+ ; 5 do not run as they are dead code
 "RTN","utt3",16,0)
- S X=1  ; Counts
+ ; Expected Coverage: 15/20 = 75%
 "RTN","utt3",17,0)
- QUIT   ; Counts
+ ;
 "RTN","utt3",18,0)
- ;
+STARTUP ; Doesn't count
 "RTN","utt3",19,0)
-SHUTDOWN K X,Y QUIT     ; Counts; ZEXCEPT: X,Y
+ N X    ; Counts
 "RTN","utt3",20,0)
- ;
+ S X=1  ; Counts
 "RTN","utt3",21,0)
-SETUP S Y=$G(Y)+1 QUIT  ; Counts
+ QUIT   ; Counts
 "RTN","utt3",22,0)
  ;
 "RTN","utt3",23,0)
-TEARDOWN ; Doesn't count
+SHUTDOWN K X,Y QUIT     ; Counts; ZEXCEPT: X,Y
 "RTN","utt3",24,0)
- S Y=Y-1 ; Counts
+ ;
 "RTN","utt3",25,0)
- QUIT    ; Counts
+SETUP S Y=$G(Y)+1 QUIT  ; Counts
 "RTN","utt3",26,0)
  ;
 "RTN","utt3",27,0)
-T1 ; @TEST Test 1
+TEARDOWN ; Doesn't count
 "RTN","utt3",28,0)
- D CHKTF^%ut($D(Y)) ; Counts
+ S Y=Y-1 ; Counts
 "RTN","utt3",29,0)
- QUIT                   ; Counts
+ QUIT    ; Counts
 "RTN","utt3",30,0)
  ;
 "RTN","utt3",31,0)
-T2 ; @TEST Test 2
+T1 ; @TEST Test 1
 "RTN","utt3",32,0)
- D INTERNAL(1)          ; Counts
+ D CHKTF^%ut($D(Y)) ; Counts
 "RTN","utt3",33,0)
- D CHKTF^%ut(1)     ; Counts
-"RTN","utt3",34,0)
  QUIT                   ; Counts
-"RTN","utt3",35,0)
- S X=1                  ; Dead code
-"RTN","utt3",36,0)
- QUIT                   ; Dead code
-"RTN","utt3",37,0)
+"RTN","utt3",34,0)
  ;
+"RTN","utt3",35,0)
+T2 ; @TEST Test 2
+"RTN","utt3",36,0)
+ D INTERNAL(1)          ; Counts
+"RTN","utt3",37,0)
+ D CHKTF^%ut(1)     ; Counts
 "RTN","utt3",38,0)
-INTERNAL(A) ; Counts
+ QUIT                   ; Counts
 "RTN","utt3",39,0)
- S A=A+1    ; Counts
+ S X=1                  ; Dead code
 "RTN","utt3",40,0)
- QUIT       ; Counts
+ QUIT                   ; Dead code
 "RTN","utt3",41,0)
- S A=2      ; Dead code
+ ;
 "RTN","utt3",42,0)
- S Y=2      ; Dead code
+INTERNAL(A) ; Counts
 "RTN","utt3",43,0)
+ S A=A+1    ; Counts
+"RTN","utt3",44,0)
+ QUIT       ; Counts
+"RTN","utt3",45,0)
+ S A=2      ; Dead code
+"RTN","utt3",46,0)
+ S Y=2      ; Dead code
+"RTN","utt3",47,0)
  QUIT       ; Dead code
 "RTN","utt4")
-0^6^B1419637
+0^7^B1568129
 "RTN","utt4",1,0)
-%utt4 ; VEN/SMH - Coverage Test Runner;08/23/14  08:33
+%utt4 ; VEN/SMH/JLI - Coverage Test Runner;12/16/15  08:45
 "RTN","utt4",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","utt4",3,0)
-XTMUNITW ; VEN/SMH - Coverage Test Runner;2014-04-17  3:30 PM
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","utt4",4,0)
- ;;7.3;KERNEL TOOLKIT;;
+ ; Original routine authored by Sam H. Habiel 07/2013-04/2014
 "RTN","utt4",5,0)
- ;
+ ; Additions and modifications made by Joel L. Ivey 05/2014-08/2015
 "RTN","utt4",6,0)
- ; This tests code in XTMUNITV for coverage
-"RTN","utt4",7,0)
- D EN^%ut($T(+0),1) QUIT
-"RTN","utt4",8,0)
  ;
+"RTN","utt4",7,0)
+XTMUNITW ; VEN/SMH - Coverage Test Runner;2014-04-17  3:30 PM
+"RTN","utt4",8,0)
+ ;;7.3;KERNEL TOOLKIT;;
 "RTN","utt4",9,0)
-MAIN ; @TEST - Test coverage calculations
+ ;
 "RTN","utt4",10,0)
- Q:$D(^TMP("%uttcovr",$J))  ; already running coverage analysis from %uttcovr
+ ; This tests code in XTMUNITV for coverage
 "RTN","utt4",11,0)
- Q:'(+$SY=47)  ; GT.M ONLY
+ D EN^%ut($T(+0),1) QUIT
 "RTN","utt4",12,0)
- ;D COV^%ut1("XTMUNITV","D EN^%ut(""XTMUNITV"",1)",-1)  ; Only produce output global.
+ ;
 "RTN","utt4",13,0)
- D COV^%ut1("%utt3","D EN^%ut(""%utt3"",1)",-1)  ; Only produce output global.
+MAIN ; @TEST - Test coverage calculations
 "RTN","utt4",14,0)
- D CHKEQ^%ut(^TMP("%utCOVREPORT",$J),"15/20")
+ Q:$D(^TMP("%uttcovr",$J))  ; already running coverage analysis from %uttcovr
 "RTN","utt4",15,0)
- ;D CHKEQ^%ut(^TMP("XTMCOVREPORT",$J,"XTMUNITV","INTERNAL"),"3/6")
+ S ^TMP("%utt4val",$J)=1
 "RTN","utt4",16,0)
- D CHKEQ^%ut(^TMP("%utCOVREPORT",$J,"%utt3","INTERNAL"),"3/6")
+ D COV^%ut("%utt3","D EN^%ut(""%utt3"",1)",-1)  ; Only produce output global.
 "RTN","utt4",17,0)
- ;D CHKTF^%ut($D(^TMP("XTMCOVREPORT",$J,"XTMUNITV","T2",4)))
+ D CHKEQ^%ut("14/19",^TMP("%utCOVREPORT",$J))
 "RTN","utt4",18,0)
- D CHKTF^%ut($D(^TMP("%utCOVREPORT",$J,"%utt3","T2",4)))
+ D CHKEQ^%ut("2/5",^TMP("%utCOVREPORT",$J,"%utt3","INTERNAL"))
 "RTN","utt4",19,0)
- ;D CHKEQ^%ut(^TMP("XTMCOVREPORT",$J,"XTMUNITV","SETUP"),"1/1")
+ D CHKTF^%ut($D(^TMP("%utCOVREPORT",$J,"%utt3","T2",4)))
 "RTN","utt4",20,0)
- D CHKEQ^%ut(^TMP("%utCOVREPORT",$J,"%utt3","SETUP"),"1/1")
+ D CHKEQ^%ut("1/1",^TMP("%utCOVREPORT",$J,"%utt3","SETUP"))
 "RTN","utt4",21,0)
+ K ^TMP("%utt4val",$J)
+"RTN","utt4",22,0)
  QUIT
 "RTN","utt5")
-0^7^B22421637
+0^8^B23054235
 "RTN","utt5",1,0)
-%utt5 ;JLI - test for aspects of MUnit functionality ;08/29/14  11:23
+%utt5 ;JLI - test for aspects of MUnit functionality ;12/16/15  08:47
 "RTN","utt5",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","utt5",3,0)
- Q
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","utt5",4,0)
- ;
+ ; Original routine authored by Joel L. Ivey 05/2014-12/2015.
 "RTN","utt5",5,0)
-OLDSTYLE ;
+ ;
 "RTN","utt5",6,0)
- ; ZEXCEPT: %ut - Newed in EN^%zu
+ Q
 "RTN","utt5",7,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ;
 "RTN","utt5",8,0)
- I $D(%utt6var) S %ut("ENT")="OLDSTYLE",%utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"OLDSTYLE")=""
+OLDSTYLE ;
 "RTN","utt5",9,0)
- D CHKEQ^%ut(5,5,"SET EQUAL ON PURPOSE - OLDSTYLE DONE")
+ ; ZEXCEPT: %ut - Newed in EN^%zu
 "RTN","utt5",10,0)
- D CHKTF^%ut(4=4,"MY EQUAL VALUE")
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",11,0)
- Q
+ I $D(%utt6var) S %ut("ENT")="OLDSTYLE",%utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"OLDSTYLE")=""
 "RTN","utt5",12,0)
- ;
+ D CHKEQ^%ut(5,5,"SET EQUAL ON PURPOSE - OLDSTYLE DONE")
 "RTN","utt5",13,0)
-OLDSTYL1 ;
+ D CHKTF^%ut(4=4,"MY EQUAL VALUE")
 "RTN","utt5",14,0)
- ; ZEXCEPT: %ut - Newed in EN^%zu
+ Q
 "RTN","utt5",15,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ;
 "RTN","utt5",16,0)
- I $D(%utt6var) S %ut("ENT")="OLDSTYL1",%utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"OLDSTYL1")=""
+OLDSTYL1 ;
 "RTN","utt5",17,0)
- D CHKEQ^%ut(4,4,"SET EQUAL ON PURPOSE - OLDSTYL1 DONE")
+ ; ZEXCEPT: %ut - Newed in EN^%zu
 "RTN","utt5",18,0)
- Q
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",19,0)
- ;
+ I $D(%utt6var) S %ut("ENT")="OLDSTYL1",%utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"OLDSTYL1")=""
 "RTN","utt5",20,0)
-NEWSTYLE ; @TEST identify new style test indicator functionality
+ D CHKEQ^%ut(4,4,"SET EQUAL ON PURPOSE - OLDSTYL1 DONE")
 "RTN","utt5",21,0)
- ; ZEXCEPT: %ut - Newed in EN^%zu
+ Q
 "RTN","utt5",22,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ;
 "RTN","utt5",23,0)
- I $D(%utt6var) S %ut("ENT")="NEWSTYLE" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"NEWSTYLE")=""
+NEWSTYLE ; @TEST identify new style test indicator functionality
 "RTN","utt5",24,0)
- D CHKEQ^%ut(4,4,"SET EQUAL ON PURPOSE - NEWSTYLE DONE")
+ ; ZEXCEPT: %ut - Newed in EN^%zu
 "RTN","utt5",25,0)
- Q
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",26,0)
- ;
+ I $D(%utt6var) S %ut("ENT")="NEWSTYLE" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"NEWSTYLE")=""
 "RTN","utt5",27,0)
-BADCHKEQ ;
+ D CHKEQ^%ut(4,4,"SET EQUAL ON PURPOSE - NEWSTYLE DONE")
 "RTN","utt5",28,0)
- ; ZEXCEPT: %ut - Newed in EN^%zu
+ Q
 "RTN","utt5",29,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ;
 "RTN","utt5",30,0)
- I $D(%utt6var) S %ut("ENT")="BADCHKEQ" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADCHKEQ")=""
+BADCHKEQ ;
 "RTN","utt5",31,0)
- D CHKEQ^%ut(4,3,"SET UNEQUAL ON PURPOSE - SHOULD FAIL")
+ ; ZEXCEPT: %ut - Newed in EN^%zu
 "RTN","utt5",32,0)
- Q
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",33,0)
- ;
+ I $D(%utt6var) S %ut("ENT")="BADCHKEQ" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADCHKEQ")=""
 "RTN","utt5",34,0)
-BADCHKTF ;
+ D CHKEQ^%ut(4,3,"SET UNEQUAL ON PURPOSE - SHOULD FAIL")
 "RTN","utt5",35,0)
- ; ZEXCEPT: %ut - Newed in EN^%zu
+ Q
 "RTN","utt5",36,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ;
 "RTN","utt5",37,0)
- I $D(%utt6var) S %ut("ENT")="BADCHKTF" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADCHKTF")=""
+BADCHKTF ;
 "RTN","utt5",38,0)
- D CHKTF^%ut(0,"SET FALSE (0) ON PURPOSE - SHOULD FAIL")
+ ; ZEXCEPT: %ut - Newed in EN^%zu
 "RTN","utt5",39,0)
- Q
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",40,0)
- ;
+ I $D(%utt6var) S %ut("ENT")="BADCHKTF" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADCHKTF")=""
 "RTN","utt5",41,0)
-BADERROR ;
+ D CHKTF^%ut(0,"SET FALSE (0) ON PURPOSE - SHOULD FAIL")
 "RTN","utt5",42,0)
- ; ZEXCEPT: %ut - Newed in EN^%zu
+ Q
 "RTN","utt5",43,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ;
 "RTN","utt5",44,0)
- N X
+BADERROR ;
 "RTN","utt5",45,0)
- I $D(%utt6var) S %ut("ENT")="BADERROR" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADERROR")=""
+ ; ZEXCEPT: %ut - Newed in EN^%zu
 "RTN","utt5",46,0)
- ; following syntax error is on purpose to throw an error
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",47,0)
- S X= ; syntax error on purpose
-"RTN","utt5",48,0)
- Q
-"RTN","utt5",49,0)
- ;
-"RTN","utt5",50,0)
-CALLFAIL ;
-"RTN","utt5",51,0)
- ; ZEXCEPT: %ut - Newed in EN^%zu
-"RTN","utt5",52,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-"RTN","utt5",53,0)
  N X
+"RTN","utt5",48,0)
+ I $D(%utt6var) S %ut("ENT")="BADERROR" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADERROR")=""
+"RTN","utt5",49,0)
+ ; following syntax error is on purpose to throw an error
+"RTN","utt5",50,0)
+ S X= ; syntax error on purpose
+"RTN","utt5",51,0)
+ Q
+"RTN","utt5",52,0)
+ ;
+"RTN","utt5",53,0)
+CALLFAIL ;
 "RTN","utt5",54,0)
- I $D(%utt6var) S %ut("ENT")="CALLFAIL" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"CALLFAIL")=""
+ ; ZEXCEPT: %ut - Newed in EN^%zu
 "RTN","utt5",55,0)
- D FAIL^%ut("Called FAIL to test it")
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",56,0)
- Q
+ N X
 "RTN","utt5",57,0)
- ;
+ I $D(%utt6var) S %ut("ENT")="CALLFAIL" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"CALLFAIL")=""
 "RTN","utt5",58,0)
-LEAKSOK ;
+ D FAIL^%ut("Called FAIL to test it")
 "RTN","utt5",59,0)
- N CODE,LOCATN,MYVALS,X
+ Q
 "RTN","utt5",60,0)
- S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSOK TEST",MYVALS("X")=""
+ ;
 "RTN","utt5",61,0)
- D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find no leaks
+LEAKSOK ;
 "RTN","utt5",62,0)
- Q
-"RTN","utt5",63,0)
- ;
-"RTN","utt5",64,0)
-LEAKSBAD ;
-"RTN","utt5",65,0)
  N CODE,LOCATN,MYVALS,X
+"RTN","utt5",63,0)
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSOK TEST",MYVALS("X")=""
+"RTN","utt5",64,0)
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find no leaks
+"RTN","utt5",65,0)
+ Q
 "RTN","utt5",66,0)
- S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSBAD TEST - X NOT SPECIFIED"
+ ;
 "RTN","utt5",67,0)
- D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find X since it isn't indicated
+LEAKSBAD ;
 "RTN","utt5",68,0)
- Q
+ N CODE,LOCATN,MYVALS,X
 "RTN","utt5",69,0)
- ;
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSBAD TEST - X NOT SPECIFIED"
 "RTN","utt5",70,0)
-NVLDARG1 ;
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find X since it isn't indicated
 "RTN","utt5",71,0)
- D CHKEQ^%ut(1)
+ Q
 "RTN","utt5",72,0)
- Q
+ ;
 "RTN","utt5",73,0)
- ;
+NVLDARG1 ;
 "RTN","utt5",74,0)
-ISUTEST ;
+ D CHKEQ^%ut(1)
 "RTN","utt5",75,0)
- D CHKTF^%ut($$ISUTEST^%ut,"ISUTEST returned FALSE!")
+ Q
 "RTN","utt5",76,0)
- Q
+ ;
 "RTN","utt5",77,0)
- ;
+ISUTEST ;
 "RTN","utt5",78,0)
-BADFORM1(X) ; @TEST should not be selected - arguments
+ D CHKTF^%ut($$ISUTEST^%ut,"ISUTEST returned FALSE!")
 "RTN","utt5",79,0)
- ; ZEXCEPT: %ut - Newed in EN^%zu
+ Q
 "RTN","utt5",80,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ;
 "RTN","utt5",81,0)
- I $D(%utt6var) S %ut("ENT")="NEWSTYLE" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADFORM1")=""
+BADFORM1(X) ; @TEST should not be selected - arguments
 "RTN","utt5",82,0)
- D CHKEQ^%ut(4,3,"SHOULD NOT BE SELECTED - ARGUMENTS - BADFORM1")
-"RTN","utt5",83,0)
- Q
-"RTN","utt5",84,0)
- ;
-"RTN","utt5",85,0)
-BADFORM2 ; ABC @TEST should not be selected - @TEST NOT FIRST
-"RTN","utt5",86,0)
  ; ZEXCEPT: %ut - Newed in EN^%zu
+"RTN","utt5",83,0)
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+"RTN","utt5",84,0)
+ I $D(%utt6var) S %ut("ENT")="NEWSTYLE" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADFORM1")=""
+"RTN","utt5",85,0)
+ D CHKEQ^%ut(4,3,"SHOULD NOT BE SELECTED - ARGUMENTS - BADFORM1")
+"RTN","utt5",86,0)
+ Q
 "RTN","utt5",87,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ;
 "RTN","utt5",88,0)
- I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADFORM2")=""
+BADFORM2 ; ABC @TEST should not be selected - @TEST NOT FIRST
 "RTN","utt5",89,0)
- D CHKEQ^%ut(4,3,"SHOULD NOT BE SELECTED - @TEST NOT FIRST - BADFORM2")
+ ; ZEXCEPT: %ut - Newed in EN^%zu
 "RTN","utt5",90,0)
- Q
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",91,0)
- ;
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADFORM2")=""
 "RTN","utt5",92,0)
-STARTUP ;
+ D CHKEQ^%ut(4,3,"SHOULD NOT BE SELECTED - @TEST NOT FIRST - BADFORM2")
 "RTN","utt5",93,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ Q
 "RTN","utt5",94,0)
- ; ZEXCEPT: KBANCOUNT created here, killed in SHUTDOWN
+ ;
 "RTN","utt5",95,0)
- I $D(%utt6var),$D(^TMP("%utt5",$J)) K ^TMP("%utt5",$J)
+STARTUP ;
 "RTN","utt5",96,0)
- I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"STARTUP")=""
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",97,0)
- ; following brought from %utt1, since only one STARTUP can RUN in a set
+ ; ZEXCEPT: KBANCOUNT created here, killed in SHUTDOWN
 "RTN","utt5",98,0)
- I '$D(%utt6var) D
+ I $D(%utt6var),$D(^TMP("%utt5",$J)) K ^TMP("%utt5",$J)
 "RTN","utt5",99,0)
- . S ^TMP($J,"%ut","STARTUP")=""
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"STARTUP")=""
 "RTN","utt5",100,0)
- . S KBANCOUNT=1
+ ; following brought from %utt1, since only one STARTUP can RUN in a set
 "RTN","utt5",101,0)
- . Q
-"RTN","utt5",102,0)
- Q
-"RTN","utt5",103,0)
- ;
-"RTN","utt5",104,0)
-SHUTDOWN ;
-"RTN","utt5",105,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-"RTN","utt5",106,0)
- ; ZEXCEPT: KBANCOUNT created in STARTUP, killed here
-"RTN","utt5",107,0)
- I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"SHUTDOWN")=""
-"RTN","utt5",108,0)
- ; following brought from %utt1, since only one SHUTDOWN can RUN in a set
-"RTN","utt5",109,0)
  I '$D(%utt6var) D
-"RTN","utt5",110,0)
- . K ^TMP($J,"%ut","STARTUP")
-"RTN","utt5",111,0)
- . K KBANCOUNT
-"RTN","utt5",112,0)
+"RTN","utt5",102,0)
+ . S ^TMP($J,"%ut","STARTUP")=""
+"RTN","utt5",103,0)
+ . S KBANCOUNT=1
+"RTN","utt5",104,0)
  . Q
+"RTN","utt5",105,0)
+ Q
+"RTN","utt5",106,0)
+ ;
+"RTN","utt5",107,0)
+SHUTDOWN ;
+"RTN","utt5",108,0)
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+"RTN","utt5",109,0)
+ ; ZEXCEPT: KBANCOUNT created in STARTUP, killed here
+"RTN","utt5",110,0)
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"SHUTDOWN")=""
+"RTN","utt5",111,0)
+ ; following brought from %utt1, since only one SHUTDOWN can RUN in a set
+"RTN","utt5",112,0)
+ I '$D(%utt6var) D
 "RTN","utt5",113,0)
- Q
+ . K ^TMP($J,"%ut","STARTUP")
 "RTN","utt5",114,0)
- ;
+ . K KBANCOUNT
 "RTN","utt5",115,0)
-SETUP ;
+ . Q
 "RTN","utt5",116,0)
- ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ Q
 "RTN","utt5",117,0)
- I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"SETUP")=""
+ ;
 "RTN","utt5",118,0)
- Q
+SETUP ;
 "RTN","utt5",119,0)
- ;
-"RTN","utt5",120,0)
-TEARDOWN ;
-"RTN","utt5",121,0)
  ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-"RTN","utt5",122,0)
- I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"TEARDOWN")=""
-"RTN","utt5",123,0)
+"RTN","utt5",120,0)
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"SETUP")=""
+"RTN","utt5",121,0)
  Q
-"RTN","utt5",124,0)
+"RTN","utt5",122,0)
  ;
+"RTN","utt5",123,0)
+TEARDOWN ;
+"RTN","utt5",124,0)
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
 "RTN","utt5",125,0)
-XTENT ;
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"TEARDOWN")=""
 "RTN","utt5",126,0)
- ;;OLDSTYLE; identify old style test indicator functionality
+ Q
 "RTN","utt5",127,0)
- ;;OLDSTYL1; identify old style test indicator 2
+ ;
 "RTN","utt5",128,0)
- ;;BADCHKEQ; CHKEQ should fail on unequal value
+XTENT ;
 "RTN","utt5",129,0)
- ;;BADCHKTF; CHKTF should fail on false value
+ ;;OLDSTYLE; identify old style test indicator functionality
 "RTN","utt5",130,0)
- ;;BADERROR; throws an error on purpose
+ ;;OLDSTYL1; identify old style test indicator 2
 "RTN","utt5",131,0)
- ;;CALLFAIL; called FAIL to test it
+ ;;BADCHKEQ; CHKEQ should fail on unequal value
 "RTN","utt5",132,0)
- ;;LEAKSOK;check leaks should be ok
+ ;;BADCHKTF; CHKTF should fail on false value
 "RTN","utt5",133,0)
- ;;LEAKSBAD;check leaks with leak
+ ;;BADERROR; throws an error on purpose
 "RTN","utt5",134,0)
- ;;NVLDARG1;check invalid arg in CHKEQ
+ ;;CALLFAIL; called FAIL to test it
 "RTN","utt5",135,0)
+ ;;LEAKSOK;check leaks should be ok
+"RTN","utt5",136,0)
+ ;;LEAKSBAD;check leaks with leak
+"RTN","utt5",137,0)
+ ;;NVLDARG1;check invalid arg in CHKEQ
+"RTN","utt5",138,0)
  ;;ISUTEST;check ISUTEST inside unit test
 "RTN","utt6")
-0^8^B29243478
+0^9^B39118749
 "RTN","utt6",1,0)
-%utt6 ;JLI - Unit tests for MUnit functionality ;08/29/14  11:43
+%utt6 ;JLI - Unit tests for MUnit functionality ;12/16/15  08:47
 "RTN","utt6",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","utt6",3,0)
- ;
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","utt6",4,0)
- ; This routine uses ZZUTJLI2 as a test routine, it does not include the routine as an extension,
+ ; Original routine authored by Joel L. Ivey 05/2014-12/2015
 "RTN","utt6",5,0)
- ; since it uses it for tests.
+ ;
 "RTN","utt6",6,0)
  ;
 "RTN","utt6",7,0)
- ; ZZUTJLI2 currently contains 3 tests (2 old style, 1 new style), it also specifies STARTUP and
+ ; This routine uses ZZUTJLI2 as a test routine, it does not include the routine as an extension,
 "RTN","utt6",8,0)
- ; SHUTDOWN (should be 1 each) and SETUP and TEARDOWN (should be 3 each, 1 for each test) enteries, each of these
+ ; since it uses it for tests.
 "RTN","utt6",9,0)
- ; creates an entry under the ^TMP("ZZUTJLI2" global node, indicating function then continues the process.
+ ;
 "RTN","utt6",10,0)
- ; Should be 2+3n entries (1+1 for STARTUP and SHUTDOWN, then 3 for each of the tests (SETUP, test,
+ ; ZZUTJLI2 currently contains 3 tests (2 old style, 1 new style), it also specifies STARTUP and
 "RTN","utt6",11,0)
- ; and TEARDOWN).
+ ; SHUTDOWN (should be 1 each) and SETUP and TEARDOWN (should be 3 each, 1 for each test) enteries, each of these
 "RTN","utt6",12,0)
- ;
+ ; creates an entry under the ^TMP("ZZUTJLI2" global node, indicating function then continues the process.
 "RTN","utt6",13,0)
- ; This first section is more of a functional test, since it checks the full unit test processing from both
+ ; Should be 2+3n entries (1+1 for STARTUP and SHUTDOWN, then 3 for each of the tests (SETUP, test,
 "RTN","utt6",14,0)
- ; a command line and a GUI call approach.  Data for analysis is saved under ^TMP("ZZUTJLI2_C", for command
+ ; and TEARDOWN).
 "RTN","utt6",15,0)
- ; line and ^TMP("ZZUTJLI2_G", for gui processing.
+ ;
 "RTN","utt6",16,0)
- ;
+ ; This first section is more of a functional test, since it checks the full unit test processing from both
 "RTN","utt6",17,0)
- ; The counts for the command line processing are based on the number of unit test tags
+ ; a command line and a GUI call approach.  Data for analysis is saved under ^TMP("ZZUTJLI2_C", for command
 "RTN","utt6",18,0)
- ; determined for the GUI processing as well.  The numbers are 2 (startup and shutdown)
+ ; line and ^TMP("ZZUTJLI2_G", for gui processing.
 "RTN","utt6",19,0)
- ;  + 3 x the number of tests present.
+ ;
 "RTN","utt6",20,0)
- ;
+ ; The counts for the command line processing are based on the number of unit test tags
 "RTN","utt6",21,0)
- ; run unit tests by command line
+ ; determined for the GUI processing as well.  The numbers are 2 (startup and shutdown)
 "RTN","utt6",22,0)
- N VERBOSE
+ ;  + 3 x the number of tests present.
 "RTN","utt6",23,0)
- S VERBOSE=0
-"RTN","utt6",24,0)
-VERBOSE ;
-"RTN","utt6",25,0)
- I '$D(VERBOSE) N VERBOSE S VERBOSE=1
-"RTN","utt6",26,0)
- N ZZUTCNT,JLICNT,JLIEXPCT,JLII,JLIX,ZZUTRSLT,%utt5,%utt6,%utt6var
-"RTN","utt6",27,0)
- W !!,"RUNNING COMMAND LINE TESTS VIA DOSET^%ut",!
-"RTN","utt6",28,0)
- D DOSET^%ut(1,VERBOSE) ; run `1 in M-UNIT TEST GROUP file
-"RTN","utt6",29,0)
  ;
+"RTN","utt6",24,0)
+ ; run unit tests by command line
+"RTN","utt6",25,0)
+ N VERBOSE
+"RTN","utt6",26,0)
+ S VERBOSE=0
+"RTN","utt6",27,0)
+VERBOSE ;
+"RTN","utt6",28,0)
+ I '$D(VERBOSE) N VERBOSE S VERBOSE=1
+"RTN","utt6",29,0)
+ N ZZUTCNT,JLICNT,JLIEXPCT,JLII,JLIX,ZZUTRSLT,%utt5,%utt6,%utt6var
 "RTN","utt6",30,0)
- W !!!,"Running command line tests by RUNSET^%ut",!
+ W !!,"RUNNING COMMAND LINE TESTS VIA DOSET^%ut",!
 "RTN","utt6",31,0)
- D RUNSET^%ut("TESTS FOR UNIT TEST ROUTINES")
+ D DOSET^%ut(1,VERBOSE) ; run `1 in M-UNIT TEST GROUP file
 "RTN","utt6",32,0)
  ;
 "RTN","utt6",33,0)
- ; Call GUISET to obtain list of tags via entry in M-UNIT TEST GROUP file
+ W !!!,"Running command line tests by RUNSET^%ut",!
 "RTN","utt6",34,0)
- ; silent to the user
+ D RUNSET^%ut("TESTS FOR UNIT TEST ROUTINES")
 "RTN","utt6",35,0)
- D GUISET^%ut(.%utt6,1)
+ ;
 "RTN","utt6",36,0)
- K ^TMP("%utt6_GUISET",$J) M ^TMP("%utt6_GUISET",$J)=@%utt6
+ ; Call GUISET to obtain list of tags via entry in M-UNIT TEST GROUP file
 "RTN","utt6",37,0)
- ;
+ ; silent to the user
 "RTN","utt6",38,0)
- W !!!,"RUNNING COMMAND LINE UNIT TESTS FOR %utt5",!
+ D GUISET^%ut(.%utt6,1)
 "RTN","utt6",39,0)
- N ZZUTCNT,JLICNT,JLIEXPCT,JLII,JLIX,ZZUTRSLT
+ K ^TMP("%utt6_GUISET",$J) M ^TMP("%utt6_GUISET",$J)=@%utt6
 "RTN","utt6",40,0)
- S ZZUTCNT=0
+ ;
 "RTN","utt6",41,0)
- K ^TMP("%utt5",$J) ; kill any contents of data storage
+ W !!!,"RUNNING COMMAND LINE UNIT TESTS FOR %utt5",!
 "RTN","utt6",42,0)
- D EN^%ut("%utt5",VERBOSE) ; should do STARTUP(1x), then SETUP, test, TEARDOWN (each together 3x) and SHUTDOWN (1x)
+ N ZZUTCNT,JLICNT,JLIEXPCT,JLII,JLIX,ZZUTRSLT
 "RTN","utt6",43,0)
- K ^TMP("%utt5_C",$J) M ^TMP("%utt5_C",$J)=^TMP("%utt5",$J)
-"RTN","utt6",44,0)
- ;
-"RTN","utt6",45,0)
- ; now run unit tests by GUI - first determines unit test tags
-"RTN","utt6",46,0)
- W !!!,"RUNNING UNIT TESTS FOR %utt5 VIA GUI CALLS - Silent",!
-"RTN","utt6",47,0)
  S ZZUTCNT=0
+"RTN","utt6",44,0)
+ K ^TMP("%utt5",$J) ; kill any contents of data storage
+"RTN","utt6",45,0)
+ D EN^%ut("%utt5",VERBOSE) ; should do STARTUP(1x), then SETUP, test, TEARDOWN (each together 3x) and SHUTDOWN (1x)
+"RTN","utt6",46,0)
+ K ^TMP("%utt5_C",$J) M ^TMP("%utt5_C",$J)=^TMP("%utt5",$J)
+"RTN","utt6",47,0)
+ ;
 "RTN","utt6",48,0)
- K ^TMP("%utt5",$J),^TMP("%utt6",$J)
+ ; now run unit tests by GUI - first determines unit test tags
 "RTN","utt6",49,0)
- D GUILOAD^%ut(.%utt6,"%utt5")
+ W !!!,"RUNNING UNIT TESTS FOR %utt5 VIA GUI CALLS - Silent",!
 "RTN","utt6",50,0)
- M ^TMP("%utt6",$J)=@%utt6
+ S ZZUTCNT=0
 "RTN","utt6",51,0)
- S %utt6=$NA(^TMP("%utt6",$J))
+ K ^TMP("%utt5",$J),^TMP("%utt6",$J)
 "RTN","utt6",52,0)
- ; then run each tag separately
+ D GUILOAD^%ut(.%utt6,"%utt5")
 "RTN","utt6",53,0)
- ; JLICNT is count of unit test tags, which can be determined for GUI call for each unit test tag
+ M ^TMP("%utt6",$J)=@%utt6
 "RTN","utt6",54,0)
- S JLICNT=0 F JLII=1:1 S JLIX=$G(@%utt6@(JLII)) Q:JLIX=""  I $P(JLIX,U,2)'="" S JLICNT=JLICNT+1 D GUINEXT^%ut(.ZZUTRSLT,$P(JLIX,U,2)_U_$P(JLIX,U))
+ S %utt6=$NA(^TMP("%utt6",$J))
 "RTN","utt6",55,0)
- ; and close it with a null routine name
+ ; then run each tag separately
 "RTN","utt6",56,0)
- D GUINEXT^%ut(.ZZUTRSLT,"")
+ ; JLICNT is count of unit test tags, which can be determined for GUI call for each unit test tag
 "RTN","utt6",57,0)
- K ^TMP("%utt5_G",$J) M ^TMP("%utt5_G",$J)=^TMP("%utt5",$J)
+ S JLICNT=0 F JLII=1:1 S JLIX=$G(@%utt6@(JLII)) Q:JLIX=""  I $P(JLIX,U,2)'="" S JLICNT=JLICNT+1 D GUINEXT^%ut(.ZZUTRSLT,$P(JLIX,U,2)_U_$P(JLIX,U))
 "RTN","utt6",58,0)
- S JLIEXPCT=2+(3*JLICNT) ; number of lines that should be in the global nodes for command line and GUI
+ ; and close it with a null routine name
 "RTN","utt6",59,0)
- ;
+ D GUINEXT^%ut(.ZZUTRSLT,"")
 "RTN","utt6",60,0)
- ; now run the unit tests in this routine
+ K ^TMP("%utt5_G",$J) M ^TMP("%utt5_G",$J)=^TMP("%utt5",$J)
 "RTN","utt6",61,0)
- W !!,"NOW RUNNING UNIT TESTS FOR %utt6",!!
+ S JLIEXPCT=2+(3*JLICNT) ; number of lines that should be in the global nodes for command line and GUI
 "RTN","utt6",62,0)
- D EN^%ut("%utt6",VERBOSE)
+ ;
 "RTN","utt6",63,0)
- K ^TMP("%utt5",$J),^TMP("%utt5_C",$J),^TMP("%utt5_G",$J),^TMP("%utt6",$J),^TMP("%utt6_GUISET",$J)
+ W !!,"NOW RUNNING UNIT TESTS FOR %uttcovr",!!
 "RTN","utt6",64,0)
- ; clean up after GUI calls as well
+ D EN^%ut("%uttcovr",VERBOSE)
 "RTN","utt6",65,0)
- K ^TMP("GUI-MUNIT",$J),^TMP("GUINEXT",$J),^TMP("MUNIT-%utRSLT",$J)
+ ;
 "RTN","utt6",66,0)
- Q
+ ; now run the unit tests in this routine
 "RTN","utt6",67,0)
- ;
+ W !!,"NOW RUNNING UNIT TESTS FOR %utt6",!!
 "RTN","utt6",68,0)
- ;
+ D EN^%ut("%utt6",VERBOSE)
 "RTN","utt6",69,0)
- ;           WARNING     --      WARNING     --      WARNING
+ K ^TMP("%utt5",$J),^TMP("%utt5_C",$J),^TMP("%utt5_G",$J),^TMP("%utt6",$J),^TMP("%utt6_GUISET",$J)
 "RTN","utt6",70,0)
- ; If the number of NEW STYLE tests in %utt5 is increased (it is currently 1), then the following
+ ; clean up after GUI calls as well
 "RTN","utt6",71,0)
- ; test will need to be updated to reflect the change(s)
+ K ^TMP("GUI-MUNIT",$J),^TMP("GUINEXT",$J),^TMP("MUNIT-%utRSLT",$J)
 "RTN","utt6",72,0)
- ;     END OF WARNING  --  END OF WARNING  --  END OF WARNING
+ Q
 "RTN","utt6",73,0)
  ;
 "RTN","utt6",74,0)
-NEWSTYLE ; tests return of valid new style or @TEST indicators
+ ;
 "RTN","utt6",75,0)
- N LIST
+ ;           WARNING     --      WARNING     --      WARNING
 "RTN","utt6",76,0)
- D NEWSTYLE^%ut1(.LIST,"%utt5")
+ ; If the number of NEW STYLE tests in %utt5 is increased (it is currently 1), then the following
 "RTN","utt6",77,0)
- D CHKEQ^%ut(LIST,1,"Returned an incorrect number ("_LIST_") of New Style indicators - should be one")
+ ; test will need to be updated to reflect the change(s)
 "RTN","utt6",78,0)
- I LIST>0 D CHKEQ^%ut(LIST(1),"NEWSTYLE^identify new style test indicator functionality","Returned incorrect TAG^reason "_LIST(1))
+ ;     END OF WARNING  --  END OF WARNING  --  END OF WARNING
 "RTN","utt6",79,0)
- I LIST>0 D CHKEQ^%ut($G(LIST(2)),"","Returned a value for LIST(2) - should not have any value (i.e., null)")
+ ;
 "RTN","utt6",80,0)
- Q
+SETROUS ; @TEST - generate array with indices of routines to exclude
 "RTN","utt6",81,0)
- ;
+ N ROU,XCLDROUS,ROULIST
 "RTN","utt6",82,0)
-CKGUISET ;
+ S XCLDROUS(1)="ROU1NAME,ROU2NAME"
 "RTN","utt6",83,0)
- ; ZEXCEPT: %utt6var - if present, is NEWed and created in code following VERBOSE
+ S XCLDROUS("ROUNAME3")="ROUNAME4,ROUNAME5"
 "RTN","utt6",84,0)
- I '$D(%utt6var) Q
+ D SETROUS^%utcover(.ROULIST,.XCLDROUS,1)
 "RTN","utt6",85,0)
- N MAX
+ D CHKTF('$D(ROULIST(1)),"SETROUS returned number for routine")
 "RTN","utt6",86,0)
- S MAX=$O(^TMP("%utt6_GUISET",$J,""),-1)
+ D CHKTF($D(ROULIST("ROU1NAME")),"Didn't get first name on numeric subscript")
 "RTN","utt6",87,0)
- D CHKTF^%ut(^TMP("%utt6_GUISET",$J,MAX)["%utt6^NEWSTYLE","GUISET returned incorrect list")
+ D CHKTF($D(ROULIST("ROU2NAME")),"Didn't get second name on numeric subscript")
 "RTN","utt6",88,0)
- Q
+ D SETROUS^%utcover(.ROULIST,.XCLDROUS,"ROUNAME3")
 "RTN","utt6",89,0)
- ;
+ D CHKTF($D(ROULIST("ROUNAME3")),"Didn't get name for routine argument")
 "RTN","utt6",90,0)
-CHKCMDLN ; check command line processing of %utt5
+ D CHKTF($D(ROULIST("ROUNAME4")),"Didn't get first name on routine subscript")
 "RTN","utt6",91,0)
- ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+ D CHKTF($D(ROULIST("ROUNAME5")),"Didn't get second name on routine subscript")
 "RTN","utt6",92,0)
- I '$D(%utt6var) Q
+ Q
 "RTN","utt6",93,0)
- D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+ ;
 "RTN","utt6",94,0)
- D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
+NEWSTYLE ; tests return of valid new style or @TEST indicators
 "RTN","utt6",95,0)
- D CHKTF^%ut($O(^TMP("%utt5_C",$J,1,""))="STARTUP","Incorrect function for entry 1,'"_$O(^TMP("%utt5_C",$J,1,""))_"' should be 'STARTUP'")
+ N LIST
 "RTN","utt6",96,0)
- D CHKTF^%ut($O(^TMP("%utt5_C",$J,JLIEXPCT,""))="SHUTDOWN","Incorrect function for entry "_JLIEXPCT_", '"_$O(^TMP("%utt5_C",$J,JLIEXPCT,""))_"' should be 'SHUTDOWN'")
+ D NEWSTYLE^%ut1(.LIST,"%utt5")
 "RTN","utt6",97,0)
- Q
+ D CHKEQ^%ut(LIST,1,"Returned an incorrect number ("_LIST_") of New Style indicators - should be one")
 "RTN","utt6",98,0)
- ;
+ I LIST>0 D CHKEQ^%ut(LIST(1),"NEWSTYLE^identify new style test indicator functionality","Returned incorrect TAG^reason "_LIST(1))
 "RTN","utt6",99,0)
-CHKGUI ; check GUI processing of %utt5
+ I LIST>0 D CHKEQ^%ut($G(LIST(2)),"","Returned a value for LIST(2) - should not have any value (i.e., null)")
 "RTN","utt6",100,0)
- ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+ ; the following is basically just for coverage
 "RTN","utt6",101,0)
- I '$D(%utt6var) Q
+ D PICKSET^%ut
 "RTN","utt6",102,0)
- D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
-"RTN","utt6",103,0)
- D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
-"RTN","utt6",104,0)
- D CHKTF^%ut($O(^TMP("%utt5_G",$J,1,""))="STARTUP","Incorrect function for entry 1,'"_$O(^TMP("%utt5Z_G",1,""))_"' should be 'STARTUP'")
-"RTN","utt6",105,0)
- D CHKTF^%ut($O(^TMP("%utt5_G",$J,JLIEXPCT,""))="SHUTDOWN","Incorrect function for entry "_JLIEXPCT_", '"_$O(^TMP("%utt5_G",$J,JLIEXPCT,""))_"' should be 'SHUTDOWN'")
-"RTN","utt6",106,0)
  Q
-"RTN","utt6",107,0)
+"RTN","utt6",103,0)
  ;
+"RTN","utt6",104,0)
+CKGUISET ;
+"RTN","utt6",105,0)
+ ; ZEXCEPT: %utt6var - if present, is NEWed and created in code following VERBOSE
+"RTN","utt6",106,0)
+ I '$D(%utt6var) Q
+"RTN","utt6",107,0)
+ N MAX
 "RTN","utt6",108,0)
-XTENT ;
+ S MAX=$O(^TMP("%utt6_GUISET",$J,""),-1)
 "RTN","utt6",109,0)
- ;;CHKCMDLN;check command line processing of %utt5
+ D CHKTF(^TMP("%utt6_GUISET",$J,MAX)["%utt6^NEWSTYLE","GUISET returned incorrect list")
 "RTN","utt6",110,0)
- ;;CHKGUI;check GUI processing of %utt5
+ Q
 "RTN","utt6",111,0)
- ;;CKGUISET;check list of tests returned by GUISET
+ ;
 "RTN","utt6",112,0)
+CHKCMDLN ; check command line processing of %utt5
+"RTN","utt6",113,0)
+ ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+"RTN","utt6",114,0)
+ I '$D(%utt6var) Q
+"RTN","utt6",115,0)
+ D CHKTF($D(^TMP("%utt5_C",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",116,0)
+ D CHKTF($D(^TMP("%utt5_C",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",117,0)
+ D CHKTF($O(^TMP("%utt5_C",$J,1,""))="STARTUP","Incorrect function for entry 1,'"_$O(^TMP("%utt5_C",$J,1,""))_"' should be 'STARTUP'")
+"RTN","utt6",118,0)
+ D CHKTF($O(^TMP("%utt5_C",$J,JLIEXPCT,""))="SHUTDOWN","Incorrect function for entry "_JLIEXPCT_", '"_$O(^TMP("%utt5_C",$J,JLIEXPCT,""))_"' should be 'SHUTDOWN'")
+"RTN","utt6",119,0)
+ Q
+"RTN","utt6",120,0)
+ ;
+"RTN","utt6",121,0)
+CHKGUI ; check GUI processing of %utt5
+"RTN","utt6",122,0)
+ ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+"RTN","utt6",123,0)
+ I '$D(%utt6var) Q
+"RTN","utt6",124,0)
+ D CHKTF($D(^TMP("%utt5_G",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",125,0)
+ D CHKTF($D(^TMP("%utt5_G",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",126,0)
+ D CHKTF($O(^TMP("%utt5_G",$J,1,""))="STARTUP","Incorrect function for entry 1,'"_$O(^TMP("%utt5Z_G",1,""))_"' should be 'STARTUP'")
+"RTN","utt6",127,0)
+ D CHKTF($O(^TMP("%utt5_G",$J,JLIEXPCT,""))="SHUTDOWN","Incorrect function for entry "_JLIEXPCT_", '"_$O(^TMP("%utt5_G",$J,JLIEXPCT,""))_"' should be 'SHUTDOWN'")
+"RTN","utt6",128,0)
+ Q
+"RTN","utt6",129,0)
+ ;
+"RTN","utt6",130,0)
+CHKTF(VALUE,MESSAGE) ;
+"RTN","utt6",131,0)
+ D CHKTF^%ut($G(VALUE),$G(MESSAGE))
+"RTN","utt6",132,0)
+ Q
+"RTN","utt6",133,0)
+ ;
+"RTN","utt6",134,0)
+XTENT ;
+"RTN","utt6",135,0)
+ ;;CHKCMDLN;check command line processing of %utt5
+"RTN","utt6",136,0)
+ ;;CHKGUI;check GUI processing of %utt5
+"RTN","utt6",137,0)
+ ;;CKGUISET;check list of tests returned by GUISET
+"RTN","utt6",138,0)
  ;;NEWSTYLE;test return of valid new style or @TEST indicators
 "RTN","uttcovr")
-0^9^B2835727
+0^10^B186023122
 "RTN","uttcovr",1,0)
-%uttcovr ;JLI/JIVEYSOFT - runs coverage tests on %ut and %ut1 routines via unit tests ;09/10/14  14:34
+%uttcovr ;JIVEYSOFT/JLI - runs coverage tests on %ut and %ut1 routines via unit tests ;12/16/15  08:48
 "RTN","uttcovr",2,0)
- ;;0.1;MASH UTILITIES;;;Build 4
+ ;;1.4;MASH;;Feb 27, 2016;Build 6
 "RTN","uttcovr",3,0)
- ;
+ ; Submitted to OSEHRA Dec 16, 2015 by Joel L. Ivey under the Apache 2 license (http://www.apache.org/licenses/LICENSE-2.0.html)
 "RTN","uttcovr",4,0)
- I '(+$SY=47) W !,"This coverage analysis is currently only available in GT.M" Q  ; GT.M only!
+ ; Original routine authored by Joel L. Ivey 05/2014-12/2015
 "RTN","uttcovr",5,0)
  ;
 "RTN","uttcovr",6,0)
- ; if SHOWALL is true (1) all coverage globals data are listed
+ ;
 "RTN","uttcovr",7,0)
- ; if SHOWALL is false (0), only the %utCOVREPORT global is listed
+ ; ZEXCEPT: DTIME - if present the value is Kernel timeout for reads
 "RTN","uttcovr",8,0)
- I '$D(SHOWALL) N SHOWALL S SHOWALL=0
+ N RUNCODE,XCLUDE
 "RTN","uttcovr",9,0)
- ; set global node so %utt4 doesn't run its own analysis
+ ;
 "RTN","uttcovr",10,0)
- S ^TMP("%uttcovr",$J)=1
+ ; Have it run the following entry points or, if no ^, call EN^%ut with routine name
 "RTN","uttcovr",11,0)
- ; start analysis of %ut - it calls entry below
+ S RUNCODE(1)="^%utt1,%utt1,^%utt6,VERBOSE^%utt6,%uttcovr,^%ut,^%ut1,^%utcover"
 "RTN","uttcovr",12,0)
- D COV^%ut1("%ut","D TESTCOVR^%ut",-1)
+ S RUNCODE("ENTRY^%uttcovr")=""
 "RTN","uttcovr",13,0)
- D LIST("%ut") ; output results of analysis
+ ; Have the analysis EXCLUDE the following routines from coverage - unit test routines
 "RTN","uttcovr",14,0)
- ; start analysis of %ut1
+ S XCLUDE(1)="%utt1,%utt2,%utt3,%utt4,%utt5,%utt6,%uttcovr"
 "RTN","uttcovr",15,0)
- D COV^%ut1("%ut1","D TESTCOVR^%ut1",3)
+ S XCLUDE(2)="%utf2hex" ; a GT.M system file, although it wasn't showing up anyway
 "RTN","uttcovr",16,0)
- D LIST("%ut1")
+ M ^TMP("%uttcovr",$J,"XCLUDE")=XCLUDE
 "RTN","uttcovr",17,0)
- K ^TMP("%uttcovr",$J)
+ D COVERAGE^%ut("%ut*",.RUNCODE,.XCLUDE,3)
 "RTN","uttcovr",18,0)
  Q
 "RTN","uttcovr",19,0)
  ;
 "RTN","uttcovr",20,0)
-SHOWALL ; Entry to get all coverage globals listed
-"RTN","uttcovr",21,0)
- N SHOWALL
-"RTN","uttcovr",22,0)
- S SHOWALL=1
-"RTN","uttcovr",23,0)
- D ^%uttcovr
-"RTN","uttcovr",24,0)
- Q
-"RTN","uttcovr",25,0)
- ;
-"RTN","uttcovr",26,0)
 ENTRY ;
+"RTN","uttcovr",21,0)
+ K ^TMP("ENTRY^%uttcovr",$J,"VALS")
+"RTN","uttcovr",22,0)
+ M ^TMP("ENTRY^%uttcovr",$J,"VALS")=^TMP("%ut",$J,"UTVALS")
+"RTN","uttcovr",23,0)
+ K ^TMP("%ut",$J,"UTVALS")
+"RTN","uttcovr",24,0)
+ ; these tests run outside of unit tests to handle CHKLEAKS calls not in unit tests
+"RTN","uttcovr",25,0)
+ ; they need data set, so they are called in here
+"RTN","uttcovr",26,0)
+ ; LEAKSOK ;
 "RTN","uttcovr",27,0)
- D ^%utt1 ; verbose
+ N CODE,LOCATN,MYVALS,X,I
 "RTN","uttcovr",28,0)
- D EN^%ut("%utt1") ; non-verbose
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSOK TEST",MYVALS("X")=""
 "RTN","uttcovr",29,0)
- ; run tests from top of %utt6, runs both command line and gui analyses
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find no leaks
 "RTN","uttcovr",30,0)
- D ^%utt6 ; non-verbose
+ ; LEAKSBAD ;
 "RTN","uttcovr",31,0)
- D VERBOSE^%utt6 ; verbose
+ N CODE,LOCATN,MYVALS,X
 "RTN","uttcovr",32,0)
- Q
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSBAD TEST - X NOT SPECIFIED"
 "RTN","uttcovr",33,0)
- ;
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find X since it isn't indicated
 "RTN","uttcovr",34,0)
-LIST(ROU) ;
+ ; try to run coverage
 "RTN","uttcovr",35,0)
- ; ZEXCEPT: SHOWALL - NEWed and set in SHOWALL or entering at %uttcovr
+ W !,"xxxxxxxxxxxxxxxxxxxx GOING TO COV^%ut FOR %utt5 at 3",!!!
 "RTN","uttcovr",36,0)
- N JOB,NAME,BASE,GLOB
+ D COV^%ut("%ut1","D EN^%ut(""%utt5"")",3)
 "RTN","uttcovr",37,0)
- S JOB=$J
+ W !,"xxxxxxxxxxxxxxxxxxxx GOING TO COV^%ut FOR %utt5 at -1",!!!
 "RTN","uttcovr",38,0)
- W !!!,ROU_" COVERAGE ANALYSIS"
+ D COV^%ut("%ut1","D EN^%ut(""%utt5"")",-1)
 "RTN","uttcovr",39,0)
- F NAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
+ N RUNCODE S RUNCODE(1)="^%utt4,^%ut"
 "RTN","uttcovr",40,0)
- . I 'SHOWALL,NAME'="%utCOVREPORT" Q
+ N XCLUDE M XCLUDE=^TMP("%uttcovr",$J,"XCLUDE")
 "RTN","uttcovr",41,0)
- . W !!!,NAME," GLOBAL DATA",!
+ W !,"xxxxxxxxxxxxxxxxxxxx GOING TO MULTAPIS for %utt4 and %ut",!!!
 "RTN","uttcovr",42,0)
- . S BASE="^TMP("""_NAME_""","_JOB,GLOB=BASE_")"
+ D MULTAPIS^%ut(.RUNCODE)
 "RTN","uttcovr",43,0)
- . I $D(GLOB)#2 W !,GLOB,"=",$G(@GLOB)
+ W !,"xxxxxxxxxxxxxxxxxxxx GOING TO COVERAGE for %utt4 and %ut at 3",!!!
 "RTN","uttcovr",44,0)
- . F  S GLOB=$Q(@GLOB) Q:GLOB'[BASE  I $D(GLOB)#2 W !,GLOB,"=",@GLOB
+ D COVERAGE^%ut("%ut*",.RUNCODE,.XCLUDE,3)
 "RTN","uttcovr",45,0)
- . Q
+ N GLT S GLT=$NA(^TMP("%uttcovr-text",$J)) K @GLT
 "RTN","uttcovr",46,0)
+ W !,"xxxxxxxxxxxxxxxxxxxx LISTING DATA VIA LIST",!!!
+"RTN","uttcovr",47,0)
+ D LIST^%utcover(.XCLUDE,3,GLT) ; get coverage for listing and trimdata in %utcover
+"RTN","uttcovr",48,0)
+ F I=1:1 Q:'$D(@GLT@(I))  W !,@GLT@(I)
+"RTN","uttcovr",49,0)
+ K @GLT
+"RTN","uttcovr",50,0)
+ ; restore unit test totals from before entry
+"RTN","uttcovr",51,0)
+ K ^TMP("%ut",$J,"UTVALS")
+"RTN","uttcovr",52,0)
+ M ^TMP("%ut",$J,"UTVALS")=^TMP("ENTRY^%uttcovr",$J,"VALS")
+"RTN","uttcovr",53,0)
+ K ^TMP("ENTRY^%uttcovr",$J,"VALS")
+"RTN","uttcovr",54,0)
+ W !,"xxxxxxxxxxxxxxxxxxxx Finished in ENTRY^%uttcovr",!!!
+"RTN","uttcovr",55,0)
+ Q
+"RTN","uttcovr",56,0)
+ ;
+"RTN","uttcovr",57,0)
+RTNANAL ; @TEST - routine analysis
+"RTN","uttcovr",58,0)
+ N ROUS,GLB
+"RTN","uttcovr",59,0)
+ S ROUS("%utt4")=""
+"RTN","uttcovr",60,0)
+ S GLB=$NA(^TMP("%uttcovr-rtnanal",$J)) K @GLB
+"RTN","uttcovr",61,0)
+ D RTNANAL^%ut1(.ROUS,GLB)
+"RTN","uttcovr",62,0)
+ D CHKTF($D(@GLB@("%utt4","MAIN"))>1,"Not enough 'MAIN' nodes found")
+"RTN","uttcovr",63,0)
+ D CHKTF($G(@GLB@("%utt4","MAIN",3))["D COV^%ut(""%utt3"",""D EN^%ut(""""%utt3"""",1)"",-1)","Incorrect data for line 2 in MAIN")
+"RTN","uttcovr",64,0)
+ D CHKTF($G(@GLB@("%utt4","MAIN",9))=" QUIT","Final QUIT not on expected line")
+"RTN","uttcovr",65,0)
+ K @GLB
+"RTN","uttcovr",66,0)
+ Q
+"RTN","uttcovr",67,0)
+ ;
+"RTN","uttcovr",68,0)
+COVCOV ; @TEST - check COVCOV - remove seen lines
+"RTN","uttcovr",69,0)
+ N C,R
+"RTN","uttcovr",70,0)
+ S C=$NA(^TMP("%uttcovr_C",$J))
+"RTN","uttcovr",71,0)
+ S R=$NA(^TMP("%uttcovr_R",$J))
+"RTN","uttcovr",72,0)
+ S @C@("ROU1")=""
+"RTN","uttcovr",73,0)
+ S @C@("ROU2")="",@R@("ROU2")=""
+"RTN","uttcovr",74,0)
+ S @C@("ROU2","TAG1")="",@R@("ROU2","TAG1")=""
+"RTN","uttcovr",75,0)
+ S @C@("ROU2","TAG1",1)="AAA"
+"RTN","uttcovr",76,0)
+ S @C@("ROU2","TAG1",2)="AAA",@R@("ROU2","TAG1",2)="AAA"
+"RTN","uttcovr",77,0)
+ S @C@("ROU2","TAG1",3)="ABB",@R@("ROU2","TAG1",3)="ABB"
+"RTN","uttcovr",78,0)
+ S @C@("ROU2","TAG2",6)="ACC"
+"RTN","uttcovr",79,0)
+ S @C@("ROU2","TAG2",7)="ADD",@R@("ROU2","TAG2",7)="ADD"
+"RTN","uttcovr",80,0)
+ S @C@("ROU3","TAG1",2)="BAA",@R@("ROU3","TAG1",2)="BAA"
+"RTN","uttcovr",81,0)
+ S @C@("ROU3","TAG1",3)="CAA"
+"RTN","uttcovr",82,0)
+ S @C@("ROU3","TAG1",4)="DAA"
+"RTN","uttcovr",83,0)
+ S @C@("ROU3","TAG1",5)="EAA",@R@("ROU3","TAG1",5)="EAA"
+"RTN","uttcovr",84,0)
+ S @C@("ROU3","TAG1",6)="FAA",@R@("ROU3","TAG1",6)="FAA"
+"RTN","uttcovr",85,0)
+ D COVCOV^%ut1(C,R)
+"RTN","uttcovr",86,0)
+ D CHKTF($D(@C@("ROU2","TAG1",1)),"Invalid value for ""ROU2"",""TAG1"",1")
+"RTN","uttcovr",87,0)
+ D CHKTF('$D(@C@("ROU2","TAG1",2)),"Unexpected value for ""ROU2"",""TAG1"",1")
+"RTN","uttcovr",88,0)
+ D CHKTF($D(@C@("ROU2","TAG2",6)),"Invalid value for ""ROU2"",""TAG1"",1")
+"RTN","uttcovr",89,0)
+ D CHKTF('$D(@C@("ROU2","TAG2",7)),"Unexpected value for ""ROU2"",""TAG1"",1")
+"RTN","uttcovr",90,0)
+ D CHKTF($D(@C@("ROU3","TAG1",4)),"Invalid value for ""ROU2"",""TAG1"",1")
+"RTN","uttcovr",91,0)
+ D CHKTF('$D(@C@("ROU3","TAG1",5)),"Unexpected value for ""ROU2"",""TAG1"",1")
+"RTN","uttcovr",92,0)
+ K @C,@R
+"RTN","uttcovr",93,0)
+ Q
+"RTN","uttcovr",94,0)
+ ;
+"RTN","uttcovr",95,0)
+COVRPT  ; @TEST
+"RTN","uttcovr",96,0)
+ N GL1,GL2,GL3,GL4,VRBOSITY,GL5
+"RTN","uttcovr",97,0)
+ S GL1=$NA(^TMP("%utCOVCOHORTSAVx",$J)) K @GL1
+"RTN","uttcovr",98,0)
+ S GL2=$NA(^TMP("%utCOVCOHORTx",$J)) K @GL2
+"RTN","uttcovr",99,0)
+ S GL3=$NA(^TMP("%utCOVRESULTx",$J)) K @GL3
+"RTN","uttcovr",100,0)
+ S GL4=$NA(^TMP("%utCOVREPORTx",$J)) K @GL4
+"RTN","uttcovr",101,0)
+ S GL5=$NA(^TMP("%ut1-covrpt",$J)) K @GL5
+"RTN","uttcovr",102,0)
+ D SETGLOBS(GL1,GL2)
+"RTN","uttcovr",103,0)
+ S VRBOSITY=1
+"RTN","uttcovr",104,0)
+ D COVRPT^%ut1(GL1,GL2,GL3,VRBOSITY)
+"RTN","uttcovr",105,0)
+ D CHKEQ("COVERAGE PERCENTAGE: 42.11",$G(@GL5@(5)),"Verbosity 1 - not expected percentage value")
+"RTN","uttcovr",106,0)
+ D CHKEQ("  %ut1            42.11%  8 out of 19",$G(@GL5@(9)),"Verbosity 1 - not expected value for line 9")
+"RTN","uttcovr",107,0)
+ D CHKTF('$D(@GL5@(10)),"Verbosity 1 - unexpected data in 10th line")
+"RTN","uttcovr",108,0)
+ ;
+"RTN","uttcovr",109,0)
+ S VRBOSITY=2
+"RTN","uttcovr",110,0)
+ D COVRPT^%ut1(GL1,GL2,GL3,VRBOSITY)
+"RTN","uttcovr",111,0)
+ D CHKEQ("    ACTLINES           0.00%  0 out of 9",$G(@GL5@(10)),"Verbosity 2 - not expected value for 10th line")
+"RTN","uttcovr",112,0)
+ D CHKEQ("    CHEKTEST          80.00%  8 out of 10",$G(@GL5@(11)),"Verbosity 2 - not expected value for 11th line")
+"RTN","uttcovr",113,0)
+ D CHKTF('$D(@GL5@(12)),"Verbosity 2 - unexpected data for 12th line")
+"RTN","uttcovr",114,0)
+ ;
+"RTN","uttcovr",115,0)
+ S VRBOSITY=3
+"RTN","uttcovr",116,0)
+ D COVRPT^%ut1(GL1,GL2,GL3,VRBOSITY)
+"RTN","uttcovr",117,0)
+ D CHKEQ("    ACTLINES           0.00%  0 out of 9",$G(@GL5@(10)),"Verbosity 3 - unexpected value for line 10")
+"RTN","uttcovr",118,0)
+ D CHKEQ("ACTLINES+9:  QUIT CNT",$G(@GL5@(19)),"Verbosity 3 - unexpected value for line 19")
+"RTN","uttcovr",119,0)
+ D CHKEQ("    CHEKTEST          80.00%  8 out of 10",$G(@GL5@(20)),"Verbosity 3 - unexpected value for line 20")
+"RTN","uttcovr",120,0)
+ D CHKEQ("CHEKTEST+39:  . Q",$G(@GL5@(22)),"Verbosity 3 - unexpected value for line 22")
+"RTN","uttcovr",121,0)
+ D CHKTF('$D(@GL5@(23)),"Verbosity 3 - unexpected line 23")
+"RTN","uttcovr",122,0)
+ K @GL1,@GL2,@GL3,@GL4,@GL5
+"RTN","uttcovr",123,0)
+ Q
+"RTN","uttcovr",124,0)
+ ;
+"RTN","uttcovr",125,0)
+COVRPTLS ; @TEST - coverage report returning text in global
+"RTN","uttcovr",126,0)
+ N GL1,GL2,GL3,GL4,VRBOSITY
+"RTN","uttcovr",127,0)
+ S GL1=$NA(^TMP("%utCOVCOHORTSAVx",$J)) K @GL1
+"RTN","uttcovr",128,0)
+ S GL2=$NA(^TMP("%utCOVCOHORTx",$J)) K @GL2
+"RTN","uttcovr",129,0)
+ S GL3=$NA(^TMP("%utCOVRESULTx",$J)) K @GL3
+"RTN","uttcovr",130,0)
+ S GL4=$NA(^TMP("%utCOVREPORTx",$J)) K @GL4
+"RTN","uttcovr",131,0)
+ D SETGLOBS(GL1,GL2)
+"RTN","uttcovr",132,0)
+ S VRBOSITY=1
+"RTN","uttcovr",133,0)
+ D COVRPTLS^%ut1(GL1,GL2,GL3,VRBOSITY,GL4)
+"RTN","uttcovr",134,0)
+ D CHKEQ("COVERAGE PERCENTAGE: 42.11",$G(@GL4@(5)),"Verbosity 1 - not expected percentage value")
+"RTN","uttcovr",135,0)
+ D CHKEQ("  %ut1            42.11%  8 out of 19",$G(@GL4@(9)),"Verbosity 1 - not expected value for line 9")
+"RTN","uttcovr",136,0)
+ D CHKTF('$D(@GL4@(10)),"Verbosity 1 - unexpected data in 10th line")
+"RTN","uttcovr",137,0)
+ K @GL4
+"RTN","uttcovr",138,0)
+ ;
+"RTN","uttcovr",139,0)
+ S VRBOSITY=2
+"RTN","uttcovr",140,0)
+ D COVRPTLS^%ut1(GL1,GL2,GL3,VRBOSITY,GL4)
+"RTN","uttcovr",141,0)
+ D CHKEQ("    ACTLINES           0.00%  0 out of 9",$G(@GL4@(10)),"Verbosity 2 - not expected value for 10th line")
+"RTN","uttcovr",142,0)
+ D CHKEQ("    CHEKTEST          80.00%  8 out of 10",$G(@GL4@(11)),"Verbosity 2 - not expected value for 11th line")
+"RTN","uttcovr",143,0)
+ D CHKTF('$D(@GL4@(12)),"Verbosity 2 - unexpected data for 12th line")
+"RTN","uttcovr",144,0)
+ K @GL4
+"RTN","uttcovr",145,0)
+ ;
+"RTN","uttcovr",146,0)
+ S VRBOSITY=3
+"RTN","uttcovr",147,0)
+ D COVRPTLS^%ut1(GL1,GL2,GL3,VRBOSITY,GL4)
+"RTN","uttcovr",148,0)
+ D CHKEQ("    ACTLINES           0.00%  0 out of 9",$G(@GL4@(10)),"Verbosity 3 - unexpected value for line 10")
+"RTN","uttcovr",149,0)
+ D CHKEQ("ACTLINES+9:  QUIT CNT",$G(@GL4@(19)),"Verbosity 3 - unexpected value for line 19")
+"RTN","uttcovr",150,0)
+ D CHKEQ("    CHEKTEST          80.00%  8 out of 10",$G(@GL4@(20)),"Verbosity 3 - unexpected value for line 20")
+"RTN","uttcovr",151,0)
+ D CHKEQ("CHEKTEST+39:  . Q",$G(@GL4@(22)),"Verbosity 3 - unexpected value for line 22")
+"RTN","uttcovr",152,0)
+ D CHKTF('$D(@GL4@(23)),"Verbosity 3 - unexpected line 23")
+"RTN","uttcovr",153,0)
+ ;
+"RTN","uttcovr",154,0)
+ K @GL1,@GL2,@GL3,@GL4
+"RTN","uttcovr",155,0)
+ Q
+"RTN","uttcovr",156,0)
+ ;
+"RTN","uttcovr",157,0)
+TRIMDATA ; @TEST - TRIMDATA in %utcover
+"RTN","uttcovr",158,0)
+ N GL1,XCLUD
+"RTN","uttcovr",159,0)
+ S GL1=$NA(^TMP("%uttcovr-trimdata",$J)) K @GL1
+"RTN","uttcovr",160,0)
+ S @GL1@("GOOD",1)="1"
+"RTN","uttcovr",161,0)
+ S @GL1@("BAD",1)="1"
+"RTN","uttcovr",162,0)
+ S XCLUD("BAD")=""
+"RTN","uttcovr",163,0)
+ D TRIMDATA^%utcover(.XCLUD,GL1)
+"RTN","uttcovr",164,0)
+ D CHKTF($D(@GL1@("GOOD")),"GOOD ENTRY WAS REMOVED")
+"RTN","uttcovr",165,0)
+ D CHKTF('$D(@GL1@("BAD")),"ENTRY WAS NOT TRIMMED")
+"RTN","uttcovr",166,0)
+ K @GL1,XCLUD
+"RTN","uttcovr",167,0)
+ Q
+"RTN","uttcovr",168,0)
+ ;
+"RTN","uttcovr",169,0)
+LIST ; @TEST - LIST in %utcover
+"RTN","uttcovr",170,0)
+ N GL1,GLT S GL1=$NA(^TMP("%uttcovr-list",$J)),GLT=$NA(^TMP("%uttcovr-text",$J))
+"RTN","uttcovr",171,0)
+ S @GL1@("%ut1")="89/160"
+"RTN","uttcovr",172,0)
+ S @GL1@("%ut1","%ut1")="2/2"
+"RTN","uttcovr",173,0)
+ S @GL1@("%ut1","ACTLINES")="0/8"
+"RTN","uttcovr",174,0)
+ S @GL1@("%ut1","ACTLINES",2)=" N CNT S CNT=0"
+"RTN","uttcovr",175,0)
+ S @GL1@("%ut1","ACTLINES",3)=" N REF S REF=GL"
+"RTN","uttcovr",176,0)
+ S @GL1@("%ut1","ACTLINES",4)=" N GLQL S GLQL=$QL(GL)"
+"RTN","uttcovr",177,0)
+ S @GL1@("%ut1","ACTLINES",5)=" F  S REF=$Q(@REF) Q:REF=""""  Q:(GL'=$NA(@REF,GLQL))  D"
+"RTN","uttcovr",178,0)
+ S @GL1@("%ut1","ACTLINES",6)=" . N REFQL S REFQL=$QL(REF)"
+"RTN","uttcovr",179,0)
+ S @GL1@("%ut1","ACTLINES",7)=" . N LASTSUB S LASTSUB=$QS(REF,REFQL)"
+"RTN","uttcovr",180,0)
+ S @GL1@("%ut1","ACTLINES",8)=" . I LASTSUB?1.N S CNT=CNT+1"
+"RTN","uttcovr",181,0)
+ S @GL1@("%ut1","ACTLINES",9)=" QUIT CNT"
+"RTN","uttcovr",182,0)
+ S @GL1@("%ut1","CHECKTAG")="11/11"
+"RTN","uttcovr",183,0)
+ S @GL1@("%ut1","CHEKTEST")="10/10"
+"RTN","uttcovr",184,0)
+ N XCLUD S XCLUD("%utt1")=""
+"RTN","uttcovr",185,0)
+ D LIST^%utcover(.XCLUD,1,GLT,GL1)
+"RTN","uttcovr",186,0)
+ D CHKEQ("Routine %ut1      (55.63%)   89 out of 160 lines covered",$G(@GLT@(3)),"Verbosity 1 - Unexpected text for line 3")
+"RTN","uttcovr",187,0)
+ D CHKEQ("Overall Analysis 89 out of 160 lines covered (55% coverage)",$G(@GLT@(6)),"Verbosity 1 - unexpected text for line 6")
+"RTN","uttcovr",188,0)
+ D CHKTF('$D(@GLT@(7)),"Verbosity 1 - Unexpected line 7 present")
+"RTN","uttcovr",189,0)
+ K @GLT
+"RTN","uttcovr",190,0)
+ ;
+"RTN","uttcovr",191,0)
+ D LIST^%utcover(.XCLUD,2,GLT,GL1)
+"RTN","uttcovr",192,0)
+ D CHKEQ("  - Summary",$G(@GLT@(4)),"Verbosity 2 - unexpected text at line 4")
+"RTN","uttcovr",193,0)
+ D CHKEQ(" Tag ACTLINES^%ut1          (0.00%)   0 out of 8 lines covered",$G(@GLT@(6)),"Verbosity 2 - unexpected text at line 6")
+"RTN","uttcovr",194,0)
+ D CHKEQ(" Tag CHEKTEST^%ut1        (100.00%)   10 out of 10 lines covered",$G(@GLT@(8)),"Verbosity 2 - unexpected text at line 8")
+"RTN","uttcovr",195,0)
+ D CHKTF($D(@GLT@(14)),"Verbosity 2 - expected line at line 14")
+"RTN","uttcovr",196,0)
+ D CHKTF('$D(@GLT@(15)),"Verbosity 2 - unexpected line at line 15")
+"RTN","uttcovr",197,0)
+ K @GLT
+"RTN","uttcovr",198,0)
+ ;
+"RTN","uttcovr",199,0)
+ D LIST^%utcover(.XCLUD,3,GLT,GL1)
+"RTN","uttcovr",200,0)
+ D CHKEQ(" Tag %ut1^%ut1            (100.00%)   2 out of 2 lines covered",$G(@GLT@(5)),"Verbosity 3 - Incorrect text at line 5")
+"RTN","uttcovr",201,0)
+ D CHKEQ("     ACTLINES+9   QUIT CNT",$G(@GLT@(15)),"Verbosity 3 - incorrect line 15")
+"RTN","uttcovr",202,0)
+ D CHKTF($D(@GLT@(31)),"Verbosity 3 - expected data in line 31")
+"RTN","uttcovr",203,0)
+ D CHKTF('$D(@GLT@(32)),"Verbosity 3 - did not expect a line 32")
+"RTN","uttcovr",204,0)
+ ;
+"RTN","uttcovr",205,0)
+ K @GL1,@GLT
+"RTN","uttcovr",206,0)
+ Q
+"RTN","uttcovr",207,0)
+ ;
+"RTN","uttcovr",208,0)
+SETGLOBS(GL1,GL2) ;
+"RTN","uttcovr",209,0)
+ S @GL1@("%ut1","ACTLINES")="ACTLINES"
+"RTN","uttcovr",210,0)
+ S @GL1@("%ut1","ACTLINES",0)="ACTLINES(GL) ; [Private] $$ ; Count active lines"
+"RTN","uttcovr",211,0)
+ S @GL1@("%ut1","ACTLINES",2)=" N CNT S CNT=0"
+"RTN","uttcovr",212,0)
+ S @GL1@("%ut1","ACTLINES",3)=" N REF S REF=GL"
+"RTN","uttcovr",213,0)
+ S @GL1@("%ut1","ACTLINES",4)=" N GLQL S GLQL=$QL(GL)"
+"RTN","uttcovr",214,0)
+ S @GL1@("%ut1","ACTLINES",5)=" F  S REF=$Q(@REF) Q:REF=""""  Q:(GL'=$NA(@REF,GLQL))  D"
+"RTN","uttcovr",215,0)
+ S @GL1@("%ut1","ACTLINES",6)=" . N REFQL S REFQL=$QL(REF)"
+"RTN","uttcovr",216,0)
+ S @GL1@("%ut1","ACTLINES",7)=" . N LASTSUB S LASTSUB=$QS(REF,REFQL)"
+"RTN","uttcovr",217,0)
+ S @GL1@("%ut1","ACTLINES",8)=" . I LASTSUB?1.N S CNT=CNT+1"
+"RTN","uttcovr",218,0)
+ S @GL1@("%ut1","ACTLINES",9)=" QUIT CNT"
+"RTN","uttcovr",219,0)
+ S @GL1@("%ut1","CHEKTEST")="CHEKTEST"
+"RTN","uttcovr",220,0)
+ S @GL1@("%ut1","CHEKTEST",0)="CHEKTEST(%utROU,%ut,%utUETRY) ; Collect Test list."
+"RTN","uttcovr",221,0)
+ S @GL1@("%ut1","CHEKTEST",13)=" N I,LIST"
+"RTN","uttcovr",222,0)
+ S @GL1@("%ut1","CHEKTEST",14)=" S I=$L($T(@(U_%utROU))) I I<0 Q ""-1^Invalid Routine Name"""
+"RTN","uttcovr",223,0)
+ S @GL1@("%ut1","CHEKTEST",31)=" D NEWSTYLE(.LIST,%utROU)"
+"RTN","uttcovr",224,0)
+ S @GL1@("%ut1","CHEKTEST",32)=" F I=1:1:LIST S %ut(""ENTN"")=%ut(""ENTN"")+1,%utUETRY(%ut(""ENTN""))=$P(LIST(I),U),%utUETRY(%ut(""ENTN""),""NAME"")=$P(LIST(I),U,2,99)"
+"RTN","uttcovr",225,0)
+ S @GL1@("%ut1","CHEKTEST",37)=" N %utUI F %utUI=1:1 S %ut(""ELIN"")=$T(@(""XTENT+""_%utUI_""^""_%utROU)) Q:$P(%ut(""ELIN""),"";"",3)=""""  D"
+"RTN","uttcovr",226,0)
+ S @GL1@("%ut1","CHEKTEST",38)=" . S %ut(""ENTN"")=%ut(""ENTN"")+1,%utUETRY(%ut(""ENTN""))=$P(%ut(""ELIN""),"";"",3),%utUETRY(%ut(""ENTN""),""NAME"")=$P(%ut(""ELIN""),"";"",4)"
+"RTN","uttcovr",227,0)
+ S @GL1@("%ut1","CHEKTEST",39)=" . Q"
+"RTN","uttcovr",228,0)
+ S @GL1@("%ut1","CHEKTEST",41)=" QUIT"
+"RTN","uttcovr",229,0)
+ S @GL1@("%ut1","CHEKTEST",9)=" S %ut(""ENTN"")=0 ; Number of test, sub to %utUETRY."
+"RTN","uttcovr",230,0)
+ S @GL2@("%ut1","ACTLINES")="ACTLINES"
+"RTN","uttcovr",231,0)
+ S @GL2@("%ut1","ACTLINES",0)="ACTLINES(GL) ; [Private] $$ ; Count active lines"
+"RTN","uttcovr",232,0)
+ S @GL2@("%ut1","ACTLINES",2)=" N CNT S CNT=0"
+"RTN","uttcovr",233,0)
+ S @GL2@("%ut1","ACTLINES",3)=" N REF S REF=GL"
+"RTN","uttcovr",234,0)
+ S @GL2@("%ut1","ACTLINES",4)=" N GLQL S GLQL=$QL(GL)"
+"RTN","uttcovr",235,0)
+ S @GL2@("%ut1","ACTLINES",5)=" F  S REF=$Q(@REF) Q:REF=""""  Q:(GL'=$NA(@REF,GLQL))  D"
+"RTN","uttcovr",236,0)
+ S @GL2@("%ut1","ACTLINES",6)=" . N REFQL S REFQL=$QL(REF)"
+"RTN","uttcovr",237,0)
+ S @GL2@("%ut1","ACTLINES",7)=" . N LASTSUB S LASTSUB=$QS(REF,REFQL)"
+"RTN","uttcovr",238,0)
+ S @GL2@("%ut1","ACTLINES",8)=" . I LASTSUB?1.N S CNT=CNT+1"
+"RTN","uttcovr",239,0)
+ S @GL2@("%ut1","ACTLINES",9)=" QUIT CNT"
+"RTN","uttcovr",240,0)
+ S @GL2@("%ut1","CHEKTEST")="CHEKTEST"
+"RTN","uttcovr",241,0)
+ S @GL2@("%ut1","CHEKTEST",38)=" . S %ut(""ENTN"")=%ut(""ENTN"")+1,%utUETRY(%ut(""ENTN""))=$P(%ut(""ELIN""),"";"",3),%utUETRY(%ut(""ENTN""),""NAME"")=$P(%ut(""ELIN""),"";"",4)"
+"RTN","uttcovr",242,0)
+ S @GL2@("%ut1","CHEKTEST",39)=" . Q"
+"RTN","uttcovr",243,0)
+ Q
+"RTN","uttcovr",244,0)
+ ;
+"RTN","uttcovr",245,0)
+ ;
+"RTN","uttcovr",246,0)
+CACHECOV ;@TEST - set up routine for analysis in globals
+"RTN","uttcovr",247,0)
+ N GLOB,GLOBT
+"RTN","uttcovr",248,0)
+ S GLOB=$NA(^TMP("%uttcovr1",$J)),GLOBT=$NA(@GLOB@("uttcovr2",$J)) K @GLOB,@GLOBT
+"RTN","uttcovr",249,0)
+ D CACHECOV^%ut1(GLOB,GLOBT)
+"RTN","uttcovr",250,0)
+ D CHKEQ($T(+1^%ut),@GLOB@("%ut",1,0),"BAD FIRST LINE LOADED FOR %ut")
+"RTN","uttcovr",251,0)
+ D CHKEQ($T(+14^%ut),@GLOBT@("%ut",14,0),"Bad 14th line loaded for %ut")
+"RTN","uttcovr",252,0)
+ K @GLOB,@GLOBT
+"RTN","uttcovr",253,0)
+ Q
+"RTN","uttcovr",254,0)
+ ;
+"RTN","uttcovr",255,0)
+GETVALS ; no test - primarily calls to Cache classes
+"RTN","uttcovr",256,0)
+ Q
+"RTN","uttcovr",257,0)
+ ;
+"RTN","uttcovr",258,0)
+LINEDATA ; @TEST - convert code line to based on tags and offset, and identify active code lines
+"RTN","uttcovr",259,0)
+ N CODE,LINE,OFFSET,TAG
+"RTN","uttcovr",260,0)
+ S LINE="TEST1 ; COMMENT ON TAG",TAG="",OFFSET=0
+"RTN","uttcovr",261,0)
+ S CODE=$$LINEDATA^%ut1(LINE,.TAG,.OFFSET) ;
+"RTN","uttcovr",262,0)
+ D CHKEQ(0,CODE,"Tag with comment identified as active code")
+"RTN","uttcovr",263,0)
+ D CHKEQ("TEST1",TAG,"Bad tag returned for TEST1")
+"RTN","uttcovr",264,0)
+ D CHKEQ(0,OFFSET,"Bad OFFSET returned for TEST1")
+"RTN","uttcovr",265,0)
+ ;
+"RTN","uttcovr",266,0)
+ S LINE=" ; COMMENT ONLY"
+"RTN","uttcovr",267,0)
+ S CODE=$$LINEDATA^%ut1(LINE,.TAG,.OFFSET) ;
+"RTN","uttcovr",268,0)
+ D CHKEQ(0,CODE,"Comment line identified as active code")
+"RTN","uttcovr",269,0)
+ D CHKEQ("TEST1",TAG,"Bad tag returned for TEST1+1")
+"RTN","uttcovr",270,0)
+ D CHKEQ(1,OFFSET,"Bad OFFSET returned for TEST1+1")
+"RTN","uttcovr",271,0)
+ ;
+"RTN","uttcovr",272,0)
+ S LINE=" S X=VALUE"
+"RTN","uttcovr",273,0)
+ S CODE=$$LINEDATA^%ut1(LINE,.TAG,.OFFSET) ;
+"RTN","uttcovr",274,0)
+ D CHKEQ(1,CODE,"Code line NOT identified as active code")
+"RTN","uttcovr",275,0)
+ D CHKEQ("TEST1",TAG,"Bad tag returned for TEST1+2")
+"RTN","uttcovr",276,0)
+ D CHKEQ(2,OFFSET,"Bad OFFSET returned for TEST1+2")
+"RTN","uttcovr",277,0)
+ ;
+"RTN","uttcovr",278,0)
+ S LINE="TEST2 S X=VALUE"
+"RTN","uttcovr",279,0)
+ S CODE=$$LINEDATA^%ut1(LINE,.TAG,.OFFSET) ;
+"RTN","uttcovr",280,0)
+ D CHKEQ(1,CODE,"Tag line with code NOT identified as active code")
+"RTN","uttcovr",281,0)
+ D CHKEQ("TEST2",TAG,"Bad tag returned for TEST2")
+"RTN","uttcovr",282,0)
+ D CHKEQ(0,OFFSET,"Bad OFFSET returned for TEST2")
+"RTN","uttcovr",283,0)
+ ;
+"RTN","uttcovr",284,0)
+ Q
+"RTN","uttcovr",285,0)
+ ;
+"RTN","uttcovr",286,0)
+TOTAGS ;@TEST - convert from lines of code by line number to lines ordered by tag, line from tag, and only not covered
+"RTN","uttcovr",287,0)
+ N ACTIVE,GLOB,GLOBT,X1,X0
+"RTN","uttcovr",288,0)
+ S GLOB=$NA(^TMP("%uttcovr",$J)),GLOBT=$NA(@GLOB@("TEST1")) K @GLOB
+"RTN","uttcovr",289,0)
+ S @GLOBT@(1,0)="LINE1 ; CODE1 LINE1+0 NOT ACTIVE"
+"RTN","uttcovr",290,0)
+ S @GLOBT@(2,0)=" CODE2 LINE+1 SEEN"
+"RTN","uttcovr",291,0)
+ S @GLOBT@(2,"C")=2
+"RTN","uttcovr",292,0)
+ S @GLOBT@(3,0)=" CODE3 LINE1+2 NOT SEEN"
+"RTN","uttcovr",293,0)
+ S @GLOBT@(4,0)="LINE4 CODE4 LINE4+0 SEEN"
+"RTN","uttcovr",294,0)
+ S @GLOBT@(4,"C")=5
+"RTN","uttcovr",295,0)
+ S @GLOBT@(5,0)=" ; CODE5 LINE4+1 NOT ACTIVE"
+"RTN","uttcovr",296,0)
+ S @GLOBT@(6,0)=" CODE6 LINE4+2 COVERED"
+"RTN","uttcovr",297,0)
+ S @GLOBT@(6,"C")=2
+"RTN","uttcovr",298,0)
+ S @GLOBT@(7,0)="LINE7 CODE7 LINE7+0 NOT COVERED"
+"RTN","uttcovr",299,0)
+ S @GLOBT@(8,0)=" CODE8 LINE7+1 NOT COVERED"
+"RTN","uttcovr",300,0)
+ S ACTIVE=1
+"RTN","uttcovr",301,0)
+ D TOTAGS^%ut1(GLOB,ACTIVE)
+"RTN","uttcovr",302,0)
+ D CHKEQ(1,($D(@GLOBT@("LINE1"))#2),"LINE1 TAG NOT IDENTIFIED")
+"RTN","uttcovr",303,0)
+ D CHKEQ(1,($D(@GLOBT@("LINE4"))#2),"LINE4 TAG NOT IDENTIFIED")
+"RTN","uttcovr",304,0)
+ D CHKEQ(1,($D(@GLOBT@("LINE7"))#2),"LINE7 TAG NOT IDENTIFIED")
+"RTN","uttcovr",305,0)
+ D CHKEQ(0,$D(@GLOBT@("LINE1",0)),"LINE1+0 SHOULD NOT BE INCLUDED - IT IS A COMMENT")
+"RTN","uttcovr",306,0)
+ D CHKEQ(0,$D(@GLOBT@("LINE1",1)),"LINE1+1 SHOULD NOT BE INCLUDED - IT WAS COVERED")
+"RTN","uttcovr",307,0)
+ D CHKEQ(1,$D(@GLOBT@("LINE1",2)),"LINE1+2 SHOULD BE INCLUDED - IT WAS NOT COVERED")
+"RTN","uttcovr",308,0)
+ D CHKEQ(0,$D(@GLOBT@("LINE4",0)),"LINE4+0 SHOULD NOT BE INCLUDED - IT WAS COVERED")
+"RTN","uttcovr",309,0)
+ D CHKEQ(0,$D(@GLOBT@("LINE4",1)),"LINE4+1 SHOULD NOT BE INCLUDED - IT IS A COMMENT")
+"RTN","uttcovr",310,0)
+ D CHKEQ(0,$D(@GLOBT@("LINE4",2)),"LINE4+2 SHOULD NOT BE INCLUDED - IT WAS COVERED")
+"RTN","uttcovr",311,0)
+ D CHKEQ(1,$D(@GLOBT@("LINE7",0)),"LINE7+0 SHOULD BE INCLUDED - IT IS NOT COVERED")
+"RTN","uttcovr",312,0)
+ D CHKEQ(1,$D(@GLOBT@("LINE7",1)),"LINE7+1 SHOULD BE INCLUDED - IT IS NOT COVERED")
+"RTN","uttcovr",313,0)
+ K @GLOB,@GLOBT
+"RTN","uttcovr",314,0)
+ Q
+"RTN","uttcovr",315,0)
+ ;
+"RTN","uttcovr",316,0)
+CHKEQ(EXPECTED,SEEN,COMMENT) ;
+"RTN","uttcovr",317,0)
+ D CHKEQ^%ut(EXPECTED,SEEN,$G(COMMENT))
+"RTN","uttcovr",318,0)
+ Q
+"RTN","uttcovr",319,0)
+ ;
+"RTN","uttcovr",320,0)
+CHKTF(VALUE,COMMENT) ;
+"RTN","uttcovr",321,0)
+ D CHKTF^%ut(VALUE,$G(COMMENT))
+"RTN","uttcovr",322,0)
  Q
 "SEC","^DIC",17.9001,17.9001,0,"AUDIT")
 @