diff --git a/MASH-0_1-0_M-Unit_Test_140910.KID b/MASH-0_2-0_M-Unit_Test_150703.KID
similarity index 65%
rename from MASH-0_1-0_M-Unit_Test_140910.KID
rename to MASH-0_2-0_M-Unit_Test_150703.KID
index 13b6ddb..4855a1a 100644
--- a/MASH-0_1-0_M-Unit_Test_140910.KID
+++ b/MASH-0_2-0_M-Unit_Test_150703.KID
@@ -1,178 +1,234 @@
-KIDS Distribution saved on Sep 10, 2014@14:37:04
-Implements the M-Unit Test functionality.
-**KIDS**:MASH*0.1*0^
+KIDS Distribution saved on Jul 03, 2015@13:42:04
+Updated version of M-Unit (%ut) of MASH UTILITIES
+**KIDS**:MASH*0.2*0^
 
 **INSTALL NAME**
-MASH*0.1*0
-"BLD",5528,0)
-MASH*0.1*0^MASH UTILITIES^0^3140910^y
-"BLD",5528,1,0)
-^^2^2^3140829^
-"BLD",5528,1,1,0)
-M-Unit Test functionality to provide basic unit testing framework for M 
-"BLD",5528,1,2,0)
-development.
-"BLD",5528,4,0)
+MASH*0.2*0
+"BLD",9544,0)
+MASH*0.2*0^MASH UTILITIES^0^3150703^n
+"BLD",9544,1,0)
+^^24^24^3150703^^
+"BLD",9544,1,1,0)
+Changes to functionality include:
+"BLD",9544,1,2,0)
+ 
+"BLD",9544,1,3,0)
+STARTUP and SHUTDOWN will be run in each routine instead of the first
+"BLD",9544,1,4,0)
+instance of STARTUP and SHUTDOWN encountered being the only ones that
+"BLD",9544,1,5,0)
+were run.  This change was made because of possible suites of tests
+"BLD",9544,1,6,0)
+which have their own STARTUP and SHUTDOWN that need to be run.  Also,
+"BLD",9544,1,7,0)
+it does not depend on the order in which test routines are run.
+"BLD",9544,1,8,0)
+ 
+"BLD",9544,1,9,0)
+While the coverage functionality can only be run on GT.M systems at
+"BLD",9544,1,10,0)
+the present time, the routine %utcover has been added to provide
+"BLD",9544,1,11,0)
+additional ability to run a number of unit tests at one time so that
+"BLD",9544,1,12,0)
+coverage across all of them can be obtained in one run, this includes
+"BLD",9544,1,13,0)
+the ability to specify entry at different APIs (e.g., if both verbose
+"BLD",9544,1,14,0)
+and nonverbose entries are available) as well as run code which is not
+"BLD",9544,1,15,0)
+part of a unit test to include in the analysis.  The routine %uttcovr
+"BLD",9544,1,16,0)
+uses this functionality to provide a means of doing coverage analysis
+"BLD",9544,1,17,0)
+on the %ut routines and can be used as an example of its usage.
+"BLD",9544,1,18,0)
+ 
+"BLD",9544,1,19,0)
+A new tag (COV) has been added to the %ut routine (it simply calls
+"BLD",9544,1,20,0)
+the one in %ut1) so that all user APIs can be accessed within the %ut
+"BLD",9544,1,21,0)
+routine.
+"BLD",9544,1,22,0)
+ 
+"BLD",9544,1,23,0)
+A potential problem with setting up the %ut namespace in the local 
+"BLD",9544,1,24,0)
+instance was addressed by Sam Habiel in the preinstall routine ZZUTPRE.
+"BLD",9544,4,0)
 ^9.64PA^17.9001^1
-"BLD",5528,4,17.9001,0)
+"BLD",9544,4,17.9001,0)
 17.9001
-"BLD",5528,4,17.9001,222)
+"BLD",9544,4,17.9001,222)
 y^y^f^^n^^y^o^n
-"BLD",5528,4,"B",17.9001,17.9001)
+"BLD",9544,4,"B",17.9001,17.9001)
 
-"BLD",5528,"ABPKG")
+"BLD",9544,6.3)
+4
+"BLD",9544,"ABPKG")
 n
-"BLD",5528,"INI")
+"BLD",9544,"INI")
 ZZUTPRE
-"BLD",5528,"INID")
+"BLD",9544,"INID")
 ^n^n
-"BLD",5528,"INIT")
+"BLD",9544,"INIT")
 ZZUTPOST
-"BLD",5528,"KRN",0)
-^9.67PA^8989.52^19
-"BLD",5528,"KRN",.4,0)
+"BLD",9544,"KRN",0)
+^9.67PA^779.2^20
+"BLD",9544,"KRN",.4,0)
 .4
-"BLD",5528,"KRN",.401,0)
+"BLD",9544,"KRN",.401,0)
 .401
-"BLD",5528,"KRN",.402,0)
+"BLD",9544,"KRN",.402,0)
 .402
-"BLD",5528,"KRN",.403,0)
+"BLD",9544,"KRN",.403,0)
 .403
-"BLD",5528,"KRN",.5,0)
+"BLD",9544,"KRN",.5,0)
 .5
-"BLD",5528,"KRN",.84,0)
+"BLD",9544,"KRN",.84,0)
 .84
-"BLD",5528,"KRN",3.6,0)
+"BLD",9544,"KRN",3.6,0)
 3.6
-"BLD",5528,"KRN",3.8,0)
+"BLD",9544,"KRN",3.8,0)
 3.8
-"BLD",5528,"KRN",9.2,0)
+"BLD",9544,"KRN",9.2,0)
 9.2
-"BLD",5528,"KRN",9.8,0)
+"BLD",9544,"KRN",9.8,0)
 9.8
-"BLD",5528,"KRN",9.8,"NM",0)
-^9.68A^9^9
-"BLD",5528,"KRN",9.8,"NM",1,0)
-ut^^0^B257937062
-"BLD",5528,"KRN",9.8,"NM",2,0)
-ut1^^0^B87092328
-"BLD",5528,"KRN",9.8,"NM",3,0)
-utt1^^0^B25860592
-"BLD",5528,"KRN",9.8,"NM",4,0)
+"BLD",9544,"KRN",9.8,"NM",0)
+^9.68A^10^10
+"BLD",9544,"KRN",9.8,"NM",1,0)
+ut^^0^B268535658
+"BLD",9544,"KRN",9.8,"NM",2,0)
+ut1^^0^B105832889
+"BLD",9544,"KRN",9.8,"NM",3,0)
+utt1^^0^B26409996
+"BLD",9544,"KRN",9.8,"NM",4,0)
 utt2^^0^B473823
-"BLD",5528,"KRN",9.8,"NM",5,0)
+"BLD",9544,"KRN",9.8,"NM",5,0)
 utt3^^0^B1493136
-"BLD",5528,"KRN",9.8,"NM",6,0)
+"BLD",9544,"KRN",9.8,"NM",6,0)
 utt4^^0^B1419637
-"BLD",5528,"KRN",9.8,"NM",7,0)
+"BLD",9544,"KRN",9.8,"NM",7,0)
 utt5^^0^B22421637
-"BLD",5528,"KRN",9.8,"NM",8,0)
-utt6^^0^B29243478
-"BLD",5528,"KRN",9.8,"NM",9,0)
-uttcovr^^0^B2835727
-"BLD",5528,"KRN",9.8,"NM","B","ut",1)
+"BLD",9544,"KRN",9.8,"NM",8,0)
+utt6^^0^B30140551
+"BLD",9544,"KRN",9.8,"NM",9,0)
+uttcovr^^0^B88235384
+"BLD",9544,"KRN",9.8,"NM",10,0)
+utcover^^0^B63651128
+"BLD",9544,"KRN",9.8,"NM","B","ut",1)
 
-"BLD",5528,"KRN",9.8,"NM","B","ut1",2)
+"BLD",9544,"KRN",9.8,"NM","B","ut1",2)
 
-"BLD",5528,"KRN",9.8,"NM","B","utt1",3)
+"BLD",9544,"KRN",9.8,"NM","B","utcover",10)
 
-"BLD",5528,"KRN",9.8,"NM","B","utt2",4)
+"BLD",9544,"KRN",9.8,"NM","B","utt1",3)
 
-"BLD",5528,"KRN",9.8,"NM","B","utt3",5)
+"BLD",9544,"KRN",9.8,"NM","B","utt2",4)
 
-"BLD",5528,"KRN",9.8,"NM","B","utt4",6)
+"BLD",9544,"KRN",9.8,"NM","B","utt3",5)
 
-"BLD",5528,"KRN",9.8,"NM","B","utt5",7)
+"BLD",9544,"KRN",9.8,"NM","B","utt4",6)
 
-"BLD",5528,"KRN",9.8,"NM","B","utt6",8)
+"BLD",9544,"KRN",9.8,"NM","B","utt5",7)
 
-"BLD",5528,"KRN",9.8,"NM","B","uttcovr",9)
+"BLD",9544,"KRN",9.8,"NM","B","utt6",8)
 
-"BLD",5528,"KRN",19,0)
+"BLD",9544,"KRN",9.8,"NM","B","uttcovr",9)
+
+"BLD",9544,"KRN",19,0)
 19
-"BLD",5528,"KRN",19,"NM",0)
+"BLD",9544,"KRN",19,"NM",0)
 ^9.68A^3^3
-"BLD",5528,"KRN",19,"NM",1,0)
+"BLD",9544,"KRN",19,"NM",1,0)
 utMUNIT^^0
-"BLD",5528,"KRN",19,"NM",2,0)
+"BLD",9544,"KRN",19,"NM",2,0)
 utMUNIT GROUP EDIT^^0
-"BLD",5528,"KRN",19,"NM",3,0)
+"BLD",9544,"KRN",19,"NM",3,0)
 utMUNIT GROUP RUN^^0
-"BLD",5528,"KRN",19,"NM","B","utMUNIT",1)
+"BLD",9544,"KRN",19,"NM","B","utMUNIT",1)
 
-"BLD",5528,"KRN",19,"NM","B","utMUNIT GROUP EDIT",2)
+"BLD",9544,"KRN",19,"NM","B","utMUNIT GROUP EDIT",2)
 
-"BLD",5528,"KRN",19,"NM","B","utMUNIT GROUP RUN",3)
+"BLD",9544,"KRN",19,"NM","B","utMUNIT GROUP RUN",3)
 
-"BLD",5528,"KRN",19.1,0)
+"BLD",9544,"KRN",19.1,0)
 19.1
-"BLD",5528,"KRN",101,0)
+"BLD",9544,"KRN",101,0)
 101
-"BLD",5528,"KRN",409.61,0)
+"BLD",9544,"KRN",409.61,0)
 409.61
-"BLD",5528,"KRN",771,0)
+"BLD",9544,"KRN",771,0)
 771
-"BLD",5528,"KRN",870,0)
+"BLD",9544,"KRN",779.2,0)
+779.2
+"BLD",9544,"KRN",870,0)
 870
-"BLD",5528,"KRN",8989.51,0)
+"BLD",9544,"KRN",8989.51,0)
 8989.51
-"BLD",5528,"KRN",8989.52,0)
+"BLD",9544,"KRN",8989.52,0)
 8989.52
-"BLD",5528,"KRN",8994,0)
+"BLD",9544,"KRN",8994,0)
 8994
-"BLD",5528,"KRN",8994,"NM",0)
+"BLD",9544,"KRN",8994,"NM",0)
 ^9.68A^3^3
-"BLD",5528,"KRN",8994,"NM",1,0)
+"BLD",9544,"KRN",8994,"NM",1,0)
 utMUNIT-TEST GROUP LOAD^^0
-"BLD",5528,"KRN",8994,"NM",2,0)
+"BLD",9544,"KRN",8994,"NM",2,0)
 utMUNIT-TEST LOAD^^0
-"BLD",5528,"KRN",8994,"NM",3,0)
+"BLD",9544,"KRN",8994,"NM",3,0)
 utMUNIT-TEST NEXT^^0
-"BLD",5528,"KRN",8994,"NM","B","utMUNIT-TEST GROUP LOAD",1)
+"BLD",9544,"KRN",8994,"NM","B","utMUNIT-TEST GROUP LOAD",1)
 
-"BLD",5528,"KRN",8994,"NM","B","utMUNIT-TEST LOAD",2)
+"BLD",9544,"KRN",8994,"NM","B","utMUNIT-TEST LOAD",2)
 
-"BLD",5528,"KRN",8994,"NM","B","utMUNIT-TEST NEXT",3)
+"BLD",9544,"KRN",8994,"NM","B","utMUNIT-TEST NEXT",3)
 
-"BLD",5528,"KRN","B",.4,.4)
+"BLD",9544,"KRN","B",.4,.4)
 
-"BLD",5528,"KRN","B",.401,.401)
+"BLD",9544,"KRN","B",.401,.401)
 
-"BLD",5528,"KRN","B",.402,.402)
+"BLD",9544,"KRN","B",.402,.402)
 
-"BLD",5528,"KRN","B",.403,.403)
+"BLD",9544,"KRN","B",.403,.403)
 
-"BLD",5528,"KRN","B",.5,.5)
+"BLD",9544,"KRN","B",.5,.5)
 
-"BLD",5528,"KRN","B",.84,.84)
+"BLD",9544,"KRN","B",.84,.84)
 
-"BLD",5528,"KRN","B",3.6,3.6)
+"BLD",9544,"KRN","B",3.6,3.6)
 
-"BLD",5528,"KRN","B",3.8,3.8)
+"BLD",9544,"KRN","B",3.8,3.8)
 
-"BLD",5528,"KRN","B",9.2,9.2)
+"BLD",9544,"KRN","B",9.2,9.2)
 
-"BLD",5528,"KRN","B",9.8,9.8)
+"BLD",9544,"KRN","B",9.8,9.8)
 
-"BLD",5528,"KRN","B",19,19)
+"BLD",9544,"KRN","B",19,19)
 
-"BLD",5528,"KRN","B",19.1,19.1)
+"BLD",9544,"KRN","B",19.1,19.1)
 
-"BLD",5528,"KRN","B",101,101)
+"BLD",9544,"KRN","B",101,101)
 
-"BLD",5528,"KRN","B",409.61,409.61)
+"BLD",9544,"KRN","B",409.61,409.61)
 
-"BLD",5528,"KRN","B",771,771)
+"BLD",9544,"KRN","B",771,771)
 
-"BLD",5528,"KRN","B",870,870)
+"BLD",9544,"KRN","B",779.2,779.2)
 
-"BLD",5528,"KRN","B",8989.51,8989.51)
+"BLD",9544,"KRN","B",870,870)
 
-"BLD",5528,"KRN","B",8989.52,8989.52)
+"BLD",9544,"KRN","B",8989.51,8989.51)
 
-"BLD",5528,"KRN","B",8994,8994)
+"BLD",9544,"KRN","B",8989.52,8989.52)
 
-"BLD",5528,"QUES",0)
+"BLD",9544,"KRN","B",8994,8994)
+
+"BLD",9544,"QDEF")
+^^^^NO^^^^NO^^NO
+"BLD",9544,"QUES",0)
 ^9.62^^
 "DATA",17.9001,1,0)
 TESTS FOR UNIT TEST ROUTINES
@@ -203,7 +259,7 @@ y^y^f^^n^^y^o^n
 "FIA",17.9001,0,"RLRO")
 
 "FIA",17.9001,0,"VR")
-0.1^MASH
+0.2^MASH
 "FIA",17.9001,17.9001)
 0
 "FIA",17.9001,17.90011)
@@ -214,77 +270,77 @@ y^y^f^^n^^y^o^n
 ZZUTPRE
 "INIT")
 ZZUTPOST
-"KRN",19,10068,-1)
+"KRN",19,11538,-1)
 0^1
-"KRN",19,10068,0)
+"KRN",19,11538,0)
 utMUNIT^M-Unit Tester^^B^^^^^^^^
-"KRN",19,10068,1,0)
+"KRN",19,11538,1,0)
 ^^1^1^3140805^
-"KRN",19,10068,1,1,0)
+"KRN",19,11538,1,1,0)
 This is the context option for M-Unit Test functionality.
-"KRN",19,10068,"RPC",0)
+"KRN",19,11538,"RPC",0)
 ^19.05P^3^3
-"KRN",19,10068,"RPC",1,0)
+"KRN",19,11538,"RPC",1,0)
 utMUNIT-TEST GROUP LOAD
-"KRN",19,10068,"RPC",2,0)
+"KRN",19,11538,"RPC",2,0)
 utMUNIT-TEST LOAD
-"KRN",19,10068,"RPC",3,0)
+"KRN",19,11538,"RPC",3,0)
 utMUNIT-TEST NEXT
-"KRN",19,10068,"U")
+"KRN",19,11538,"U")
 M-UNIT TESTER
-"KRN",19,10069,-1)
+"KRN",19,11539,-1)
 0^2
-"KRN",19,10069,0)
+"KRN",19,11539,0)
 utMUNIT GROUP EDIT^M-Unit Test Group Edit^^E^^^^^^^^TOOLKIT
-"KRN",19,10069,1,0)
+"KRN",19,11539,1,0)
 ^19.06^6^6^3031030^^^
-"KRN",19,10069,1,1,0)
+"KRN",19,11539,1,1,0)
 This option can be used to maintain a listing of unit tests related to a 
-"KRN",19,10069,1,2,0)
+"KRN",19,11539,1,2,0)
 specific topic.  The Group identifies the topic, and the unit tests 
-"KRN",19,10069,1,3,0)
+"KRN",19,11539,1,3,0)
 related to that topic are added in the multiple.  Unit Tests can be run 
-"KRN",19,10069,1,4,0)
+"KRN",19,11539,1,4,0)
 by selecting a group, and all unit tests included in the multiple will be 
-"KRN",19,10069,1,5,0)
+"KRN",19,11539,1,5,0)
 used for the test.  In addition, any other references under the XTROU tag 
-"KRN",19,10069,1,6,0)
+"KRN",19,11539,1,6,0)
 in any of the included test routines will be included in the run.
-"KRN",19,10069,30)
+"KRN",19,11539,30)
 %ut(17.9001,
-"KRN",19,10069,31)
+"KRN",19,11539,31)
 AEMQL
-"KRN",19,10069,50)
+"KRN",19,11539,50)
 17.9001
-"KRN",19,10069,51)
+"KRN",19,11539,51)
 .01;1
-"KRN",19,10069,"U")
+"KRN",19,11539,"U")
 M-UNIT TEST GROUP EDIT
-"KRN",19,10070,-1)
+"KRN",19,11540,-1)
 0^3
-"KRN",19,10070,0)
+"KRN",19,11540,0)
 utMUNIT GROUP RUN^Run M-Unit Tests From Test Groups^^R^^^^^^^^TOOLKIT
-"KRN",19,10070,1,0)
+"KRN",19,11540,1,0)
 ^^2^2^3031030^
-"KRN",19,10070,1,1,0)
+"KRN",19,11540,1,1,0)
 Provides a means of initiating a unit test run from the menu system based 
-"KRN",19,10070,1,2,0)
+"KRN",19,11540,1,2,0)
 on entries in the M-UNIT TEST GROUP file (#17.9001).
-"KRN",19,10070,25)
+"KRN",19,11540,25)
 PICKSET^%ut
-"KRN",19,10070,"U")
+"KRN",19,11540,"U")
 RUN M-UNIT TESTS FROM TEST GRO
-"KRN",8994,1866,-1)
+"KRN",8994,3261,-1)
 0^1
-"KRN",8994,1866,0)
+"KRN",8994,3261,0)
 utMUNIT-TEST GROUP LOAD^GUISET^%ut^4^^^^1
-"KRN",8994,1867,-1)
+"KRN",8994,3262,-1)
 0^2
-"KRN",8994,1867,0)
+"KRN",8994,3262,0)
 utMUNIT-TEST LOAD^GUILOAD^%ut^4^^^^1
-"KRN",8994,1868,-1)
+"KRN",8994,3263,-1)
 0^3
-"KRN",8994,1868,0)
+"KRN",8994,3263,0)
 utMUNIT-TEST NEXT^GUINEXT^%ut^4^^^^1
 "MBREQ")
 0
@@ -296,24 +352,68 @@ REMOTE PROCEDURE
 19;18;;;OPT^XPDTA;OPTF1^XPDIA;OPTE1^XPDIA;OPTF2^XPDIA;;OPTDEL^XPDIA
 "ORD",18,19,0)
 OPTION
-"PKG",201,-1)
+"PKG",222,-1)
 1^1
-"PKG",201,0)
+"PKG",222,0)
 MASH UTILITIES^%u^Utilities associated with the M Advanced Shell
-"PKG",201,20,0)
+"PKG",222,20,0)
 ^9.402P^^
-"PKG",201,22,0)
+"PKG",222,22,0)
 ^9.49I^1^1
-"PKG",201,22,1,0)
-0.1
-"PKG",201,22,1,"PAH",1,0)
-0^3140910^2802
-"PKG",201,22,1,"PAH",1,1,0)
-^^2^2^3140910
-"PKG",201,22,1,"PAH",1,1,1,0)
-M-Unit Test functionality to provide basic unit testing framework for M 
-"PKG",201,22,1,"PAH",1,1,2,0)
-development.
+"PKG",222,22,1,0)
+0.2
+"PKG",222,22,1,"PAH",1,0)
+0^3150703
+"PKG",222,22,1,"PAH",1,1,0)
+^^24^24^3150703
+"PKG",222,22,1,"PAH",1,1,1,0)
+Changes to functionality include:
+"PKG",222,22,1,"PAH",1,1,2,0)
+ 
+"PKG",222,22,1,"PAH",1,1,3,0)
+STARTUP and SHUTDOWN will be run in each routine instead of the first
+"PKG",222,22,1,"PAH",1,1,4,0)
+instance of STARTUP and SHUTDOWN encountered being the only ones that
+"PKG",222,22,1,"PAH",1,1,5,0)
+were run.  This change was made because of possible suites of tests
+"PKG",222,22,1,"PAH",1,1,6,0)
+which have their own STARTUP and SHUTDOWN that need to be run.  Also,
+"PKG",222,22,1,"PAH",1,1,7,0)
+it does not depend on the order in which test routines are run.
+"PKG",222,22,1,"PAH",1,1,8,0)
+ 
+"PKG",222,22,1,"PAH",1,1,9,0)
+While the coverage functionality can only be run on GT.M systems at
+"PKG",222,22,1,"PAH",1,1,10,0)
+the present time, the routine %utcover has been added to provide
+"PKG",222,22,1,"PAH",1,1,11,0)
+additional ability to run a number of unit tests at one time so that
+"PKG",222,22,1,"PAH",1,1,12,0)
+coverage across all of them can be obtained in one run, this includes
+"PKG",222,22,1,"PAH",1,1,13,0)
+the ability to specify entry at different APIs (e.g., if both verbose
+"PKG",222,22,1,"PAH",1,1,14,0)
+and nonverbose entries are available) as well as run code which is not
+"PKG",222,22,1,"PAH",1,1,15,0)
+part of a unit test to include in the analysis.  The routine %uttcovr
+"PKG",222,22,1,"PAH",1,1,16,0)
+uses this functionality to provide a means of doing coverage analysis
+"PKG",222,22,1,"PAH",1,1,17,0)
+on the %ut routines and can be used as an example of its usage.
+"PKG",222,22,1,"PAH",1,1,18,0)
+ 
+"PKG",222,22,1,"PAH",1,1,19,0)
+A new tag (COV) has been added to the %ut routine (it simply calls
+"PKG",222,22,1,"PAH",1,1,20,0)
+the one in %ut1) so that all user APIs can be accessed within the %ut
+"PKG",222,22,1,"PAH",1,1,21,0)
+routine.
+"PKG",222,22,1,"PAH",1,1,22,0)
+ 
+"PKG",222,22,1,"PAH",1,1,23,0)
+A potential problem with setting up the %ut namespace in the local 
+"PKG",222,22,1,"PAH",1,1,24,0)
+instance was addressed by Sam Habiel in the preinstall routine ZZUTPRE.
 "QUES","XPF1",0)
 Y
 "QUES","XPF1","??")
@@ -341,7 +441,7 @@ YO
 "QUES","XPI1","A")
 Want KIDS to INHIBIT LOGONs during the install
 "QUES","XPI1","B")
-YES
+NO
 "QUES","XPI1","M")
 D XPI1^XPDIQ
 "QUES","XPM1",0)
@@ -361,7 +461,7 @@ Y
 "QUES","XPO1","A")
 Want KIDS to Rebuild Menu Trees Upon Completion of Install
 "QUES","XPO1","B")
-YES
+NO
 "QUES","XPO1","M")
 D XPO1^XPDIQ
 "QUES","XPZ1",0)
@@ -371,7 +471,7 @@ Y
 "QUES","XPZ1","A")
 Want to DISABLE Scheduled Options, Menu Options, and Protocols
 "QUES","XPZ1","B")
-YES
+NO
 "QUES","XPZ1","M")
 D XPZ1^XPDIQ
 "QUES","XPZ2",0)
@@ -385,377 +485,377 @@ NO
 "QUES","XPZ2","M")
 D XPZ2^XPDIQ
 "RTN")
-11
+12
 "RTN","ZZUTPOST")
-0^^B30449799
+0^^B39206871
 "RTN","ZZUTPOST",1,0)
-ut01POST ;VEN-SMH/JLI - post install for M-Unit Test software ;08/28/14  12:29
+ut01POST        ;VEN-SMH/JLI - post install for M-Unit Test software ;08/28/14  12:29
 "RTN","ZZUTPOST",2,0)
- ;;0.1;MASH UTILITIES
+ ;;0.1;MASH UTILITIES;;;Build 4
 "RTN","ZZUTPOST",3,0)
- N X,I
+        N X,I
 "RTN","ZZUTPOST",4,0)
- I +$SY=47 D  R X:$G(DTIME,300) D MES^XPDUTL(" ")
+        I +$SY=47 D  R X:$G(DTIME,300) D MES^XPDUTL(" ")
 "RTN","ZZUTPOST",5,0)
- . S X(1)=" "
+        . S X(1)=" "
 "RTN","ZZUTPOST",6,0)
- . S X(2)="In the next section, as it tries to copy the ut* routines"
+        . 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:"
+        . S X(3)="to %ut* routines watch for text that indicates the following:"
 "RTN","ZZUTPOST",8,0)
- . S X(4)=" "
+        . S X(4)=" "
 "RTN","ZZUTPOST",9,0)
- . S X(5)="cp: cannot create regular file `/_ut.m': Permission denied"
+        . S X(5)="cp: cannot create regular file `/_ut.m': Permission denied"
 "RTN","ZZUTPOST",10,0)
- . S X(6)=" "
+        . S X(6)=" "
 "RTN","ZZUTPOST",11,0)
- . S X(7)="If this is seen, respond Yes at the prompt after the attempt:"
+        . 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: "
+        . 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
+        . F I=1:1:18 D MES^XPDUTL(" ") ; create a blank screen for text
 "RTN","ZZUTPOST",14,0)
- . D MES^XPDUTL(.X)
+        . D MES^XPDUTL(.X)
 "RTN","ZZUTPOST",15,0)
- . Q
+        . Q
 "RTN","ZZUTPOST",16,0)
- D RENAME
+        D RENAME
 "RTN","ZZUTPOST",17,0)
- I +$SY=47 D  R X:$G(DTIME,300) I "Yy"[$E($G(X)) D GTMPROB
+        I +$SY=47 D  R X:$G(DTIME,300) I "Yy"[$E($G(X)) D GTMPROB
 "RTN","ZZUTPOST",18,0)
- . K X
+        . K X
 "RTN","ZZUTPOST",19,0)
- . S X(1)=" "
+        . S X(1)=" "
 "RTN","ZZUTPOST",20,0)
- . S X(2)="  Your entry on the next line may not echo"
+        . 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// "
+        . S X(3)="If error text was seen enter Y (and RETURN):  NO// "
 "RTN","ZZUTPOST",22,0)
- . D MES^XPDUTL(.X)
+        . D MES^XPDUTL(.X)
 "RTN","ZZUTPOST",23,0)
- . Q
+        . Q
 "RTN","ZZUTPOST",24,0)
- Q
+        Q
 "RTN","ZZUTPOST",25,0)
- ;
+        ;
 "RTN","ZZUTPOST",26,0)
-RENAME ;
+RENAME  ;
 "RTN","ZZUTPOST",27,0)
- N %S,%D ; Source, destination
+        N %S,%D ; Source, destination
 "RTN","ZZUTPOST",28,0)
- S U="^"
+        S U="^"
 "RTN","ZZUTPOST",29,0)
- S %S="ut^ut1^utt1^utt2^utt3^utt4^utt5^utt6^uttcovr"
+        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"
+        S %D="%ut^%ut1^%utt1^%utt2^%utt3^%utt4^%utt5^%utt6^%uttcovr"
 "RTN","ZZUTPOST",31,0)
- ;
+        ;
 "RTN","ZZUTPOST",32,0)
-MOVE ; rename % routines
+MOVE    ; rename % routines
 "RTN","ZZUTPOST",33,0)
- N %,X,Y,M
+        N %,X,Y,M
 "RTN","ZZUTPOST",34,0)
- F %=1:1:$L(%D,"^") D  D MES(M) I +$SY=47 D MES(" ")
+        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
+        . S M="",X=$P(%S,U,%) ; from
 "RTN","ZZUTPOST",36,0)
- . S Y=$P(%D,U,%) ; to
+        . S Y=$P(%D,U,%) ; to
 "RTN","ZZUTPOST",37,0)
- . Q:X=""
+        . Q:X=""
 "RTN","ZZUTPOST",38,0)
- . S M="Routine: "_$J(X,8)
+        . S M="Routine: "_$J(X,8)
 "RTN","ZZUTPOST",39,0)
- . Q:Y=""  I $T(^@X)=""  S M=M_"  Missing" Q
+        . Q:Y=""  I $T(^@X)=""  S M=M_"  Missing" Q
 "RTN","ZZUTPOST",40,0)
- . S M=M_" Loaded, "
+        . S M=M_" Loaded, "
 "RTN","ZZUTPOST",41,0)
- . D COPY(X,Y)
+        . D COPY(X,Y)
 "RTN","ZZUTPOST",42,0)
- . S M=M_"Saved as "_$J(Y,8)
+        . S M=M_"Saved as "_$J(Y,8)
 "RTN","ZZUTPOST",43,0)
- ;
+        ;
 "RTN","ZZUTPOST",44,0)
- QUIT  ; END
+        QUIT  ; END
 "RTN","ZZUTPOST",45,0)
- ;
+        ;
 "RTN","ZZUTPOST",46,0)
-COPY(FROM,TO) ;
+COPY(FROM,TO)   ;
 "RTN","ZZUTPOST",47,0)
- N XVAL
+        N XVAL
 "RTN","ZZUTPOST",48,0)
- I +$SYSTEM=0 S XVAL="ZL @FROM ZS @TO" X XVAL QUIT
+        I +$SYSTEM=0 S XVAL="ZL @FROM ZS @TO" X XVAL QUIT
 "RTN","ZZUTPOST",49,0)
- I +$SYSTEM=47 DO  QUIT
+        I +$SYSTEM=47 DO  QUIT
 "RTN","ZZUTPOST",50,0)
- . S FROM=$$PATH(FROM)
+        . S FROM=$$PATH(FROM)
 "RTN","ZZUTPOST",51,0)
- . S TO=$$PATH(TO,"WRITE")
+        . S TO=$$PATH(TO,"WRITE")
 "RTN","ZZUTPOST",52,0)
- . N CMD S CMD="cp "_FROM_" "_TO
+        . N CMD S CMD="cp "_FROM_" "_TO
 "RTN","ZZUTPOST",53,0)
- . O "cp":(shell="/bin/sh":command=CMD:WRITEONLY)::"PIPE"
+        . O "cp":(shell="/bin/sh":command=CMD:WRITEONLY)::"PIPE"
 "RTN","ZZUTPOST",54,0)
- . U "cp" C "cp"
+        . U "cp" C "cp"
 "RTN","ZZUTPOST",55,0)
- QUIT
+        QUIT
 "RTN","ZZUTPOST",56,0)
- ;
+        ;
 "RTN","ZZUTPOST",57,0)
-PATH(ROUTINE,MODE) ; for GT.M return source file with path for a routine
+PATH(ROUTINE,MODE)      ; for GT.M return source file with path for a routine
 "RTN","ZZUTPOST",58,0)
- ;input: ROUTINE=Name of routine
+        ;input: ROUTINE=Name of routine
 "RTN","ZZUTPOST",59,0)
- ;       MODE="READ" or "WRITE" defaults to READ
+        ;       MODE="READ" or "WRITE" defaults to READ
 "RTN","ZZUTPOST",60,0)
- ;output: Full filename
+        ;output: Full filename
 "RTN","ZZUTPOST",61,0)
- ;
+        ;
 "RTN","ZZUTPOST",62,0)
- S MODE=$G(MODE,"READ") ;set MODE to default value
+        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
+        N FILE S FILE=$TR(ROUTINE,"%","_")_".m" ;convert rtn name to filename
 "RTN","ZZUTPOST",64,0)
- N ZRO S ZRO=$ZRO
+        N ZRO S ZRO=$ZRO
 "RTN","ZZUTPOST",65,0)
- ;
+        ;
 "RTN","ZZUTPOST",66,0)
- ; Get source routine
+        ; Get source routine
 "RTN","ZZUTPOST",67,0)
- N %ZR
+        N %ZR
 "RTN","ZZUTPOST",68,0)
- I MODE="READ" D SILENT^%RSEL(ROUTINE,"SRC") Q %ZR(ROUTINE)_FILE
+        I MODE="READ" D SILENT^%RSEL(ROUTINE,"SRC") Q %ZR(ROUTINE)_FILE
 "RTN","ZZUTPOST",69,0)
- ;
+        ;
 "RTN","ZZUTPOST",70,0)
- ; We are writing. Parse directories and get 1st routine directory
+        ; We are writing. Parse directories and get 1st routine directory
 "RTN","ZZUTPOST",71,0)
- N DIRS
+        N DIRS
 "RTN","ZZUTPOST",72,0)
- D PARSEZRO(.DIRS,ZRO)
+        D PARSEZRO(.DIRS,ZRO)
 "RTN","ZZUTPOST",73,0)
- N PATH S PATH=$$ZRO1ST(.DIRS)
+        N PATH S PATH=$$ZRO1ST(.DIRS)
 "RTN","ZZUTPOST",74,0)
- ;
+        ;
 "RTN","ZZUTPOST",75,0)
- QUIT PATH_FILE ;end of PATH return directory and filename
+        QUIT PATH_FILE ;end of PATH return directory and filename
 "RTN","ZZUTPOST",76,0)
- ;
+        ;
 "RTN","ZZUTPOST",77,0)
- ;
+        ;
 "RTN","ZZUTPOST",78,0)
-PARSEZRO(DIRS,ZRO) ; Parse $zroutines properly into an array
+PARSEZRO(DIRS,ZRO)      ; Parse $zroutines properly into an array
 "RTN","ZZUTPOST",79,0)
- N PIECE
+        N PIECE
 "RTN","ZZUTPOST",80,0)
- N I
+        N I
 "RTN","ZZUTPOST",81,0)
- F I=1:1:$L(ZRO," ") S PIECE(I)=$P(ZRO," ",I)
+        F I=1:1:$L(ZRO," ") S PIECE(I)=$P(ZRO," ",I)
 "RTN","ZZUTPOST",82,0)
- N CNT S CNT=1
+        N CNT S CNT=1
 "RTN","ZZUTPOST",83,0)
- F I=0:0 S I=$O(PIECE(I)) Q:'I  D
+        F I=0:0 S I=$O(PIECE(I)) Q:'I  D
 "RTN","ZZUTPOST",84,0)
- . S DIRS(CNT)=$G(DIRS(CNT))_PIECE(I)
+        . S DIRS(CNT)=$G(DIRS(CNT))_PIECE(I)
 "RTN","ZZUTPOST",85,0)
- . I DIRS(CNT)["("&(DIRS(CNT)[")") S CNT=CNT+1 QUIT
+        . I DIRS(CNT)["("&(DIRS(CNT)[")") S CNT=CNT+1 QUIT
 "RTN","ZZUTPOST",86,0)
- . I DIRS(CNT)'["("&(DIRS(CNT)'[")") S CNT=CNT+1 QUIT
+        . I DIRS(CNT)'["("&(DIRS(CNT)'[")") S CNT=CNT+1 QUIT
 "RTN","ZZUTPOST",87,0)
- . S DIRS(CNT)=DIRS(CNT)_" " ; prep for next piece
+        . S DIRS(CNT)=DIRS(CNT)_" " ; prep for next piece
 "RTN","ZZUTPOST",88,0)
- QUIT
+        QUIT
 "RTN","ZZUTPOST",89,0)
- ;
+        ;
 "RTN","ZZUTPOST",90,0)
-ZRO1ST(DIRS) ; $$ Get first routine directory
+ZRO1ST(DIRS)    ; $$ Get first routine directory
 "RTN","ZZUTPOST",91,0)
- N OUT ; $$ return
+        N OUT ; $$ return
 "RTN","ZZUTPOST",92,0)
- N %1 S %1=DIRS(1) ; 1st directory
+        N %1 S %1=DIRS(1) ; 1st directory
 "RTN","ZZUTPOST",93,0)
- ; Parse with (...)
+        ; Parse with (...)
 "RTN","ZZUTPOST",94,0)
- I %1["(" DO
+        I %1["(" DO
 "RTN","ZZUTPOST",95,0)
- . S OUT=$P(%1,"(",2)
+        . S OUT=$P(%1,"(",2)
 "RTN","ZZUTPOST",96,0)
- . I OUT[" " S OUT=$P(OUT," ")
+        . I OUT[" " S OUT=$P(OUT," ")
 "RTN","ZZUTPOST",97,0)
- . E  S OUT=$P(OUT,")")
+        . E  S OUT=$P(OUT,")")
 "RTN","ZZUTPOST",98,0)
- ; no parens
+        ; no parens
 "RTN","ZZUTPOST",99,0)
- E  S OUT=%1
+        E  S OUT=%1
 "RTN","ZZUTPOST",100,0)
- ;
+        ;
 "RTN","ZZUTPOST",101,0)
- ; Add trailing slash
+        ; Add trailing slash
 "RTN","ZZUTPOST",102,0)
- I $E(OUT,$L(OUT))'="/" S OUT=OUT_"/"
+        I $E(OUT,$L(OUT))'="/" S OUT=OUT_"/"
 "RTN","ZZUTPOST",103,0)
- QUIT OUT
+        QUIT OUT
 "RTN","ZZUTPOST",104,0)
- ;
+        ;
 "RTN","ZZUTPOST",105,0)
-MES(T,B) ;Write message.
+MES(T,B)        ;Write message.
 "RTN","ZZUTPOST",106,0)
- S B=$G(B)
+        S B=$G(B)
 "RTN","ZZUTPOST",107,0)
- I $L($T(BMES^XPDUTL)) D BMES^XPDUTL(T):B,MES^XPDUTL(T):'B Q
+        I $L($T(BMES^XPDUTL)) D BMES^XPDUTL(T):B,MES^XPDUTL(T):'B Q
 "RTN","ZZUTPOST",108,0)
- W:B ! W !,T
+        W:B ! W !,T
 "RTN","ZZUTPOST",109,0)
- Q
+        Q
 "RTN","ZZUTPOST",110,0)
- ;
+        ;
 "RTN","ZZUTPOST",111,0)
-TEST ; @TEST - TESTING TESTING
+TEST    ; @TEST - TESTING TESTING
 "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"
+        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)
+        N DIRS D PARSEZRO(.DIRS,ZR)
 "RTN","ZZUTPOST",115,0)
- N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+        N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
 "RTN","ZZUTPOST",116,0)
- I FIRSTDIR'="p" S $EC=",U1,"
+        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"
+        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)
+        N DIRS D PARSEZRO(.DIRS,ZR)
 "RTN","ZZUTPOST",120,0)
- N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+        N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
 "RTN","ZZUTPOST",121,0)
- I FIRSTDIR'="/var/abc/r/" S $EC=",U1,"
+        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"
+        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)
+        N DIRS D PARSEZRO(.DIRS,ZR)
 "RTN","ZZUTPOST",125,0)
- N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+        N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
 "RTN","ZZUTPOST",126,0)
- I FIRSTDIR'="/abc/def" S $EC=",U1,"
+        I FIRSTDIR'="/abc/def" S $EC=",U1,"
 "RTN","ZZUTPOST",127,0)
- ;
+        ;
 "RTN","ZZUTPOST",128,0)
- WRITE "All tests have run successfully!",!
+        WRITE "All tests have run successfully!",!
 "RTN","ZZUTPOST",129,0)
- QUIT
+        QUIT
 "RTN","ZZUTPOST",130,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
+        N X
 "RTN","ZZUTPOST",133,0)
- S X(1)=" "
+        S X(1)=" "
 "RTN","ZZUTPOST",134,0)
- S X(2)="*** An error occurred during renaming of routines to %ut*."
+        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."
+        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"
+        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 "
+        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',"
+        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"
+        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"
+        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."
+        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"
+        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"
+        S X(11)="*** the %ut and %ut1 routines to confirm they are working"
 "RTN","ZZUTPOST",144,0)
- S X(12)=" "
+        S X(12)=" "
 "RTN","ZZUTPOST",145,0)
- S X(13)="  Press Enter to continue: "
+        S X(13)="  Press Enter to continue: "
 "RTN","ZZUTPOST",146,0)
- D MES^XPDUTL(.X)
+        D MES^XPDUTL(.X)
 "RTN","ZZUTPOST",147,0)
- R X:$G(DTIME,300)
+        R X:$G(DTIME,300)
 "RTN","ZZUTPOST",148,0)
- Q
+        Q
 "RTN","ZZUTPRE")
-0^^B3651860
+0^^B6741733
 "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
 "RTN","ZZUTPRE",2,0)
- ;;0.1;MASH UTILITIES
+ ;;0.2;MASH UTILITIES;;;Build 4
 "RTN","ZZUTPRE",3,0)
- ;
+        ;
 "RTN","ZZUTPRE",4,0)
- ; The following is used to create, if it does not exist, the MASH UTILITIES
+        ; The following is used to create, if it does not exist, the MASH UTILITIES
 "RTN","ZZUTPRE",5,0)
- ; package, and to assign the %u namespace to this package.  This special
+        ; 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
+        ; processing is necessary, since the input transform currently will not accept a
 "RTN","ZZUTPRE",7,0)
- ; % or lower case character in the namespace.
+        ; % or lower case character in the namespace.
 "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
+        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",9,0)
- ; and if necessary, as in CACHE, map %ut routine and namespace in the current account.
+        ; and if necessary, as in CACHE, map %ut routine and namespace in the current account.
 "RTN","ZZUTPRE",10,0)
- I +$SY=0 D CACHEMAP ; This routine is CACHE specific
+        I +$SY=0 D CACHEMAP ; This routine is CACHE specific
 "RTN","ZZUTPRE",11,0)
- Q
+        Q
 "RTN","ZZUTPRE",12,0)
- ; The following code was provided by Sam Habiel to map %
+        ; The following code was provided by Sam Habiel to map %
 "RTN","ZZUTPRE",13,0)
-CACHEMAP ; Map %ut* Globals and Routines away from %SYS in Cache
+CACHEMAP        ; Map %ut* Globals and Routines away from %SYS in Cache
 "RTN","ZZUTPRE",14,0)
- ; Get current namespace
+        ; Get current namespace
 "RTN","ZZUTPRE",15,0)
- N NMSP
+        N NMSP
 "RTN","ZZUTPRE",16,0)
- I $P($P($ZV,") ",2),"(")<2012 S NMSP=$ZU(5)
+        I $P($P($ZV,") ",2),"(")<2012 S NMSP=$ZU(5)
 "RTN","ZZUTPRE",17,0)
- I $P($P($ZV,") ",2),"(")>2011 S NMSP=$NAMESPACE
+        I $P($P($ZV,") ",2),"(")>2011 S NMSP=$NAMESPACE
 "RTN","ZZUTPRE",18,0)
- ;
+        ;
 "RTN","ZZUTPRE",19,0)
- ; Map %ut globals away from %SYS
+        ; Map %ut globals away from %SYS
 "RTN","ZZUTPRE",20,0)
- ZN "%SYS" ; Go to SYS
+        ZN "%SYS" ; Go to SYS
 "RTN","ZZUTPRE",21,0)
- N % S %=##class(Config.Configuration).GetGlobalMapping(NMSP,"%ut*","",NMSP,NMSP)
+        N % S %=##class(Config.Configuration).GetGlobalMapping(NMSP,"%ut*","",NMSP,NMSP)
 "RTN","ZZUTPRE",22,0)
- I '% S %=##class(Config.Configuration).AddGlobalMapping(NMSP,"%ut*","",NMSP,NMSP)
+        I '% S %=##class(Config.Configuration).AddGlobalMapping(NMSP,"%ut*","",NMSP,NMSP)
 "RTN","ZZUTPRE",23,0)
- I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) QUIT
+        I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) QUIT
 "RTN","ZZUTPRE",24,0)
- ;
+        ;
 "RTN","ZZUTPRE",25,0)
- ; Map %ut routines away from %SYS
+        ; Map %ut routines away from %SYS
 "RTN","ZZUTPRE",26,0)
- N A S A("Database")=NMSP
+        N A S A("Database")=NMSP
 "RTN","ZZUTPRE",27,0)
- N % S %=##Class(Config.MapRoutines).Get(NMSP,"%ut*",.A)
+        N % S %=##Class(Config.MapRoutines).Get(NMSP,"%ut*",.A)
 "RTN","ZZUTPRE",28,0)
- S A("Database")=NMSP
+        S A("Database")=NMSP
 "RTN","ZZUTPRE",29,0)
- I '% S %=##Class(Config.MapRoutines).Create(NMSP,"%ut*",.A)
+        I '% S %=##Class(Config.MapRoutines).Create(NMSP,"%ut*",.A)
 "RTN","ZZUTPRE",30,0)
- I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) QUIT
+        I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) QUIT
 "RTN","ZZUTPRE",31,0)
- ZN NMSP ; Go back
+        ZN NMSP ; Go back
 "RTN","ZZUTPRE",32,0)
- QUIT
+        QUIT
 "RTN","ut")
-0^1^B257937062
+0^1^B268535658
 "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 ; 7/2/15 1:12pm
 "RTN","ut",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 4
 "RTN","ut",3,0)
  ;
 "RTN","ut",4,0)
@@ -837,901 +937,903 @@ CACHEMAP ; Map %ut* Globals and Routines away from %SYS in Cache
 "RTN","ut",42,0)
  ;              Created M-UNIT TEST GROUP file at 17.9001 based on the 17.9001 file
 "RTN","ut",43,0)
- Q
+ ; 141030 JLI - Removed tag TESTCOVR and code under it, not necessary
 "RTN","ut",44,0)
- ;
+ ;              since %uttcovr can handle all of the calling needed
 "RTN","ut",45,0)
-EN(%utRNAM,%utVERB,%utBREAK) ; .SR Entry point with primary test routine name, optional 1 for verbose output
+ ;              Added call to run routine %utt6 if run from the top,
 "RTN","ut",46,0)
- N %utLIST,%utROU,%ut
+ ;              since this will run the full range of unit tests
 "RTN","ut",47,0)
- I '+$G(%utVERB) S %utVERB=0
+ ;              Modified STARTUP and SHUTDOWN commands to handle in
 "RTN","ut",48,0)
- S %utLIST=1,%utROU(%utLIST)=%utRNAM
+ ;              each routine where they are available, since only
 "RTN","ut",49,0)
- D SETUT
+ ;              running one STARTUP and SHUTDOWN (the first seen by
 "RTN","ut",50,0)
- D EN1(.%utROU,%utLIST)
+ ;              the program) restricted their use in suites of multiple
 "RTN","ut",51,0)
- Q
+ ;              tests.
 "RTN","ut",52,0)
- ;
+ ; 150101 JLI - Added COV entry to %ut (in addition to current in %ut1) so it is easier
 "RTN","ut",53,0)
-SETUT ;
+ ;              to remember how to use it.
 "RTN","ut",54,0)
- ; VEN/SMH 26JUL2013
+ ; 150621 JLI - Added a global location to pick up summary data for a unit test call, so
 "RTN","ut",55,0)
- I '($D(IO)#2) S IO=$P
+ ;              programs running multiple calls can generate a summary if desired.
 "RTN","ut",56,0)
- S U="^"
+ D ^%utt6 ; runs unit tests on all of it
 "RTN","ut",57,0)
- ; VEN/SMH 26JUL2013 END
+ Q
 "RTN","ut",58,0)
  ;
 "RTN","ut",59,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+EN(%utRNAM,%utVERB,%utBREAK) ; .SR Entry point with primary test routine name, optional 1 for verbose output
 "RTN","ut",60,0)
- S %ut("IO")=IO
+ N %utLIST,%utROU,%ut
 "RTN","ut",61,0)
- S %ut=1 ; set to identify unit test being run check with $$ISUTEST^%ut()
+ I '+$G(%utVERB) S %utVERB=0
 "RTN","ut",62,0)
- ;
+ S %utLIST=1,%utROU(%utLIST)=%utRNAM
 "RTN","ut",63,0)
- ; ZEXCEPT: %utBREAK
+ K ^TMP("%ut",$J,"UTVALS")
 "RTN","ut",64,0)
- I $G(%utBREAK) S %ut("BREAK")=1
+ D SETUT
 "RTN","ut",65,0)
- Q
+ D EN1(.%utROU,%utLIST)
 "RTN","ut",66,0)
- ;
+ Q
 "RTN","ut",67,0)
-EN1(%utROU,%utLIST) ;
+ ;
 "RTN","ut",68,0)
- ; VEN/SMH 26JUL2013 - This block is refactored to fix problems with
+SETUT ;
 "RTN","ut",69,0)
- ; SETUP and TEARDOWN not happening at the right time
+ ; VEN/SMH 26JUL2013
 "RTN","ut",70,0)
- N %utERRL,%utK,%utI,%utJ,%utSTRT
+ I '($D(IO)#2) S IO=$P
 "RTN","ut",71,0)
- ; ZEXCEPT: %utVERB   -- ARGUMENT TO EN
+ S U="^"
 "RTN","ut",72,0)
- ; ZEXCEPT: %utGUI      -- CONDITIONALLY DEFINED BY GUINEXT
+ ; VEN/SMH 26JUL2013 END
 "RTN","ut",73,0)
- ; ZEXCEPT: %ut  -- NEWED IN EN
+ ;
 "RTN","ut",74,0)
- ;
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
 "RTN","ut",75,0)
- ; Structure map for %ut
+ S %ut("IO")=IO
 "RTN","ut",76,0)
- ; -- CURR = Counter for routine number. Used as sub in %utROU
+ S %ut=1 ; set to identify unit test being run check with $$ISUTEST^%ut()
 "RTN","ut",77,0)
- ; -- ECNT = Entry point count in loop (cf. NERT); VEN/SMH - Needed?
+ ;
 "RTN","ut",78,0)
- ; -- FAIL = Number of failures
+ ; ZEXCEPT: %utBREAK
 "RTN","ut",79,0)
- ; -- CHK  = Number of checks ran (TF/EQ/FAIL)
+ I $G(%utBREAK) S %ut("BREAK")=1
 "RTN","ut",80,0)
- ; -- NENT = Number of entry points ran
+ Q
 "RTN","ut",81,0)
- ; -- ERRN = Number of errors
+ ;
 "RTN","ut",82,0)
- S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
+EN1(%utROU,%utLIST) ;
 "RTN","ut",83,0)
- ;
+ ; VEN/SMH 26JUL2013 - This block is refactored to fix problems with
 "RTN","ut",84,0)
- ; -- GET LIST OF ROUTINES --
+ ; SETUP and TEARDOWN not happening at the right time
 "RTN","ut",85,0)
- ; first get any tree of routines from this one
+ N %utERRL,%utK,%utI,%utJ,%utSTRT
 "RTN","ut",86,0)
- D GETTREE^%ut1(.%utROU,.%utLIST)
+ ; ZEXCEPT: %utVERB   -- ARGUMENT TO EN
 "RTN","ut",87,0)
- ;
+ ; ZEXCEPT: %utGUI      -- CONDITIONALLY DEFINED BY GUINEXT
 "RTN","ut",88,0)
- ; -- STARTUP --
+ ; ZEXCEPT: %ut  -- NEWED IN EN
 "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
+ ; Structure map for %ut
 "RTN","ut",91,0)
- . I $T(@("STARTUP^"_%utROU(%ut("CURR"))))'="" S %utSTRT="STARTUP^"_%utROU(%ut("CURR"))
+ ; -- CURR = Counter for routine number. Used as sub in %utROU
 "RTN","ut",92,0)
- . Q
+ ; -- ECNT = Entry point count in loop (cf. NERT); VEN/SMH - Needed?
 "RTN","ut",93,0)
- ; 070224 - end of addition JLI
+ ; -- FAIL = Number of failures
 "RTN","ut",94,0)
- ;
+ ; -- CHK  = Number of checks ran (TF/EQ/FAIL)
 "RTN","ut",95,0)
- ;
+ ; -- NENT = Number of entry points ran
 "RTN","ut",96,0)
- ; Now process each routine that has been referenced
+ ; -- ERRN = Number of errors
 "RTN","ut",97,0)
- S %ut("CURR")=0
+ S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
 "RTN","ut",98,0)
- F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D
+ ;
 "RTN","ut",99,0)
- . N %utETRY ; Test list to run
+ ; -- GET LIST OF ROUTINES --
 "RTN","ut",100,0)
- . ;
+ ; first get any tree of routines from this one
 "RTN","ut",101,0)
- . ; Collect Test list.
+ D GETTREE^%ut1(.%utROU,.%utLIST)
 "RTN","ut",102,0)
- . D CHEKTEST^%ut1(%utROU(%ut("CURR")),.%ut,.%utETRY)
+ ;
 "RTN","ut",103,0)
- . ;
+ ; Now process each routine that has been referenced
 "RTN","ut",104,0)
- . ; if a SETUP entry point exists, save it off in %ut
+ N CURRROU
 "RTN","ut",105,0)
- . N %utSETUP S %utSETUP="SETUP^"_%utROU(%ut("CURR"))
+ S %ut("CURR")=0
 "RTN","ut",106,0)
- . S %ut("LINE")=$T(@%utSETUP) I %ut("LINE")'="" S %ut("SETUP")=%utSETUP
+ 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",107,0)
- . K %utSETUP ; we're done!
+ . ; 141018 - add ability to run STARTUP and SHUTDOWN in each routine JLI
 "RTN","ut",108,0)
- . ;
+ . I $T(@("STARTUP^"_CURRROU))'="" D @("STARTUP^"_CURRROU) ; 141018
 "RTN","ut",109,0)
- . ; if a TEARDOWN entry point exists, ditto
+ . N %utETRY ; Test list to run
 "RTN","ut",110,0)
- . N %utTEARDOWN S %utTEARDOWN="TEARDOWN^"_%utROU(%ut("CURR"))
+ . ;
 "RTN","ut",111,0)
- . S %ut("LINE")=$T(@%utTEARDOWN) I %ut("LINE")'="" S %ut("TEARDOWN")=%utTEARDOWN
+ . ; Collect Test list.
 "RTN","ut",112,0)
- . K %utTEARDOWN ; done here.
+ . D CHEKTEST^%ut1(%utROU(%ut("CURR")),.%ut,.%utETRY)
 "RTN","ut",113,0)
  . ;
 "RTN","ut",114,0)
- . ; VEN/SMH 26JUL2013 - this block changed to correct running of setup and teardown
+ . ; if a SETUP entry point exists, save it off in %ut
 "RTN","ut",115,0)
- . ; run each of the specified entry points
+ . S %ut("SETUP")="" ; 141018 need to clear any previous values JLI
 "RTN","ut",116,0)
- . ;
+ . N %utSETUP S %utSETUP="SETUP^"_%utROU(%ut("CURR"))
 "RTN","ut",117,0)
- . ; == THIS FOR/DO BLOCK IS THE CENTRAL TEST RUNNER ==
+ . S %ut("LINE")=$T(@%utSETUP) I %ut("LINE")'="" S %ut("SETUP")=%utSETUP
 "RTN","ut",118,0)
- . S %utI=0
+ . K %utSETUP ; we're done!
 "RTN","ut",119,0)
- . F  S %utI=$O(%utETRY(%utI)) Q:%utI'>0  S %ut("ENUM")=%ut("ERRN")+%ut("FAIL") D
+ . ;
 "RTN","ut",120,0)
- . . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . ; if a TEARDOWN entry point exists, ditto
 "RTN","ut",121,0)
- . . ;
+ . S %ut("TEARDOWN")="" ; 141018 need to clear any previous values JLI
 "RTN","ut",122,0)
- . . ; Run Set-up Code (only if present)
+ . N %utTEARDOWN S %utTEARDOWN="TEARDOWN^"_%utROU(%ut("CURR"))
 "RTN","ut",123,0)
- . . S %ut("ENT")=$G(%ut("SETUP")) ; Current entry
+ . S %ut("LINE")=$T(@%utTEARDOWN) I %ut("LINE")'="" S %ut("TEARDOWN")=%utTEARDOWN
 "RTN","ut",124,0)
- . . S %ut("NAME")="Set-up Code"
+ . K %utTEARDOWN ; done here.
 "RTN","ut",125,0)
- . . D:%ut("ENT")]"" @%ut("ENT")
+ . ;
 "RTN","ut",126,0)
- . . ;
+ . ; VEN/SMH 26JUL2013 - this block changed to correct running of setup and teardown
 "RTN","ut",127,0)
- . . ; Run actual test
+ . ; run each of the specified entry points
 "RTN","ut",128,0)
- . . S %ut("ECNT")=%ut("ECNT")+1
+ . ;
 "RTN","ut",129,0)
- . . S %ut("NAME")=%utETRY(%utI,"NAME")
+ . ; == THIS FOR/DO BLOCK IS THE CENTRAL TEST RUNNER ==
 "RTN","ut",130,0)
- . . S %ut("ENT")=%utETRY(%utI)_"^"_%utROU(%ut("CURR"))
+ . S %utI=0
 "RTN","ut",131,0)
- . . I %utVERB,'$D(%utGUI) D VERBOSE1(.%utETRY,%utI) ; Say what we executed.
+ . F  S %utI=$O(%utETRY(%utI)) Q:%utI'>0  S %ut("ENUM")=%ut("ERRN")+%ut("FAIL") D
 "RTN","ut",132,0)
- . . D @%ut("ENT")
+ . . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",133,0)
  . . ;
 "RTN","ut",134,0)
- . . ; Run Teardown Code (only if present)
+ . . ; Run Set-up Code (only if present)
 "RTN","ut",135,0)
- . . S %ut("ENT")=$G(%ut("TEARDOWN"))
+ . . S %ut("ENT")=$G(%ut("SETUP")) ; Current entry
 "RTN","ut",136,0)
- . . S %ut("NAME")="Teardown Code"
+ . . S %ut("NAME")="Set-up Code"
 "RTN","ut",137,0)
  . . D:%ut("ENT")]"" @%ut("ENT")
 "RTN","ut",138,0)
  . . ;
 "RTN","ut",139,0)
- . . ; ENUM = Number of errors + failures
+ . . ; Run actual test
 "RTN","ut",140,0)
- . . ; Only print out the success message [OK] If our error number remains
+ . . S %ut("ECNT")=%ut("ECNT")+1
 "RTN","ut",141,0)
- . . ; the same as when we started the loop.
+ . . S %ut("NAME")=%utETRY(%utI,"NAME")
 "RTN","ut",142,0)
- . . I %utVERB,'$D(%utGUI) D
+ . . S %ut("ENT")=%utETRY(%utI)_"^"_%utROU(%ut("CURR"))
 "RTN","ut",143,0)
- . . . I %ut("ENUM")=(%ut("ERRN")+%ut("FAIL")) D VERBOSE(.%utETRY,%utI,1) I 1
+ . . I %utVERB,'$D(%utGUI) D VERBOSE1(.%utETRY,%utI) ; Say what we executed.
 "RTN","ut",144,0)
- . . . E  D VERBOSE(.%utETRY,%utI,0)
+ . . D @%ut("ENT")
 "RTN","ut",145,0)
- . ;
+ . . ;
 "RTN","ut",146,0)
- . ;
+ . . ; Run Teardown Code (only if present)
 "RTN","ut",147,0)
- . ; keep a %utCNT of number of entry points executed across all routines
+ . . S %ut("ENT")=$G(%ut("TEARDOWN"))
 "RTN","ut",148,0)
- . S %ut("NENT")=%ut("NENT")+%ut("ENTN")
+ . . S %ut("NAME")="Teardown Code"
 "RTN","ut",149,0)
- . Q
+ . . D:%ut("ENT")]"" @%ut("ENT")
 "RTN","ut",150,0)
- ;
+ . . ;
 "RTN","ut",151,0)
- ; -- SHUTDOWN --
+ . . ; ENUM = Number of errors + failures
 "RTN","ut",152,0)
- ; 070224 - following code added to allow one overall SHUTDOWN code JLI
+ . . ; Only print out the success message [OK] If our error number remains
 "RTN","ut",153,0)
- N XTFINISH
+ . . ; the same as when we started the loop.
 "RTN","ut",154,0)
- S %ut("CURR")=0
+ . . I %utVERB,'$D(%utGUI) D
 "RTN","ut",155,0)
- F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D  I $G(XTFINISH)'="" D @XTFINISH Q
+ . . . I %ut("ENUM")=(%ut("ERRN")+%ut("FAIL")) D VERBOSE(.%utETRY,%utI,1) I 1
 "RTN","ut",156,0)
- . I $T(@("SHUTDOWN^"_%utROU(%ut("CURR"))))'="" S XTFINISH="SHUTDOWN^"_%utROU(%ut("CURR"))
+ . . . E  D VERBOSE(.%utETRY,%utI,0)
 "RTN","ut",157,0)
- . Q
+ . ;
 "RTN","ut",158,0)
- ; 070224 - End of addition JLI
+ . ;
 "RTN","ut",159,0)
- ; and output the results
+ . ; keep a %utCNT of number of entry points executed across all routines
 "RTN","ut",160,0)
- D SETIO
+ . S %ut("NENT")=%ut("NENT")+%ut("ENTN")
 "RTN","ut",161,0)
- W !!,"Ran ",%utLIST," Routine",$S(%utLIST>1:"s",1:""),", ",%ut("NENT")," Entry Tag",$S(%ut("NENT")>1:"s",1:"")
+ . Q
 "RTN","ut",162,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
+ ; -- SHUTDOWN --
 "RTN","ut",164,0)
- Q
+ D SETIO
 "RTN","ut",165,0)
- ; -- end EN1
+ W !!,"Ran ",%utLIST," Routine",$S(%utLIST>1:"s",1:""),", ",%ut("NENT")," Entry Tag",$S(%ut("NENT")>1:"s",1:"")
 "RTN","ut",166,0)
-VERBOSE(%utETRY,%utI,SUCCESS) ; Say whether we succeeded or failed.
+ 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",167,0)
- ; ZEXCEPT: %ut - NEWED IN EN
+ 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",168,0)
- D SETIO
+ D RESETIO
 "RTN","ut",169,0)
- N I F I=$X+3:1:73 W "-"
+ Q
 "RTN","ut",170,0)
- W ?73
+ ; -- end EN1
 "RTN","ut",171,0)
- I $G(SUCCESS) W "[OK]"
+VERBOSE(%utETRY,%utI,SUCCESS) ; Say whether we succeeded or failed.
 "RTN","ut",172,0)
- E  W "[FAIL]"
+ ; ZEXCEPT: %ut - NEWED IN EN
 "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)
+"RTN","ut",174,0)
+ N I F I=$X+3:1:73 W "-"
+"RTN","ut",175,0)
+ W ?73
+"RTN","ut",176,0)
+ I $G(SUCCESS) W "[OK]"
+"RTN","ut",177,0)
+ E  W "[FAIL]"
+"RTN","ut",178,0)
  D RESETIO
+"RTN","ut",179,0)
+ Q
+"RTN","ut",180,0)
+ ;
 "RTN","ut",181,0)
- Q
+VERBOSE1(%utETRY,%utI) ; Print out the entry point info
 "RTN","ut",182,0)
-CHKTF(XTSTVAL,XTERMSG) ; Entry point for checking True or False values
+ ; ZEXCEPT: %ut - NEWED IN EN
 "RTN","ut",183,0)
- ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
+ D SETIO
 "RTN","ut",184,0)
- ; ZEXCEPT: %ut - NEWED IN EN
+ W !,%utETRY(%utI) I $G(%utETRY(%utI,"NAME"))'="" W " - ",%utETRY(%utI,"NAME")
 "RTN","ut",185,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ D RESETIO
 "RTN","ut",186,0)
- I '$D(XTSTVAL) D NVLDARG Q
+ 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
+CHKTF(XTSTVAL,XTERMSG) ; Entry point for checking True or False values
 "RTN","ut",189,0)
- I '$D(%utGUI) D
-"RTN","ut",190,0)
- . D SETIO
-"RTN","ut",191,0)
- . I 'XTSTVAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " D
-"RTN","ut",192,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)
- . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-"RTN","ut",194,0)
- . . Q
-"RTN","ut",195,0)
- . I XTSTVAL W "."
-"RTN","ut",196,0)
- . D RESETIO
-"RTN","ut",197,0)
- . Q
-"RTN","ut",198,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)
- Q
-"RTN","ut",200,0)
- ;
-"RTN","ut",201,0)
-CHKEQ(XTEXPECT,XTACTUAL,XTERMSG) ; Entry point for checking values to see if they are EQUAL
-"RTN","ut",202,0)
- N FAILMSG
-"RTN","ut",203,0)
- ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
-"RTN","ut",204,0)
- ; ZEXCEPT: %ut  -- NEWED IN EN
-"RTN","ut",205,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)
- S XTACTUAL=$G(XTACTUAL),XTEXPECT=$G(XTEXPECT)
-"RTN","ut",208,0)
- I $G(XTERMSG)="" S XTERMSG="no failure message provided"
-"RTN","ut",209,0)
- S %ut("CHK")=%ut("CHK")+1
-"RTN","ut",210,0)
- I XTEXPECT'=XTACTUAL S FAILMSG="<"_XTEXPECT_"> vs <"_XTACTUAL_"> - "
-"RTN","ut",211,0)
- I '$D(%utGUI) D
-"RTN","ut",212,0)
- . D SETIO
-"RTN","ut",213,0)
- . I XTEXPECT'=XTACTUAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W FAILMSG,XTERMSG,! D
-"RTN","ut",214,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)
-     . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-"RTN","ut",216,0)
- . . Q
-"RTN","ut",217,0)
- . E  W "."
-"RTN","ut",218,0)
- . D RESETIO
-"RTN","ut",219,0)
- . Q
-"RTN","ut",220,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)
- Q
-"RTN","ut",222,0)
- ;
-"RTN","ut",223,0)
-FAIL(XTERMSG) ; Entry point for generating a failure message
-"RTN","ut",224,0)
- ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
-"RTN","ut",225,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"RTN","ut",226,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
-"RTN","ut",227,0)
- I $G(XTERMSG)="" S XTERMSG="no failure message provided"
-"RTN","ut",228,0)
- S %ut("CHK")=%ut("CHK")+1
-"RTN","ut",229,0)
- I '$D(%utGUI) D
-"RTN","ut",230,0)
- . D SETIO
-"RTN","ut",231,0)
- . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
-"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")
-"RTN","ut",233,0)
- . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-"RTN","ut",234,0)
- . . Q
-"RTN","ut",235,0)
- . D RESETIO
-"RTN","ut",236,0)
- . Q
-"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
-"RTN","ut",239,0)
-SUCCEED ; Entry point for forcing a success (Thx David Whitten)
-"RTN","ut",240,0)
  ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
-"RTN","ut",241,0)
+"RTN","ut",190,0)
  ; ZEXCEPT: %ut - NEWED IN EN
-"RTN","ut",242,0)
- ; Switch IO and write out the dot for activity
-"RTN","ut",243,0)
+"RTN","ut",191,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut",192,0)
+ I '$D(XTSTVAL) D NVLDARG Q
+"RTN","ut",193,0)
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+"RTN","ut",194,0)
+ S %ut("CHK")=$G(%ut("CHK"))+1
+"RTN","ut",195,0)
  I '$D(%utGUI) D
-"RTN","ut",244,0)
+"RTN","ut",196,0)
  . D SETIO
-"RTN","ut",245,0)
- . W "."
-"RTN","ut",246,0)
+"RTN","ut",197,0)
+ . I 'XTSTVAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " D
+"RTN","ut",198,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",199,0)
+ . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+"RTN","ut",200,0)
+ . . Q
+"RTN","ut",201,0)
+ . I XTSTVAL W "."
+"RTN","ut",202,0)
  . D RESETIO
-"RTN","ut",247,0)
+"RTN","ut",203,0)
+ . Q
+"RTN","ut",204,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",205,0)
+ Q
+"RTN","ut",206,0)
  ;
-"RTN","ut",248,0)
- ; Increment test counter
-"RTN","ut",249,0)
+"RTN","ut",207,0)
+CHKEQ(XTEXPECT,XTACTUAL,XTERMSG) ; Entry point for checking values to see if they are EQUAL
+"RTN","ut",208,0)
+ N FAILMSG
+"RTN","ut",209,0)
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+"RTN","ut",210,0)
+ ; ZEXCEPT: %ut  -- NEWED IN EN
+"RTN","ut",211,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut",212,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",213,0)
+ S XTACTUAL=$G(XTACTUAL),XTEXPECT=$G(XTEXPECT)
+"RTN","ut",214,0)
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+"RTN","ut",215,0)
  S %ut("CHK")=%ut("CHK")+1
+"RTN","ut",216,0)
+ I XTEXPECT'=XTACTUAL S FAILMSG="<"_XTEXPECT_"> vs <"_XTACTUAL_"> - "
+"RTN","ut",217,0)
+ I '$D(%utGUI) D
+"RTN","ut",218,0)
+ . D SETIO
+"RTN","ut",219,0)
+ . I XTEXPECT'=XTACTUAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W FAILMSG,XTERMSG,! D
+"RTN","ut",220,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",221,0)
+     . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+"RTN","ut",222,0)
+ . . Q
+"RTN","ut",223,0)
+ . E  W "."
+"RTN","ut",224,0)
+ . D RESETIO
+"RTN","ut",225,0)
+ . Q
+"RTN","ut",226,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",227,0)
+ Q
+"RTN","ut",228,0)
+ ;
+"RTN","ut",229,0)
+FAIL(XTERMSG) ; Entry point for generating a failure message
+"RTN","ut",230,0)
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+"RTN","ut",231,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",232,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut",233,0)
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+"RTN","ut",234,0)
+ S %ut("CHK")=%ut("CHK")+1
+"RTN","ut",235,0)
+ I '$D(%utGUI) D
+"RTN","ut",236,0)
+ . D SETIO
+"RTN","ut",237,0)
+ . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+"RTN","ut",238,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",239,0)
+ . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+"RTN","ut",240,0)
+ . . Q
+"RTN","ut",241,0)
+ . D RESETIO
+"RTN","ut",242,0)
+ . Q
+"RTN","ut",243,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",244,0)
+ Q
+"RTN","ut",245,0)
+ ;
+"RTN","ut",246,0)
+SUCCEED ; Entry point for forcing a success (Thx David Whitten)
+"RTN","ut",247,0)
+ ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
+"RTN","ut",248,0)
+ ; ZEXCEPT: %ut - NEWED IN EN
+"RTN","ut",249,0)
+ ; Switch IO and write out the dot for activity
 "RTN","ut",250,0)
- QUIT
+ I '$D(%utGUI) D
 "RTN","ut",251,0)
- ;
+ . D SETIO
 "RTN","ut",252,0)
-CHKLEAKS(%utCODE,%utLOC,%utINPT) ; functionality to check for variable leaks on executing a section of code
+ . W "."
 "RTN","ut",253,0)
- ; %utCODE - A string that specifies the code that is to be XECUTED and checked for leaks.
+ . D RESETIO
 "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
+ ; Increment test counter
 "RTN","ut",256,0)
- ; %utINPT - An optional variable which may be passed by reference.  This may
+ S %ut("CHK")=%ut("CHK")+1
 "RTN","ut",257,0)
- ;           be used to pass any variable values, etc. into the code to be
+ QUIT
 "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.
+CHKLEAKS(%utCODE,%utLOC,%utINPT) ; functionality to check for variable leaks on executing a section of code
 "RTN","ut",260,0)
- ;              e.g., (using NAME as my current namespace)
+ ; %utCODE - A string that specifies the code that is to be XECUTED and checked for leaks.
 "RTN","ut",261,0)
- ;                   S CODE="S %utINPT=$$ENTRY^ROUTINE(ZZVALUE1,ZZVALUE2)"
+ ;            this should be a complete piece of code (e.g., "S X=$$NOW^XLFDT()" or "D EN^%ut(""ROUNAME"")")
 "RTN","ut",262,0)
- ;                   S NAMELOC="ENTRY^ROUTINE leak test"   (or simply "ENTRY^ROUTINE")
+ ; %utLOC  - A string that is used to indicate the code tested for variable leaks
 "RTN","ut",263,0)
- ;                   S NAMEINPT("ZZVALUE1")=ZZVALUE1
+ ; %utINPT - An optional variable which may be passed by reference.  This may
 "RTN","ut",264,0)
- ;                   S NAMEINPT("ZZVALUE2")=ZZVALUE2
+ ;           be used to pass any variable values, etc. into the code to be
 "RTN","ut",265,0)
- ;                   D CHKLEAKS^%ut(CODE,NAMELOC,.NAMEINPT)
+ ;           XECUTED.  In this case, set the subscript to the variable name and the
 "RTN","ut",266,0)
- ;
+ ;           value of the subscripted variable to the desired value of the subscript.
 "RTN","ut",267,0)
- ;           If part of a unit test, any leaked variables in ENTRY^ROUTINE which result
+ ;              e.g., (using NAME as my current namespace)
 "RTN","ut",268,0)
- ;           from running the code with the variables indicated will be shown as FAILUREs.
+ ;                   S CODE="S %utINPT=$$ENTRY^ROUTINE(ZZVALUE1,ZZVALUE2)"
 "RTN","ut",269,0)
- ;
+ ;                   S NAMELOC="ENTRY^ROUTINE leak test"   (or simply "ENTRY^ROUTINE")
 "RTN","ut",270,0)
- ;           If called outside of a unit test, any leaked variables will be printed to the
+ ;                   S NAMEINPT("ZZVALUE1")=ZZVALUE1
 "RTN","ut",271,0)
- ;           current device.
+ ;                   S NAMEINPT("ZZVALUE2")=ZZVALUE2
 "RTN","ut",272,0)
- ;
+ ;                   D CHKLEAKS^%ut(CODE,NAMELOC,.NAMEINPT)
 "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
+ ;           If part of a unit test, any leaked variables in ENTRY^ROUTINE which result
 "RTN","ut",275,0)
- ; ZEXCEPT: %utVAR - handled by exclusive NEW
+ ;           from running the code with the variables indicated will be shown as FAILUREs.
 "RTN","ut",276,0)
  ;
 "RTN","ut",277,0)
- ; ACTIVATE ANY VARIABLES PASSED AS SUBSCRIPTS TO %utINPT TO THEIR VALUES
+ ;           If called outside of a unit test, any leaked variables will be printed to the
 "RTN","ut",278,0)
- S %utVAR=" " F  S %utVAR=$O(%utINPT(%utVAR)) Q:%utVAR=""  S (@%utVAR)=%utINPT(%utVAR)
+ ;           current device.
 "RTN","ut",279,0)
- X %utCODE
+ ;
 "RTN","ut",280,0)
- N ZZUTVAR S ZZUTVAR="%"
+ N (%utCODE,%utLOC,%utINPT,DUZ,IO,U,%utERRL,%ut,%utGUI,%utERR,%utI,%utJ,%utK,%utLIST,%utROU,%utSTRT,XTGUISEP)
 "RTN","ut",281,0)
- I $G(%ut)=1 D
+ ; ZEXCEPT: %ut - part of exclusive NEW TESTS FOR EXISTENCE ONLY
 "RTN","ut",282,0)
- . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) D FAIL^%ut(%utLOC_" VARIABLE LEAK: "_ZZUTVAR)
+ ; ZEXCEPT: %utVAR - handled by exclusive NEW
 "RTN","ut",283,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)
- . Q
+ ; ACTIVATE ANY VARIABLES PASSED AS SUBSCRIPTS TO %utINPT TO THEIR VALUES
 "RTN","ut",285,0)
- I '($G(%ut)=1) D
+ S %utVAR=" " F  S %utVAR=$O(%utINPT(%utVAR)) Q:%utVAR=""  S (@%utVAR)=%utINPT(%utVAR)
 "RTN","ut",286,0)
- . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) W !,%utLOC_" VARIABLE LEAK: "_ZZUTVAR
+ X %utCODE
 "RTN","ut",287,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
+ N ZZUTVAR S ZZUTVAR="%"
 "RTN","ut",288,0)
- . Q
+ I $G(%ut)=1 D
 "RTN","ut",289,0)
- Q
+ . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) D FAIL^%ut(%utLOC_" VARIABLE LEAK: "_ZZUTVAR)
 "RTN","ut",290,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",291,0)
-NVLDARG ; generate message for invalid arguments to test
+ . Q
 "RTN","ut",292,0)
- N XTERMSG
+ I '($G(%ut)=1) D
 "RTN","ut",293,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) W !,%utLOC_" VARIABLE LEAK: "_ZZUTVAR
 "RTN","ut",294,0)
- ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+ . 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",295,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ . Q
 "RTN","ut",296,0)
- S XTERMSG="NO VALUES INPUT TO CHKEQ^%ut - no evaluation possible"
+ Q
 "RTN","ut",297,0)
- I '$D(%utGUI) D
+ ;
 "RTN","ut",298,0)
- . D SETIO
+NVLDARG ; generate message for invalid arguments to test
 "RTN","ut",299,0)
- . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+ N XTERMSG
 "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")
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
 "RTN","ut",301,0)
- . . Q
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
 "RTN","ut",302,0)
- . D RESETIO
-"RTN","ut",303,0)
- . Q
-"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
-"RTN","ut",305,0)
- Q
-"RTN","ut",306,0)
- ;
-"RTN","ut",307,0)
-ERROR ; record errors
-"RTN","ut",308,0)
- ; ZEXCEPT: %utERRL,%utGUI,%utERR -CREATED IN SETUP, KILLED IN END
-"RTN","ut",309,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"RTN","ut",310,0)
  ; ZEXCEPT: XTGUISEP - newed in GUINEXT
-"RTN","ut",311,0)
- S %ut("CHK")=%ut("CHK")+1
-"RTN","ut",312,0)
- I '$D(%utGUI) D ERROR1
-"RTN","ut",313,0)
- I $D(%utGUI) D
-"RTN","ut",314,0)
- . S %ut("CNT")=%ut("CNT")+1
-"RTN","ut",315,0)
- . S %utERR=%utERR+1
-"RTN","ut",316,0)
- . S @%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"ERROR"_XTGUISEP_$S(+$SY=47:$ZS,1:$ZE)
-"RTN","ut",317,0)
- . Q
-"RTN","ut",318,0)
- S @($S(+$SY=47:"$ZS",1:"$ZE")_"="_""""""),$EC=""
-"RTN","ut",319,0)
- Q
-"RTN","ut",320,0)
- ;
-"RTN","ut",321,0)
-ERROR1 ;
-"RTN","ut",322,0)
- I $G(%ut("BREAK")) BREAK  ; if we are asked to break upon error, please do so!
-"RTN","ut",323,0)
- ; ZEXCEPT: %utERRL -CREATED IN SETUP, KILLED IN END
-"RTN","ut",324,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"RTN","ut",325,0)
- D SETIO
-"RTN","ut",326,0)
- W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - Error: " W $S(+$SY=47:$ZS,1:$ZE),! D
-"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")
-"RTN","ut",328,0)
- . Q
-"RTN","ut",329,0)
- D RESETIO
-"RTN","ut",330,0)
- Q
-"RTN","ut",331,0)
-SETIO ; Set M-Unit Device to write the results to...
-"RTN","ut",332,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"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",355,0)
-RUNSET(SETNAME,VERBOSE) ; .SR Run with Specified Selection of MUnit Test Group
-"RTN","ut",356,0)
- N Y,%utROU,%utLIST,%utVERB
-"RTN","ut",357,0)
- Q:$G(SETNAME)=""
-"RTN","ut",358,0)
- S %utVERB=$G(VERBOSE,0)
-"RTN","ut",359,0)
- S Y=+$$FIND1^DIC(17.9001,"","X",SETNAME) Q:Y'>0
-"RTN","ut",360,0)
- D GETSET(Y,.%utROU,.%utLIST)
-"RTN","ut",361,0)
- N Y,SETNAME,%ut
-"RTN","ut",362,0)
- D SETUT
-"RTN","ut",363,0)
- D EN1(.%utROU,%utLIST)
-"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)
- N %utROU,%utLIST,%ut
-"RTN","ut",386,0)
- D SETUT
-"RTN","ut",387,0)
- S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
-"RTN","ut",388,0)
- D GETSET(XTSET,.%utROU,.%utLIST)
-"RTN","ut",389,0)
- D GETLIST(.%utROU,%utLIST,%ut("RSLT"))
-"RTN","ut",390,0)
- S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
-"RTN","ut",391,0)
- S %utRSLT=%ut("RSLT")
-"RTN","ut",392,0)
- Q
-"RTN","ut",393,0)
- ;
-"RTN","ut",394,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)
- N %utROU,%ut
-"RTN","ut",396,0)
- D SETUT
-"RTN","ut",397,0)
- S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
-"RTN","ut",398,0)
- S %utROU(1)=%utROUN
-"RTN","ut",399,0)
- D GETLIST(.%utROU,1,%ut("RSLT"))
-"RTN","ut",400,0)
- S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
-"RTN","ut",401,0)
- S %utRSLT=%ut("RSLT")
-"RTN","ut",402,0)
- Q
-"RTN","ut",403,0)
- ;
-"RTN","ut",404,0)
-GETLIST(%utROU,%utLIST,%utRSLT) ; called from GUISET, GUILOAD
-"RTN","ut",405,0)
- N I,%utROUL,%utROUN,%ut,XTCOMNT,XTVALUE,%utCNT
-"RTN","ut",406,0)
- S XTVALUE=$NA(^TMP("GUI-MUNIT",$J)) K @XTVALUE
-"RTN","ut",407,0)
- S %utCNT=0,XTCOMNT=""
-"RTN","ut",408,0)
- D GETTREE^%ut1(.%utROU,%utLIST)
-"RTN","ut",409,0)
- F I=1:1 Q:'$D(%utROU(I))  S %utROUL(%utROU(I))=""
-"RTN","ut",410,0)
- S %utROUN="" F  S %utROUN=$O(%utROUL(%utROUN)) Q:%utROUN=""  D LOAD(%utROUN,.%utCNT,XTVALUE,XTCOMNT,.%utROUL)
-"RTN","ut",411,0)
- M @%utRSLT=@XTVALUE
-"RTN","ut",412,0)
- K @%utRSLT@("SHUTDOWN")
-"RTN","ut",413,0)
- K @%utRSLT@("STARTUP")
-"RTN","ut",414,0)
- S @XTVALUE@("LASTROU")="" ; Use this to keep track of place in routines
-"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)
- ; XTGUISEP - added 110719 to provide for changing separator for GUI
-"RTN","ut",436,0)
- ;            return from ^ to another value ~~^~~  so that data returned
-"RTN","ut",437,0)
- ;            is not affected by ^ values in the data - if not present
-"RTN","ut",438,0)
- ;            sets value to default ^
-"RTN","ut",439,0)
- N %utETRY,%utROUT,XTOLROU,XTVALUE,%utERR,%utGUI
-"RTN","ut",440,0)
- N %ut
-"RTN","ut",441,0)
- I $G(XTGUISEP)="" S XTGUISEP="^"
-"RTN","ut",442,0)
- D SETUT
-"RTN","ut",443,0)
- S %ut("LOC")=%utLOC
-"RTN","ut",444,0)
- S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
-"RTN","ut",445,0)
- S XTVALUE=$NA(^TMP("GUI-MUNIT",$J))
-"RTN","ut",446,0)
- S %ut("RSLT")=$NA(^TMP("GUINEXT",$J)) K @%ut("RSLT")
-"RTN","ut",447,0)
- S %utRSLT=%ut("RSLT")
-"RTN","ut",448,0)
- S %utETRY=$P(%utLOC,U),%utROUT=$P(%utLOC,U,2),XTOLROU=$G(@XTVALUE@("LASTROU"))
-"RTN","ut",449,0)
- S %utGUI=1
-"RTN","ut",450,0)
- S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
-"RTN","ut",451,0)
- ; I %utROUT'=XTOLROU D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ;140731 JLI - commented out
-"RTN","ut",452,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)
- . I XTOLROU="",$D(@XTVALUE@("STARTUP")) D
-"RTN","ut",455,0)
- . . S %ut("LOC")=@XTVALUE@("STARTUP")
-"RTN","ut",456,0)
- . . N $ETRAP S $ETRAP="D ERROR^%ut"
-"RTN","ut",457,0)
- . . D @(@XTVALUE@("STARTUP"))
-"RTN","ut",458,0)
+"RTN","ut",303,0)
+ S XTERMSG="NO VALUES INPUT TO CHKEQ^%ut - no evaluation possible"
+"RTN","ut",304,0)
+ I '$D(%utGUI) D
+"RTN","ut",305,0)
+ . D SETIO
+"RTN","ut",306,0)
+ . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+"RTN","ut",307,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",308,0)
  . . Q
+"RTN","ut",309,0)
+ . D RESETIO
+"RTN","ut",310,0)
+ . Q
+"RTN","ut",311,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",312,0)
+ Q
+"RTN","ut",313,0)
+ ;
+"RTN","ut",314,0)
+ERROR ; record errors
+"RTN","ut",315,0)
+ ; ZEXCEPT: %utERRL,%utGUI,%utERR -CREATED IN SETUP, KILLED IN END
+"RTN","ut",316,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",317,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut",318,0)
+ S %ut("CHK")=%ut("CHK")+1
+"RTN","ut",319,0)
+ I '$D(%utGUI) D ERROR1
+"RTN","ut",320,0)
+ I $D(%utGUI) D
+"RTN","ut",321,0)
+ . S %ut("CNT")=%ut("CNT")+1
+"RTN","ut",322,0)
+ . S %utERR=%utERR+1
+"RTN","ut",323,0)
+ . S @%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"ERROR"_XTGUISEP_$S(+$SY=47:$ZS,1:$ZE)
+"RTN","ut",324,0)
+ . Q
+"RTN","ut",325,0)
+ S @($S(+$SY=47:"$ZS",1:"$ZE")_"="_""""""),$EC=""
+"RTN","ut",326,0)
+ Q
+"RTN","ut",327,0)
+ ;
+"RTN","ut",328,0)
+ERROR1 ;
+"RTN","ut",329,0)
+ I $G(%ut("BREAK")) BREAK  ; if we are asked to break upon error, please do so!
+"RTN","ut",330,0)
+ ; ZEXCEPT: %utERRL -CREATED IN SETUP, KILLED IN END
+"RTN","ut",331,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",332,0)
+ D SETIO
+"RTN","ut",333,0)
+ W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - Error: " W $S(+$SY=47:$ZS,1:$ZE),! D
+"RTN","ut",334,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",335,0)
+ . Q
+"RTN","ut",336,0)
+ D RESETIO
+"RTN","ut",337,0)
+ Q
+"RTN","ut",338,0)
+SETIO ; Set M-Unit Device to write the results to...
+"RTN","ut",339,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",340,0)
+ I $IO'=%ut("IO") S (IO(0),%ut("DEV","OLD"))=$IO USE %ut("IO") SET IO=$IO
+"RTN","ut",341,0)
+ QUIT
+"RTN","ut",342,0)
+ ;
+"RTN","ut",343,0)
+RESETIO ; Reset $IO back to the original device if we changed it.
+"RTN","ut",344,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",345,0)
+ I $D(%ut("DEV","OLD")) S IO(0)=%ut("IO") U %ut("DEV","OLD") S IO=$IO K %ut("DEV","OLD")
+"RTN","ut",346,0)
+ QUIT
+"RTN","ut",347,0)
+ ;
+"RTN","ut",348,0)
+ISUTEST() ; .SUPPORTED API TO DETERMINE IF CURRENTLY IN UNIT TEST
+"RTN","ut",349,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",350,0)
+ Q $G(%ut)=1
+"RTN","ut",351,0)
+ ;
+"RTN","ut",352,0)
+PICKSET ; .OPT Interactive selection of MUnit Test Group
+"RTN","ut",353,0)
+ N DIC,Y,%utROU,%utLIST,DIR 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",354,0)
+ Q
+"RTN","ut",355,0)
+ ;
+"RTN","ut",356,0)
+RUNSET(SETNAME,VERBOSE) ; .SR Run with Specified Selection of MUnit Test Group
+"RTN","ut",357,0)
+ N Y,%utROU,%utLIST,%utVERB
+"RTN","ut",358,0)
+ Q:$G(SETNAME)=""
+"RTN","ut",359,0)
+ S %utVERB=$G(VERBOSE,0)
+"RTN","ut",360,0)
+ S Y=+$$FIND1^DIC(17.9001,"","X",SETNAME) Q:Y'>0
+"RTN","ut",361,0)
+ D GETSET(Y,.%utROU,.%utLIST)
+"RTN","ut",362,0)
+ N Y,SETNAME,%ut
+"RTN","ut",363,0)
+ D SETUT
+"RTN","ut",364,0)
+ D EN1(.%utROU,%utLIST)
+"RTN","ut",365,0)
+ Q
+"RTN","ut",366,0)
+ ;
+"RTN","ut",367,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",368,0)
+DOSET(IEN,%utVERB) ; 140731 JLI added %utVERB as a second argument
+"RTN","ut",369,0)
+ ; IEN - Internal entry number for selected set of tests in the MUNIT TEST GROUP file (#17.9001)
+"RTN","ut",370,0)
+ ; %utVERB - optional input that indicates verbose output is permitted
+"RTN","ut",371,0)
+ ;
+"RTN","ut",372,0)
+ N %utROU,%utLIST
+"RTN","ut",373,0)
+ I '$D(%utVERB) S %utVERB=0
+"RTN","ut",374,0)
+ S %utLIST=0
+"RTN","ut",375,0)
+ D GETSET($G(IEN),.%utROU,.%utLIST)
+"RTN","ut",376,0)
+ I %utLIST>0  N IEN,%ut D SETUT,EN1(.%utROU,%utLIST)
+"RTN","ut",377,0)
+ Q
+"RTN","ut",378,0)
+ ;
+"RTN","ut",379,0)
+GETSET(IEN,%utROU,%utLIST) ;  JLI 140731 - called from PICKSET, RUNSET, DOSET, GUISET
+"RTN","ut",380,0)
+ N IENS,%utROOT
+"RTN","ut",381,0)
+ S IENS=IEN_"," D GETS^DIQ(17.9001,IENS,"1*","","%utROOT")
+"RTN","ut",382,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",383,0)
+ Q
+"RTN","ut",384,0)
+ ;
+"RTN","ut",385,0)
+COV(NMSP,COVCODE,VERBOSITY) ; simply make it callable from %ut1 as well (along with other APIs) JLI 150101
+"RTN","ut",386,0)
+ D COV^%ut1(NMSP,COVCODE,+$G(VERBOSITY)) ; see COV^%ut1 for description of arguments
+"RTN","ut",387,0)
+ Q
+"RTN","ut",388,0)
+ ;
+"RTN","ut",389,0)
+GUISET(%utRSLT,XTSET) ; Entry point for GUI start with selected Test Set IEN - called by %ut-TEST GROUP LOAD rpc
+"RTN","ut",390,0)
+ N %utROU,%utLIST,%ut
+"RTN","ut",391,0)
+ D SETUT
+"RTN","ut",392,0)
+ S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
+"RTN","ut",393,0)
+ D GETSET(XTSET,.%utROU,.%utLIST)
+"RTN","ut",394,0)
+ D GETLIST(.%utROU,%utLIST,%ut("RSLT"))
+"RTN","ut",395,0)
+ S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
+"RTN","ut",396,0)
+ S %utRSLT=%ut("RSLT")
+"RTN","ut",397,0)
+ Q
+"RTN","ut",398,0)
+ ;
+"RTN","ut",399,0)
+GUILOAD(%utRSLT,%utROUN) ; Entry point for GUI start with %utROUN containing primary routine name - called by %ut-TEST LOAD rpc
+"RTN","ut",400,0)
+ N %utROU,%ut
+"RTN","ut",401,0)
+ D SETUT
+"RTN","ut",402,0)
+ S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
+"RTN","ut",403,0)
+ S %utROU(1)=%utROUN
+"RTN","ut",404,0)
+ D GETLIST(.%utROU,1,%ut("RSLT"))
+"RTN","ut",405,0)
+ S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
+"RTN","ut",406,0)
+ S %utRSLT=%ut("RSLT")
+"RTN","ut",407,0)
+ Q
+"RTN","ut",408,0)
+ ;
+"RTN","ut",409,0)
+GETLIST(%utROU,%utLIST,%utRSLT) ; called from GUISET, GUILOAD
+"RTN","ut",410,0)
+ N I,%utROUL,%utROUN,%ut,XTCOMNT,XTVALUE,%utCNT
+"RTN","ut",411,0)
+ S XTVALUE=$NA(^TMP("GUI-MUNIT",$J)) K @XTVALUE
+"RTN","ut",412,0)
+ S %utCNT=0,XTCOMNT=""
+"RTN","ut",413,0)
+ D GETTREE^%ut1(.%utROU,%utLIST)
+"RTN","ut",414,0)
+ F I=1:1 Q:'$D(%utROU(I))  S %utROUL(%utROU(I))=""
+"RTN","ut",415,0)
+ S %utROUN="" F  S %utROUN=$O(%utROUL(%utROUN)) Q:%utROUN=""  D LOAD(%utROUN,.%utCNT,XTVALUE,XTCOMNT,.%utROUL)
+"RTN","ut",416,0)
+ M @%utRSLT=@XTVALUE
+"RTN","ut",417,0)
+ K @%utRSLT@("SHUTDOWN")
+"RTN","ut",418,0)
+ K @%utRSLT@("STARTUP")
+"RTN","ut",419,0)
+ S @XTVALUE@("LASTROU")="" ; Use this to keep track of place in routines
+"RTN","ut",420,0)
+ Q
+"RTN","ut",421,0)
+ ;
+"RTN","ut",422,0)
+ ; generate list of unit test routines, entry points and comments on test for entry point
+"RTN","ut",423,0)
+LOAD(%utROUN,%utNCNT,XTVALUE,XTCOMNT,%utROUL) ; called from GETLIST, and recursively from LOAD
+"RTN","ut",424,0)
+ I $T(@("^"_%utROUN))="" S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_"^^*** ERROR - ROUTINE NAME NOT FOUND" Q
+"RTN","ut",425,0)
+ S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_U_XTCOMNT
+"RTN","ut",426,0)
+ ;N %utI,XTX1,XTX2,LINE
+"RTN","ut",427,0)
+ N %utI,XTX1,XTX2,LINE,LIST,I
+"RTN","ut",428,0)
+ ; 100622 JLI added code to identify STARTUP and TEARDOWN
+"RTN","ut",429,0)
+ I $T(@("STARTUP^"_%utROUN))'="",'$D(@XTVALUE@("STARTUP")) S @XTVALUE@("STARTUP")="STARTUP^"_%utROUN
+"RTN","ut",430,0)
+ I $T(@("SHUTDOWN^"_%utROUN))'="",'$D(@XTVALUE@("SHUTDOWN")) S @XTVALUE@("SHUTDOWN")="SHUTDOWN^"_%utROUN
+"RTN","ut",431,0)
+ ; JLI 140731 handle @TEST identified test tags
+"RTN","ut",432,0)
+ D NEWSTYLE^%ut1(.LIST,%utROUN)
+"RTN","ut",433,0)
+ F I=1:1:LIST S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_LIST(I)
+"RTN","ut",434,0)
+ ; JLI 140731 end of @TEST addition
+"RTN","ut",435,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",436,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",437,0)
+ Q
+"RTN","ut",438,0)
+ ;
+"RTN","ut",439,0)
+GUINEXT(%utRSLT,%utLOC,XTGUISEP) ; Entry point for GUI execute next test - called by %ut-TEST NEXT rpc
+"RTN","ut",440,0)
+ ; XTGUISEP - added 110719 to provide for changing separator for GUI
+"RTN","ut",441,0)
+ ;            return from ^ to another value ~~^~~  so that data returned
+"RTN","ut",442,0)
+ ;            is not affected by ^ values in the data - if not present
+"RTN","ut",443,0)
+ ;            sets value to default ^
+"RTN","ut",444,0)
+ N %utETRY,%utROUT,XTOLROU,XTVALUE,%utERR,%utGUI
+"RTN","ut",445,0)
+ N %ut
+"RTN","ut",446,0)
+ I $G(XTGUISEP)="" S XTGUISEP="^"
+"RTN","ut",447,0)
+ D SETUT
+"RTN","ut",448,0)
+ S %ut("LOC")=%utLOC
+"RTN","ut",449,0)
+ S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
+"RTN","ut",450,0)
+ S XTVALUE=$NA(^TMP("GUI-MUNIT",$J))
+"RTN","ut",451,0)
+ S %ut("RSLT")=$NA(^TMP("GUINEXT",$J)) K @%ut("RSLT")
+"RTN","ut",452,0)
+ S %utRSLT=%ut("RSLT")
+"RTN","ut",453,0)
+ S %utETRY=$P(%utLOC,U),%utROUT=$P(%utLOC,U,2),XTOLROU=$G(@XTVALUE@("LASTROU"))
+"RTN","ut",454,0)
+ S %utGUI=1
+"RTN","ut",455,0)
+ S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
+"RTN","ut",456,0)
+ ; I %utROUT'=XTOLROU D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ;140731 JLI - commented out
+"RTN","ut",457,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",458,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",459,0)
- . S @XTVALUE@("LASTROU")=%utROUT I %utROUT'="",$T(@("SETUP^"_%utROUT))'="" D
+ . I XTOLROU="",$D(@XTVALUE@("STARTUP")) D
 "RTN","ut",460,0)
- . . S %ut("LOC")="SETUP^"_%utROUT
+ . . S %ut("LOC")=@XTVALUE@("STARTUP")
 "RTN","ut",461,0)
  . . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",462,0)
- . . D @("SETUP^"_%utROUT)
+ . . D @(@XTVALUE@("STARTUP"))
 "RTN","ut",463,0)
  . . Q
 "RTN","ut",464,0)
- . I %utROUT="",$D(@XTVALUE@("SHUTDOWN")) D
+ . S @XTVALUE@("LASTROU")=%utROUT I %utROUT'="",$T(@("SETUP^"_%utROUT))'="" D
 "RTN","ut",465,0)
- . . S %ut("LOC")=@XTVALUE@("SHUTDOWN")
+ . . S %ut("LOC")="SETUP^"_%utROUT
 "RTN","ut",466,0)
  . . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",467,0)
- . . D @(@XTVALUE@("SHUTDOWN"))
+ . . D @("SETUP^"_%utROUT)
 "RTN","ut",468,0)
  . . Q
 "RTN","ut",469,0)
- . Q
+ . I %utROUT="",$D(@XTVALUE@("SHUTDOWN")) D
 "RTN","ut",470,0)
- S %ut("LOC")=%utLOC
+ . . S %ut("LOC")=@XTVALUE@("SHUTDOWN")
 "RTN","ut",471,0)
- S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
+ . . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",472,0)
- D  ; to limit range of error trap so we continue through other tests
+ . . D @(@XTVALUE@("SHUTDOWN"))
 "RTN","ut",473,0)
- . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . . Q
 "RTN","ut",474,0)
- . D @%ut("LOC")
-"RTN","ut",475,0)
  . Q
+"RTN","ut",475,0)
+ S %ut("LOC")=%utLOC
 "RTN","ut",476,0)
- I $T(@("TEARDOWN^"_%utROUT))'="" D
+ S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
 "RTN","ut",477,0)
- . S %ut("LOC")="TEARDOWN^"_%utROUT
+ D  ; to limit range of error trap so we continue through other tests
 "RTN","ut",478,0)
  . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",479,0)
- . D @("TEARDOWN^"_%utROUT)
+ . D @%ut("LOC")
 "RTN","ut",480,0)
  . Q
 "RTN","ut",481,0)
- S @%ut("RSLT")@(1)=%ut("CHK")_XTGUISEP_(%ut("CNT")-1-%utERR)_XTGUISEP_%utERR
+ I $T(@("TEARDOWN^"_%utROUT))'="" D
 "RTN","ut",482,0)
- Q
+ . S %ut("LOC")="TEARDOWN^"_%utROUT
 "RTN","ut",483,0)
- ;
+ . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",484,0)
-TESTCOVR ; entry under coverage analysis
+ . D @("TEARDOWN^"_%utROUT)
 "RTN","ut",485,0)
- D ENTRY^%uttcovr ; does analysis while running various unit tests
+ . Q
 "RTN","ut",486,0)
- Q
+ S @%ut("RSLT")@(1)=%ut("CHK")_XTGUISEP_(%ut("CNT")-1-%utERR)_XTGUISEP_%utERR
 "RTN","ut",487,0)
+ Q
+"RTN","ut",488,0)
  ;
 "RTN","ut1")
-0^2^B87092328
+0^2^B105832889
 "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 ; 7/2/15 10:45pm
 "RTN","ut1",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 4
 "RTN","ut1",3,0)
  ;
 "RTN","ut1",4,0)
@@ -1763,511 +1865,847 @@ TESTCOVR ; entry under coverage analysis
 "RTN","ut1",17,0)
  ;
 "RTN","ut1",18,0)
- Q
+ D ^%utt6 ; runs unit tests from several perspectives
 "RTN","ut1",19,0)
- ;
+ Q
 "RTN","ut1",20,0)
-CHEKTEST(%utROU,%ut,%utUETRY) ; Collect Test list.
+ ;
 "RTN","ut1",21,0)
- ; %utROU - input - Name of routine to check for tags with @TEST attribute
+CHEKTEST(%utROU,%ut,%utUETRY) ; Collect Test list.
 "RTN","ut1",22,0)
- ; %ut - input/output - passed by reference
+ ; %utROU - input - Name of routine to check for tags with @TEST attribute
 "RTN","ut1",23,0)
- ; %utUETRY - input/output - passed by reference
+ ; %ut - input/output - passed by reference
 "RTN","ut1",24,0)
- ;
+ ; %utUETRY - input/output - passed by reference
 "RTN","ut1",25,0)
- ; Test list collected in two ways:
+ ;
 "RTN","ut1",26,0)
- ; - @TEST on labellines
+ ; Test list collected in two ways:
 "RTN","ut1",27,0)
- ; - Offsets of XTENT
+ ; - @TEST on labellines
 "RTN","ut1",28,0)
- ;
+ ; - Offsets of XTENT
 "RTN","ut1",29,0)
- S %ut("ENTN")=0 ; Number of test, sub to %utUETRY.
+ ;
 "RTN","ut1",30,0)
- ;
+ S %ut("ENTN")=0 ; Number of test, sub to %utUETRY.
 "RTN","ut1",31,0)
- ; This stanza and everything below is for collecting @TEST.
-"RTN","ut1",32,0)
- ; VEN/SMH - block refactored to use $TEXT instead of ^%ZOSF("LOAD")
-"RTN","ut1",33,0)
- N I,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)
- 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",32,0)
+ ; This stanza and everything below is for collecting @TEST.
+"RTN","ut1",33,0)
+ ; VEN/SMH - block refactored to use $TEXT instead of ^%ZOSF("LOAD")
+"RTN","ut1",34,0)
+ N I,LIST
+"RTN","ut1",35,0)
+ S I=$L($T(@(U_%utROU))) I I<0 Q "-1^Invalid Routine Name"
+"RTN","ut1",36,0)
+ ; 140731 JLI - the following SMH code is replaced by the code below
+"RTN","ut1",37,0)
+ ; Complexity galore: $TEXT loops through routine
+"RTN","ut1",38,0)
+ ; IF tab or space isn't the first character ($C(9,32)) and line contains @TEST
+"RTN","ut1",39,0)
+ ; Load that line as a testing entry point
+"RTN","ut1",40,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",41,0)
+ ; . N TAGNAME,CHAR,NPAREN S TAGNAME="",NPAREN=0
+"RTN","ut1",42,0)
+ ; . F  Q:LINE=""  S CHAR=$E(LINE),LINE=$E(LINE,2,999) Q:CHAR=""  Q:" ("[CHAR  S TAGNAME=TAGNAME_CHAR
+"RTN","ut1",43,0)
+ ; . ; should be no paren or arguments
+"RTN","ut1",44,0)
+ ; . I CHAR="(" Q
+"RTN","ut1",45,0)
+ ; . F  Q:LINE=""  S CHAR=$E(LINE) Q:" ;"'[CHAR  S LINE=$E(LINE,2,999)
+"RTN","ut1",46,0)
+ ; . I $$UP($E(LINE,1,5))="@TEST" S LINE=$E(LINE,6,999) D
+"RTN","ut1",47,0)
+ ; . . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=TAGNAME
+"RTN","ut1",48,0)
+ ; . . F  Q:LINE=""  S CHAR=$E(LINE) Q:CHAR?1AN  S LINE=$E(LINE,2,999)
+"RTN","ut1",49,0)
+ ; . . S %utUETRY(%ut("ENTN"),"NAME")=LINE
+"RTN","ut1",50,0)
+ ; JLI 140731 - end of code replaced by following code
+"RTN","ut1",51,0)
+ ; JLI 140731 - the following code replaces the code above
+"RTN","ut1",52,0)
+ D NEWSTYLE(.LIST,%utROU)
+"RTN","ut1",53,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",54,0)
+ ; JLI 140731 - end of replacement code
 "RTN","ut1",55,0)
  ;
 "RTN","ut1",56,0)
- ; This Stanza is to collect XTENT offsets
+ ;
 "RTN","ut1",57,0)
- N %utUI F %utUI=1:1 S %ut("ELIN")=$T(@("XTENT+"_%utUI_"^"_%utROU)) Q:$P(%ut("ELIN"),";",3)=""  D
+ ; This Stanza is to collect XTENT offsets
 "RTN","ut1",58,0)
- . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=$P(%ut("ELIN"),";",3),%utUETRY(%ut("ENTN"),"NAME")=$P(%ut("ELIN"),";",4)
+ N %utUI F %utUI=1:1 S %ut("ELIN")=$T(@("XTENT+"_%utUI_"^"_%utROU)) Q:$P(%ut("ELIN"),";",3)=""  D
 "RTN","ut1",59,0)
- . Q
+ . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=$P(%ut("ELIN"),";",3),%utUETRY(%ut("ENTN"),"NAME")=$P(%ut("ELIN"),";",4)
 "RTN","ut1",60,0)
- ;
+ . Q
 "RTN","ut1",61,0)
- QUIT
+ ;
 "RTN","ut1",62,0)
- ;
+ QUIT
 "RTN","ut1",63,0)
- ; VEN/SMH 26JUL2013 - Moved GETTREE here.
+ ;
 "RTN","ut1",64,0)
-GETTREE(%utROU,%utULIST) ;
+ ; VEN/SMH 26JUL2013 - Moved GETTREE here.
 "RTN","ut1",65,0)
- ; first get any other routines this one references for running subsequently
+GETTREE(%utROU,%utULIST) ;
 "RTN","ut1",66,0)
- ; then any that they refer to as well
+ ; first get any other routines this one references for running subsequently
 "RTN","ut1",67,0)
- ; this builds a tree of all routines referred to by any routine including each only once
+ ; then any that they refer to as well
 "RTN","ut1",68,0)
- N %utUK,%utUI,%utUJ,%utURNAM,%utURLIN
+ ; this builds a tree of all routines referred to by any routine including each only once
 "RTN","ut1",69,0)
- F %utUK=1:1 Q:'$D(%utROU(%utUK))  D
+ N %utUK,%utUI,%utUJ,%utURNAM,%utURLIN
 "RTN","ut1",70,0)
- . F %utUI=1:1 S %utURLIN=$T(@("XTROU+"_%utUI_"^"_%utROU(%utUK))) S %utURNAM=$P(%utURLIN,";",3) Q:%utURNAM=""  D
+ F %utUK=1:1 Q:'$D(%utROU(%utUK))  D
 "RTN","ut1",71,0)
- . . F %utUJ=1:1:%utULIST I %utROU(%utUJ)=%utURNAM S %utURNAM="" Q
+ . F %utUI=1:1 S %utURLIN=$T(@("XTROU+"_%utUI_"^"_%utROU(%utUK))) S %utURNAM=$P(%utURLIN,";",3) Q:%utURNAM=""  D
 "RTN","ut1",72,0)
- . . I %utURNAM'="",$T(@("+1^"_%utURNAM))="" W:'$D(XWBOS) "Referenced routine ",%utURNAM," not found.",! Q
+ . . F %utUJ=1:1:%utULIST I %utROU(%utUJ)=%utURNAM S %utURNAM="" Q
 "RTN","ut1",73,0)
- . . S:%utURNAM'="" %utULIST=%utULIST+1,%utROU(%utULIST)=%utURNAM
+ . . I %utURNAM'="",$T(@("+1^"_%utURNAM))="" W:'$D(XWBOS) "Referenced routine ",%utURNAM," not found.",! Q
 "RTN","ut1",74,0)
- QUIT
+ . . S:%utURNAM'="" %utULIST=%utULIST+1,%utROU(%utULIST)=%utURNAM
 "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)
- K LIST S LIST=0
-"RTN","ut1",83,0)
- ; search routine by line for a tag and @TEST declaration
-"RTN","ut1",84,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)
- Q
-"RTN","ut1",86,0)
- ;
-"RTN","ut1",87,0)
-CHECKTAG(LINE) ; JLI 140726 check line to determine @test TAG
-"RTN","ut1",88,0)
- ; LINE - input - Line of code to be checked
-"RTN","ut1",89,0)
- ; returns null line if not @TEST line, otherwise TAG^NOTE
-"RTN","ut1",90,0)
- N TAG,NOTE,CHAR
-"RTN","ut1",91,0)
- I $E(LINE)=" " Q "" ; test entry must have a tag
-"RTN","ut1",92,0)
- I $$UP(LINE)'["@TEST" Q "" ; must have @TEST declaration
-"RTN","ut1",93,0)
- I $P($$UP(LINE),"@TEST")["(" Q "" ; can't have an argument
-"RTN","ut1",94,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)
- F  Q:NOTE=""  S CHAR=$E(NOTE),NOTE=$E(NOTE,2,$L(NOTE)) I " ;"'[CHAR Q  ;
-"RTN","ut1",96,0)
- I $L(NOTE)'=0 Q "" ; @TEST must be first text on line
-"RTN","ut1",97,0)
- F  Q:$E(LINE)'=" "  S LINE=$E(LINE,2,$L(LINE)) ; remove leading spaces from test info
-"RTN","ut1",98,0)
- S TAG=TAG_U_LINE
-"RTN","ut1",99,0)
- Q TAG
-"RTN","ut1",100,0)
- ;
-"RTN","ut1",101,0)
- ; VEN/SMH 17DEC2013 - Remove dependence on VISTA - Uppercase here instead of XLFSTR.
-"RTN","ut1",102,0)
-UP(X) ;
-"RTN","ut1",103,0)
- Q $TR(X,"abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ")
-"RTN","ut1",104,0)
- ;
-"RTN","ut1",105,0)
-COV(NMSP,COVCODE,VERBOSITY) ; VEN/SMH - PUBLIC ENTRY POINT; Coverage calculations
-"RTN","ut1",106,0)
- ; NMSP: Namespace of the routines to analyze. End with * to include all routines.
-"RTN","ut1",107,0)
- ;       Not using * will only include the routine with NMSP name.
-"RTN","ut1",108,0)
- ;       e.g. PSOM* will include all routines starting with PSOM
-"RTN","ut1",109,0)
- ;            PSOM will only include PSOM.
-"RTN","ut1",110,0)
- ; COVCODE: Mumps code to run over which coverage will be calculated. Typically Unit Tests.
-"RTN","ut1",111,0)
- ; VERBOSITY (optional): Scalar from -1 to 3.
-"RTN","ut1",112,0)
- ;    - -1 = Global output in ^TMP("%utCOVREPORT",$J)
-"RTN","ut1",113,0)
- ;    - 0 = Print only total coverage
-"RTN","ut1",114,0)
- ;    - 1 = Break down by routine
-"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.
-"RTN","ut1",117,0)
- ;
-"RTN","ut1",118,0)
- Q:'(+$SY=47)  ; GT.M only!
-"RTN","ut1",119,0)
- ;
-"RTN","ut1",120,0)
- ; ZEXCEPT: CTRAP - not really a variable
-"RTN","ut1",121,0)
- S VERBOSITY=+$G(VERBOSITY) ; Get 0 if not passed.
-"RTN","ut1",122,0)
- N %ZR ; GT.M specific
-"RTN","ut1",123,0)
- D SILENT^%RSEL(NMSP,"SRC") ; GT.M specific. On Cache use $O(^$R(RTN)).
-"RTN","ut1",124,0)
- ;
-"RTN","ut1",125,0)
- N RN S RN=""
-"RTN","ut1",126,0)
- W "Loading routines to test coverage...",!
-"RTN","ut1",127,0)
- F  S RN=$O(%ZR(RN)) Q:RN=""  W RN," " D
-"RTN","ut1",128,0)
- . N L2 S L2=$T(+2^@RN)
-"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
-"RTN","ut1",131,0)
- ;
-"RTN","ut1",132,0)
- N RTNS M RTNS=%ZR
-"RTN","ut1",133,0)
- K %ZR
-"RTN","ut1",134,0)
- ;
-"RTN","ut1",135,0)
- N GL
-"RTN","ut1",136,0)
- S GL=$NA(^TMP("%utCOVCOHORT",$J))
-"RTN","ut1",137,0)
- K @GL
-"RTN","ut1",138,0)
- D RTNANAL(.RTNS,GL)
-"RTN","ut1",139,0)
- K ^TMP("%utCOVCOHORTSAV",$J)
-"RTN","ut1",140,0)
- M ^TMP("%utCOVCOHORTSAV",$J)=^TMP("%utCOVCOHORT",$J)
-"RTN","ut1",141,0)
- ;
-"RTN","ut1",142,0)
- ;
-"RTN","ut1",143,0)
- K ^TMP("%utCOVRESULT",$J)
-"RTN","ut1",144,0)
- VIEW "TRACE":1:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M START PROFILING
-"RTN","ut1",145,0)
- DO  ; Run the code, but keep our variables to ourselves.
-"RTN","ut1",146,0)
- . NEW $ETRAP,$ESTACK
-"RTN","ut1",147,0)
- . SET $ETRAP="Q:($ES&$Q) -9 Q:$ES  W ""CTRL-C ENTERED"""
-"RTN","ut1",148,0)
- . USE $PRINCIPAL:(CTRAP=$C(3))
-"RTN","ut1",149,0)
- . NEW (DUZ,IO,COVCODE,U,DILOCKTM,DISYS,DT,DTIME,IOBS,IOF,IOM,ION,IOS,IOSL,IOST,IOT,IOXY)
-"RTN","ut1",150,0)
- . XECUTE COVCODE
-"RTN","ut1",151,0)
- VIEW "TRACE":0:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M STOP PROFILING
-"RTN","ut1",152,0)
- ;
-"RTN","ut1",153,0)
- D COVCOV($NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J))) ; Venn diagram matching between globals
-"RTN","ut1",154,0)
- ;
-"RTN","ut1",155,0)
- ; Report
-"RTN","ut1",156,0)
- I VERBOSITY=-1 D
-"RTN","ut1",157,0)
- . K ^TMP("%utCOVREPORT",$J)
-"RTN","ut1",158,0)
- . D COVRPTGL($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),$NA(^TMP("%utCOVREPORT",$J)))
-"RTN","ut1",159,0)
- E  D COVRPT($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),VERBOSITY)
-"RTN","ut1",160,0)
- ;
-"RTN","ut1",161,0)
  QUIT
-"RTN","ut1",162,0)
+"RTN","ut1",76,0)
  ;
+"RTN","ut1",77,0)
+NEWSTYLE(LIST,ROUNAME) ; JLI 140726 identify and return list of newstyle tags or entries for this routine
+"RTN","ut1",78,0)
+ ; LIST - input, passed by reference - returns containing array with list of tags identified as tests
+"RTN","ut1",79,0)
+ ;                   LIST indicates number of tags identified, LIST(n)=tag^test_info where tag is entry point for test
+"RTN","ut1",80,0)
+ ; ROUNAME - input - routine name in which tests should be identified
+"RTN","ut1",81,0)
+ ;
+"RTN","ut1",82,0)
+ N I,VALUE,LINE
+"RTN","ut1",83,0)
+ K LIST S LIST=0
+"RTN","ut1",84,0)
+ ; search routine by line for a tag and @TEST declaration
+"RTN","ut1",85,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",86,0)
+ Q
+"RTN","ut1",87,0)
+ ;
+"RTN","ut1",88,0)
+CHECKTAG(LINE) ; JLI 140726 check line to determine @test TAG
+"RTN","ut1",89,0)
+ ; LINE - input - Line of code to be checked
+"RTN","ut1",90,0)
+ ; returns null line if not @TEST line, otherwise TAG^NOTE
+"RTN","ut1",91,0)
+ N TAG,NOTE,CHAR
+"RTN","ut1",92,0)
+ I $E(LINE)=" " Q "" ; test entry must have a tag
+"RTN","ut1",93,0)
+ I $$UP(LINE)'["@TEST" Q "" ; must have @TEST declaration
+"RTN","ut1",94,0)
+ I $P($$UP(LINE),"@TEST")["(" Q "" ; can't have an argument
+"RTN","ut1",95,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",96,0)
+ F  Q:NOTE=""  S CHAR=$E(NOTE),NOTE=$E(NOTE,2,$L(NOTE)) I " ;"'[CHAR Q  ;
+"RTN","ut1",97,0)
+ I $L(NOTE)'=0 Q "" ; @TEST must be first text on line
+"RTN","ut1",98,0)
+ F  Q:$E(LINE)'=" "  S LINE=$E(LINE,2,$L(LINE)) ; remove leading spaces from test info
+"RTN","ut1",99,0)
+ S TAG=TAG_U_LINE
+"RTN","ut1",100,0)
+ Q TAG
+"RTN","ut1",101,0)
+ ;
+"RTN","ut1",102,0)
+ ; VEN/SMH 17DEC2013 - Remove dependence on VISTA - Uppercase here instead of XLFSTR.
+"RTN","ut1",103,0)
+UP(X) ;
+"RTN","ut1",104,0)
+ Q $TR(X,"abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+"RTN","ut1",105,0)
+ ;
+"RTN","ut1",106,0)
+COV(NMSP,COVCODE,VERBOSITY) ; VEN/SMH - PUBLIC ENTRY POINT; Coverage calculations
+"RTN","ut1",107,0)
+ ; NMSP: Namespace of the routines to analyze. End with * to include all routines.
+"RTN","ut1",108,0)
+ ;       Not using * will only include the routine with NMSP name.
+"RTN","ut1",109,0)
+ ;       e.g. PSOM* will include all routines starting with PSOM
+"RTN","ut1",110,0)
+ ;            PSOM will only include PSOM.
+"RTN","ut1",111,0)
+ ; COVCODE: Mumps code to run over which coverage will be calculated. Typically Unit Tests.
+"RTN","ut1",112,0)
+ ; VERBOSITY (optional): Scalar from -1 to 3.
+"RTN","ut1",113,0)
+ ;    - -1 = Global output in ^TMP("%utCOVREPORT",$J)
+"RTN","ut1",114,0)
+ ;    - 0 = Print only total coverage
+"RTN","ut1",115,0)
+ ;    - 1 = Break down by routine
+"RTN","ut1",116,0)
+ ;    - 2 = Break down by routine and tag
+"RTN","ut1",117,0)
+ ;    - 3 = Break down by routine and tag, and print lines that didn't execute for each tag.
+"RTN","ut1",118,0)
+ ;
+"RTN","ut1",119,0)
+ ; ZEXCEPT: %utcovxx - SET and KILLED in this code at top level
+"RTN","ut1",120,0)
+ Q:'(+$SY=47)  ; GT.M only!
+"RTN","ut1",121,0)
+ ;
+"RTN","ut1",122,0)
+ ; ZEXCEPT: CTRAP - not really a variable
+"RTN","ut1",123,0)
+ S VERBOSITY=+$G(VERBOSITY) ; Get 0 if not passed.
+"RTN","ut1",124,0)
+ N %ZR ; GT.M specific
+"RTN","ut1",125,0)
+ D SILENT^%RSEL(NMSP,"SRC") ; GT.M specific. On Cache use $O(^$R(RTN)).
+"RTN","ut1",126,0)
+ ;
+"RTN","ut1",127,0)
+ N RN S RN=""
+"RTN","ut1",128,0)
+ W !,"Loading routines to test coverage...",!
+"RTN","ut1",129,0)
+ F  S RN=$O(%ZR(RN)) Q:RN=""  W RN," " D
+"RTN","ut1",130,0)
+ . N L2 S L2=$T(+2^@RN)
+"RTN","ut1",131,0)
+ . S L2=$TR(L2,$C(9,32)) ; Translate spaces and tabs out
+"RTN","ut1",132,0)
+ . I $E(L2,1,2)'=";;" K %ZR(RN)  ; Not a human produced routine
+"RTN","ut1",133,0)
+ ;
+"RTN","ut1",134,0)
+ N RTNS M RTNS=%ZR
+"RTN","ut1",135,0)
+ K %ZR
+"RTN","ut1",136,0)
+ ;
+"RTN","ut1",137,0)
+ N GL
+"RTN","ut1",138,0)
+ S GL=$NA(^TMP("%utCOVCOHORT",$J))
+"RTN","ut1",139,0)
+ I '$D(^TMP("%utcovrunning",$J)) K @GL
+"RTN","ut1",140,0)
+ D RTNANAL(.RTNS,GL)
+"RTN","ut1",141,0)
+ I '$D(^TMP("%utcovrunning",$J)) D
+"RTN","ut1",142,0)
+ . K ^TMP("%utCOVCOHORTSAV",$J)
+"RTN","ut1",143,0)
+ . M ^TMP("%utCOVCOHORTSAV",$J)=^TMP("%utCOVCOHORT",$J)
+"RTN","ut1",144,0)
+ . K ^TMP("%utCOVRESULT",$J)
+"RTN","ut1",145,0)
+ . S ^TMP("%utcovrunning",$J)=1,%utcovxx=1
+"RTN","ut1",146,0)
+ . VIEW "TRACE":1:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M START PROFILING
+"RTN","ut1",147,0)
+ . Q
+"RTN","ut1",148,0)
+ DO  ; Run the code, but keep our variables to ourselves.
+"RTN","ut1",149,0)
+ . NEW $ETRAP,$ESTACK
+"RTN","ut1",150,0)
+ . SET $ETRAP="Q:($ES&$Q) -9 Q:$ES  W ""CTRL-C ENTERED"""
+"RTN","ut1",151,0)
+ . USE $PRINCIPAL:(CTRAP=$C(3))
+"RTN","ut1",152,0)
+ . NEW (DUZ,IO,COVCODE,U,DILOCKTM,DISYS,DT,DTIME,IOBS,IOF,IOM,ION,IOS,IOSL,IOST,IOT,IOXY)
+"RTN","ut1",153,0)
+ . XECUTE COVCODE
+"RTN","ut1",154,0)
+ . Q
+"RTN","ut1",155,0)
+ ; GT.M STOP PROFILING if this is the original level that started it
+"RTN","ut1",156,0)
+ I $D(^TMP("%utcovrunning",$J)),$D(%utcovxx) VIEW "TRACE":0:$NA(^TMP("%utCOVRESULT",$J)) K %utcovxx,^TMP("%utcovrunning",$J)
+"RTN","ut1",157,0)
+ ;
+"RTN","ut1",158,0)
+ I '$D(^TMP("%utcovrunning",$J)) D
+"RTN","ut1",159,0)
+ . D COVCOV($NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J))) ; Venn diagram matching between globals
+"RTN","ut1",160,0)
+ . ; Report
+"RTN","ut1",161,0)
+ . I VERBOSITY=-1 D
+"RTN","ut1",162,0)
+ . . K ^TMP("%utCOVREPORT",$J)
 "RTN","ut1",163,0)
-RTNANAL(RTNS,GL) ; [Private] - Routine Analysis
+ . . D COVRPTGL($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),$NA(^TMP("%utCOVREPORT",$J)))
 "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.
+ . E  D COVRPT($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),VERBOSITY)
 "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).
+ . Q
 "RTN","ut1",167,0)
- ; tags by themselves don't count toward the total.
+ QUIT
 "RTN","ut1",168,0)
  ;
 "RTN","ut1",169,0)
- N RTN S RTN=""
+RTNANAL(RTNS,GL) ; [Private] - Routine Analysis
 "RTN","ut1",170,0)
- F  S RTN=$O(RTNS(RTN)) Q:RTN=""  D                       ; for each routine
+ ; Create a global similar to the trace global produced by GT.M in GL
 "RTN","ut1",171,0)
- . N TAG
+ ; Only non-comment lines are stored.
 "RTN","ut1",172,0)
- . S TAG=RTN                                              ; start the tags at the first
+ ; 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",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)
+ ; tags by themselves don't count toward the total.
 "RTN","ut1",174,0)
- . . I $E(LN)?1A D  QUIT                                  ; formal line
+ ;
 "RTN","ut1",175,0)
- . . . N T                                                ; Terminator
+ N RTN S RTN=""
 "RTN","ut1",176,0)
- . . . N J F J=1:1:$L(LN) S T=$E(LN,J) Q:T'?1AN           ; Loop to...
+ F  S RTN=$O(RTNS(RTN)) Q:RTN=""  D                       ; for each routine
 "RTN","ut1",177,0)
- . . . S TAG=$E(LN,1,J-1)                                 ; Get tag
+ . N TAG
 "RTN","ut1",178,0)
- . . . S @GL@(RTN,TAG)=TAG                                ; store line
+ . S TAG=RTN                                              ; start the tags at the first
 "RTN","ut1",179,0)
- . . . I T="(" S @GL@(RTN,TAG,0)=LN                       ; formal list
+ . 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",180,0)
- . . . E  D                                               ; No formal list
+ . . I $E(LN)?1A D  QUIT                                  ; formal line
 "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
+ . . . N T                                                ; Terminator
 "RTN","ut1",182,0)
- . . . . I $E(LNTR)=";" QUIT                              ; Comment
+ . . . N J F J=1:1:$L(LN) S T=$E(LN,J) Q:T'?1AN           ; Loop to...
 "RTN","ut1",183,0)
- . . . . S @GL@(RTN,TAG,0)=LN                             ; Otherwise, store for testing
+ . . . S TAG=$E(LN,1,J-1)                                 ; Get tag
 "RTN","ut1",184,0)
- . . . S I=0                                              ; Start offsets from zero (first one at the for will be 1)
+ . . . S @GL@(RTN,TAG)=TAG                                ; store line
 "RTN","ut1",185,0)
- . . I $C(32,9)[$E(LN) D  QUIT                            ; Regular line
+ . . . I T="(" S @GL@(RTN,TAG,0)=LN                       ; formal list
 "RTN","ut1",186,0)
- . . . N LNTR S LNTR=$TR(LN,$C(32,9))                     ; Remove all spaces and tabs
+ . . . E  D                                               ; No formal list
 "RTN","ut1",187,0)
- . . . I $E(LNTR)=";" QUIT                                ; Comment line -- don't want.
+ . . . . 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",188,0)
- . . . S @GL@(RTN,TAG,I)=LN                               ; Record line
+ . . . . I $E(LNTR)=";" QUIT                              ; Comment
 "RTN","ut1",189,0)
- QUIT
+ . . . . S @GL@(RTN,TAG,0)=LN                             ; Otherwise, store for testing
 "RTN","ut1",190,0)
- ;
+ . . . S I=0                                              ; Start offsets from zero (first one at the for will be 1)
 "RTN","ut1",191,0)
-ACTLINES(GL) ; [Private] $$ ; Count active lines
+ . . I $C(32,9)[$E(LN) D  QUIT                            ; Regular line
 "RTN","ut1",192,0)
- ;
+ . . . N LNTR S LNTR=$TR(LN,$C(32,9,46))                     ; Remove all spaces and tabs - JLI 150202 remove periods as well
 "RTN","ut1",193,0)
- N CNT S CNT=0
+ . . . I $E(LNTR)=";" QUIT                                ; Comment line -- don't want.
 "RTN","ut1",194,0)
- N REF S REF=GL
+ . . . S @GL@(RTN,TAG,I)=LN                               ; Record line
 "RTN","ut1",195,0)
- N GLQL S GLQL=$QL(GL)
+ QUIT
 "RTN","ut1",196,0)
- F  S REF=$Q(@REF) Q:REF=""  Q:(GL'=$NA(@REF,GLQL))  D
+ ;
 "RTN","ut1",197,0)
- . N REFQL S REFQL=$QL(REF)
+ACTLINES(GL) ; [Private] $$ ; Count active lines
 "RTN","ut1",198,0)
- . N LASTSUB S LASTSUB=$QS(REF,REFQL)
+ ;
 "RTN","ut1",199,0)
- . I LASTSUB?1.N S CNT=CNT+1
+ N CNT S CNT=0
 "RTN","ut1",200,0)
- QUIT CNT
+ N REF S REF=GL
 "RTN","ut1",201,0)
- ;
+ N GLQL S GLQL=$QL(GL)
 "RTN","ut1",202,0)
-COVCOV(C,R) ; [Private] - Analyze coverage Cohort vs Result
+ F  S REF=$Q(@REF) Q:REF=""  Q:(GL'=$NA(@REF,GLQL))  D
 "RTN","ut1",203,0)
- N RTN S RTN=""
+ . N REFQL S REFQL=$QL(REF)
 "RTN","ut1",204,0)
- F  S RTN=$O(@C@(RTN)) Q:RTN=""  D  ; For each routine in cohort set
+ . N LASTSUB S LASTSUB=$QS(REF,REFQL)
 "RTN","ut1",205,0)
- . I '$D(@R@(RTN)) QUIT             ; Not present in result set
+ . I LASTSUB?1.N S CNT=CNT+1
 "RTN","ut1",206,0)
- . N TAG S TAG=""
+ QUIT CNT
 "RTN","ut1",207,0)
- . F  S TAG=$O(@R@(RTN,TAG)) Q:TAG=""  D  ; For each tag in the routine in the result set
+ ;
 "RTN","ut1",208,0)
- . . N LN S LN=""
+COVCOV(C,R) ; [Private] - Analyze coverage Cohort vs Result
 "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
-"RTN","ut1",210,0)
- . . . I $D(@C@(RTN,TAG,LN)) K ^(LN)  ; if present in cohort, kill off
-"RTN","ut1",211,0)
- QUIT
-"RTN","ut1",212,0)
- ;
-"RTN","ut1",213,0)
-COVRPT(C,S,R,V) ; [Private] - Coverage Report
-"RTN","ut1",214,0)
- ; C = COHORT    - Global name
-"RTN","ut1",215,0)
- ; S = SURVIVORS - Global name
-"RTN","ut1",216,0)
- ; R = RESULT    - Global name
-"RTN","ut1",217,0)
- ; V = Verbosity - Scalar from -1 to 3
-"RTN","ut1",218,0)
- N ORIGLINES S ORIGLINES=$$ACTLINES(C)
-"RTN","ut1",219,0)
- N LEFTLINES S LEFTLINES=$$ACTLINES(S)
-"RTN","ut1",220,0)
- W !!
-"RTN","ut1",221,0)
- W "ORIG: "_ORIGLINES,!
-"RTN","ut1",222,0)
- W "LEFT: "_LEFTLINES,!
-"RTN","ut1",223,0)
- W "COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00),!
-"RTN","ut1",224,0)
- W !!
-"RTN","ut1",225,0)
- W "BY ROUTINE:",!
-"RTN","ut1",226,0)
- I V=0 QUIT  ; No verbosity. Don't print routine detail
-"RTN","ut1",227,0)
  N RTN S RTN=""
-"RTN","ut1",228,0)
- F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
-"RTN","ut1",229,0)
- . N O S O=$$ACTLINES($NA(@C@(RTN)))
-"RTN","ut1",230,0)
- . N L S L=$$ACTLINES($NA(@S@(RTN)))
-"RTN","ut1",231,0)
- . W ?3,RTN,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
-"RTN","ut1",232,0)
- . I V=1 QUIT  ; Just print the routine coverage for V=1
-"RTN","ut1",233,0)
+"RTN","ut1",210,0)
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D  ; For each routine in cohort set
+"RTN","ut1",211,0)
+ . I '$D(@R@(RTN)) QUIT             ; Not present in result set
+"RTN","ut1",212,0)
  . N TAG S TAG=""
-"RTN","ut1",234,0)
- . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
-"RTN","ut1",235,0)
- . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
-"RTN","ut1",236,0)
- . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
-"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
-"RTN","ut1",239,0)
+"RTN","ut1",213,0)
+ . F  S TAG=$O(@R@(RTN,TAG)) Q:TAG=""  D  ; For each tag in the routine in the result set
+"RTN","ut1",214,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)
+"RTN","ut1",215,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",216,0)
+ . . . I $D(@C@(RTN,TAG,LN)) K ^(LN)  ; if present in cohort, kill off
+"RTN","ut1",217,0)
  QUIT
-"RTN","ut1",242,0)
+"RTN","ut1",218,0)
  ;
-"RTN","ut1",243,0)
-COVRPTGL(C,S,R,OUT) ; [Private] - Coverage Global for silent invokers
-"RTN","ut1",244,0)
+"RTN","ut1",219,0)
+COVRPT(C,S,R,V) ; [Private] - Coverage Report
+"RTN","ut1",220,0)
  ; C = COHORT    - Global name
-"RTN","ut1",245,0)
+"RTN","ut1",221,0)
  ; S = SURVIVORS - Global name
-"RTN","ut1",246,0)
+"RTN","ut1",222,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)
+"RTN","ut1",223,0)
+ ; V = Verbosity - Scalar from -1 to 3
+"RTN","ut1",224,0)
+ ; JLI 150702 -  modified to be able to do unit tests on setting up the text via COVRPTLS
+"RTN","ut1",225,0)
+ N X
+"RTN","ut1",226,0)
+ S X=$NA(^TMP("%ut1-covrpt",$J)) K @X
+"RTN","ut1",227,0)
+ D COVRPTLS(C,S,R,V,X)
+"RTN","ut1",228,0)
+ F I=1:1 Q:'$D(@X@(I))  W !,@X@(I)
+"RTN","ut1",229,0)
+ K @X
+"RTN","ut1",230,0)
  Q
-"RTN","ut1",267,0)
+"RTN","ut1",231,0)
  ;
+"RTN","ut1",232,0)
+COVRPTLS(C,S,R,V,X) ;
+"RTN","ut1",233,0)
+ ;
+"RTN","ut1",234,0)
+ N LINNUM S LINNUM=0
+"RTN","ut1",235,0)
+ N ORIGLINES S ORIGLINES=$$ACTLINES(C)
+"RTN","ut1",236,0)
+ N LEFTLINES S LEFTLINES=$$ACTLINES(S)
+"RTN","ut1",237,0)
+ ;W !!
+"RTN","ut1",238,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="",LINNUM=LINNUM+1,@X@(LINNUM)=""
+"RTN","ut1",239,0)
+ ;W "ORIG: "_ORIGLINES,!
+"RTN","ut1",240,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="ORIG: "_ORIGLINES
+"RTN","ut1",241,0)
+ ;W "LEFT: "_LEFTLINES,!
+"RTN","ut1",242,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="LEFT: "_LEFTLINES
+"RTN","ut1",243,0)
+ ;W "COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00),!
+"RTN","ut1",244,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00)
+"RTN","ut1",245,0)
+ ;W !!
+"RTN","ut1",246,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="",LINNUM=LINNUM+1,@X@(LINNUM)=""
+"RTN","ut1",247,0)
+ ;W "BY ROUTINE:",!
+"RTN","ut1",248,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="BY ROUTINE:"
+"RTN","ut1",249,0)
+ I V=0 QUIT  ; No verbosity. Don't print routine detail
+"RTN","ut1",250,0)
+ N RTN S RTN=""
+"RTN","ut1",251,0)
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
+"RTN","ut1",252,0)
+ . N O S O=$$ACTLINES($NA(@C@(RTN)))
+"RTN","ut1",253,0)
+ . N L S L=$$ACTLINES($NA(@S@(RTN)))
+"RTN","ut1",254,0)
+ . ;W ?3,RTN,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+"RTN","ut1",255,0)
+ . N XX S XX="  "_RTN_"                    ",XX=$E(XX,1,20)
+"RTN","ut1",256,0)
+ . S LINNUM=LINNUM+1,@X@(LINNUM)=XX+$S(O:$J(O-L/O*100,"",2),1:"100.00")
+"RTN","ut1",257,0)
+ . I V=1 QUIT  ; Just print the routine coverage for V=1
+"RTN","ut1",258,0)
+ . N TAG S TAG=""
+"RTN","ut1",259,0)
+ . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
+"RTN","ut1",260,0)
+ . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
+"RTN","ut1",261,0)
+ . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
+"RTN","ut1",262,0)
+ . . ;W ?5,TAG,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+"RTN","ut1",263,0)
+ . . S XX="    "_TAG_"                  ",XX=$E(XX,1,20)
+"RTN","ut1",264,0)
+ . . S LINNUM=LINNUM+1,@X@(LINNUM)=XX_$S(O:$J(O-L/O*100,"",2),1:"100.00")
+"RTN","ut1",265,0)
+ . . I V=2 QUIT  ; Just print routine/tags coverage for V=2; V=3 print uncovered lines
+"RTN","ut1",266,0)
+ . . N LN S LN=""
+"RTN","ut1",267,0)
+ . . ;F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  W TAG_"+"_LN_": "_^(LN),!
+"RTN","ut1",268,0)
+ . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  S LINNUM=LINNUM+1,@X@(LINNUM)=TAG_"+"_LN_": "_^(LN)
+"RTN","ut1",269,0)
+ . . Q
+"RTN","ut1",270,0)
+ . Q
+"RTN","ut1",271,0)
+ QUIT
+"RTN","ut1",272,0)
+ ;
+"RTN","ut1",273,0)
+COVRPTGL(C,S,R,OUT) ; [Private] - Coverage Global for silent invokers
+"RTN","ut1",274,0)
+ ; C = COHORT    - Global name
+"RTN","ut1",275,0)
+ ; S = SURVIVORS - Global name
+"RTN","ut1",276,0)
+ ; R = RESULT    - Global name
+"RTN","ut1",277,0)
+ ; OUT = OUTPUT  - Global name
+"RTN","ut1",278,0)
+ ;
+"RTN","ut1",279,0)
+ N O S O=$$ACTLINES(C)
+"RTN","ut1",280,0)
+ N L S L=$$ACTLINES(S)
+"RTN","ut1",281,0)
+ S @OUT=(O-L)_"/"_O
+"RTN","ut1",282,0)
+ N RTN,TAG,LN S (RTN,TAG,LN)=""
+"RTN","ut1",283,0)
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
+"RTN","ut1",284,0)
+ . N O S O=$$ACTLINES($NA(@C@(RTN)))
+"RTN","ut1",285,0)
+ . N L S L=$$ACTLINES($NA(@S@(RTN)))
+"RTN","ut1",286,0)
+ . S @OUT@(RTN)=(O-L)_"/"_O
+"RTN","ut1",287,0)
+ . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
+"RTN","ut1",288,0)
+ . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
+"RTN","ut1",289,0)
+ . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
+"RTN","ut1",290,0)
+ . . S @OUT@(RTN,TAG)=(O-L)_"/"_O
+"RTN","ut1",291,0)
+ . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  S @OUT@(RTN,TAG,LN)=@S@(RTN,TAG,LN)
+"RTN","ut1",292,0)
+ QUIT
+"RTN","ut1",293,0)
+ ;
+"RTN","utcover")
+0^10^B63651128
+"RTN","utcover",1,0)
+%utcover        ;JLI - generic coverage and unit test runner ; 7/3/15 2:54am
+"RTN","utcover",2,0)
+ ;;0.1;MASH UTILITIES;;;Build 4
+"RTN","utcover",3,0)
+        ;
+"RTN","utcover",4,0)
+        Q
+"RTN","utcover",5,0)
+        ;
+"RTN","utcover",6,0)
+TESTONLY(TESTROUS)      ; RUN TESTS FOR SPECIFIED ROUTINES
+"RTN","utcover",7,0)
+        ; input TESTROUS - passed by reference - array of routine names to run tests for
+"RTN","utcover",8,0)
+        ;               specify those to be called directly by including ^ as part of
+"RTN","utcover",9,0)
+        ;               TAG^ROUTINE or ^ROUTINE.
+"RTN","utcover",10,0)
+        ;               ROUTINE names without a ^ will be called as EN^%ut("ROUTINE")
+"RTN","utcover",11,0)
+        ;               Sometimes to get complete coverage, different entry points may
+"RTN","utcover",12,0)
+        ;               need to be called (e.g., at top and for VERBOSE), these should each
+"RTN","utcover",13,0)
+        ;               be included.
+"RTN","utcover",14,0)
+        ;               If the subscript is a number, it will take the list of comma separated
+"RTN","utcover",15,0)
+        ;               values as the routines.  If the the subscript is not a number, it will
+"RTN","utcover",16,0)
+        ;               take it as a routine to be added to the list, then if the value of the
+"RTN","utcover",17,0)
+        ;               contains a comma separated list of routines, they will be added as well.
+"RTN","utcover",18,0)
+        ;               Thus a value of
+"RTN","utcover",19,0)
+        ;                 TESTROUS(1)="A^ROU1,^ROU1,^ROU2,ROU3"
+"RTN","utcover",20,0)
+        ;               or a value of
+"RTN","utcover",21,0)
+        ;                 TESTROUS("A^ROU1")="^ROU1,^ROU2,ROU3"
+"RTN","utcover",22,0)
+        ;               will both result in tests for
+"RTN","utcover",23,0)
+        ;                 D A^ROU1,^ROU1,^ROU2,EN^%ut("ROU3")
+"RTN","utcover",24,0)
+        K ^TMP("%utCOVER",$J,"TESTROUS")
+"RTN","utcover",25,0)
+        M ^TMP("%utCOVER",$J,"TESTROUS")=TESTROUS
+"RTN","utcover",26,0)
+        ;
+"RTN","utcover",27,0)
+COVENTRY        ; setup of COVERAGE NEWs most variables, so TESTROUS passed by global
+"RTN","utcover",28,0)
+        ;
+"RTN","utcover",29,0)
+        N I,ROU,VAL,VALS,UTDATA,TESTS,TESTROUS
+"RTN","utcover",30,0)
+        M TESTROUS=^TMP("%utCOVER",$J,"TESTROUS")
+"RTN","utcover",31,0)
+        S ROU="" F  S ROU=$O(TESTROUS(ROU)) Q:ROU=""  D
+"RTN","utcover",32,0)
+        . I ROU'=+ROU S TESTS(ROU)=""
+"RTN","utcover",33,0)
+        . F I=1:1 S VAL=$P(TESTROUS(ROU),",",I) Q:VAL=""  S TESTS(VAL)=""
+"RTN","utcover",34,0)
+        . Q
+"RTN","utcover",35,0)
+        S ROU="" F  S ROU=$O(TESTS(ROU)) Q:ROU=""  D
+"RTN","utcover",36,0)
+        . W !!,"RUNNING ",ROU
+"RTN","utcover",37,0)
+        . I ROU[U D @ROU
+"RTN","utcover",38,0)
+        . I ROU'[U D @("EN^%ut("""_ROU_""")")
+"RTN","utcover",39,0)
+        . S VALS=$G(^TMP("%ut",$J,"UTVALS")) I VALS="" Q
+"RTN","utcover",40,0)
+        . F I=1:1 S VAL=$P(VALS,U,I) Q:VAL=""  S UTDATA(I)=$G(UTDATA(I))+VAL
+"RTN","utcover",41,0)
+        . K ^TMP("%ut",$J)
+"RTN","utcover",42,0)
+        . Q
+"RTN","utcover",43,0)
+        I $D(UTDATA) D
+"RTN","utcover",44,0)
+        . W !!!,"------------ SUMMARY ------------"
+"RTN","utcover",45,0)
+        . W !,"Ran ",UTDATA(1)," Routine",$S(UTDATA(1)>1:"s",1:""),", ",UTDATA(2)," Entry Tag",$S(UTDATA(2)>1:"s",1:"")
+"RTN","utcover",46,0)
+        . 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","utcover",47,0)
+        . Q
+"RTN","utcover",48,0)
+        Q
+"RTN","utcover",49,0)
+        ;
+"RTN","utcover",50,0)
+COVERAGE(ROUNMSP,TESTROUS,XCLDROUS,RESLTLVL)    ; run coverage analysis
+"RTN","utcover",51,0)
+        ; input ROUNMSP - Namespace for routine(s) to be analyzed
+"RTN","utcover",52,0)
+        ;                 ROUNAME will result in only the routine ROUNAME being analyzed
+"RTN","utcover",53,0)
+        ;                 ROUN* will result in all routines beginning with ROUN being analyzed
+"RTN","utcover",54,0)
+        ; input TESTROUS - passed by reference - see TESTROUS description for JUSTTEST
+"RTN","utcover",55,0)
+        ; input XCLDROUS - passed by reference - routines passed in a manner similar to TESTROUS,
+"RTN","utcover",56,0)
+        ;                  but only the routine names, whether as arguments or a comma separated
+"RTN","utcover",57,0)
+        ;                  list of routines, will be excluded from the analysis of coverage.  These
+"RTN","utcover",58,0)
+        ;                  would normally be names of routines which are only for unit tests, or
+"RTN","utcover",59,0)
+        ;                  others which should not be included in the analysis for some reason.
+"RTN","utcover",60,0)
+        ; input RESLTLVL - This value determines the amount of information to be generated for the
+"RTN","utcover",61,0)
+        ;                  analysis.  A missing or null value will be considered to be level 1
+"RTN","utcover",62,0)
+        ;                     1  -  Listing of analysis only for routine overall
+"RTN","utcover",63,0)
+        ;                     2  -  Listing of analysis for routine overall and for each TAG
+"RTN","utcover",64,0)
+        ;                     3  -  Full analysis for each tag, and lists out those lines which were
+"RTN","utcover",65,0)
+        ;                           not executed during the analysis
+"RTN","utcover",66,0)
+        ;
+"RTN","utcover",67,0)
+        N I,ROU,TYPE,VAL,XCLUDE
+"RTN","utcover",68,0)
+        S RESLTLVL=$G(RESLTLVL,1)
+"RTN","utcover",69,0)
+        I (RESLTLVL<1) S RESLTLVL=1
+"RTN","utcover",70,0)
+        I (RESLTLVL>3) S RESLTLVL=3
+"RTN","utcover",71,0)
+        M ^TMP("%utCOVER",$J,"TESTROUS")=TESTROUS ; 
+"RTN","utcover",72,0)
+        D COV^%ut1(ROUNMSP,"D COVENTRY^%utCOVER",-1)
+"RTN","utcover",73,0)
+        K ^TMP("%utCOVER",$J,"TESTROUS")
+"RTN","utcover",74,0)
+        S ROU="" F  S ROU=$O(XCLDROUS(ROU)) Q:ROU=""  D
+"RTN","utcover",75,0)
+        . I ROU'=+ROU S XCLUDE(ROU)=""
+"RTN","utcover",76,0)
+        . F I=1:1 S VAL=$P(XCLDROUS(ROU),",",I) Q:VAL=""  S XCLUDE(VAL)=""
+"RTN","utcover",77,0)
+        . Q
+"RTN","utcover",78,0)
+        N TEXTGLOB S TEXTGLOB=$NA(^TMP("%utcover-text",$J))
+"RTN","utcover",79,0)
+        D LIST(.XCLUDE,RESLTLVL,TEXTGLOB)
+"RTN","utcover",80,0)
+        F I=1:1 Q:'$D(@TEXTGLOB@(I))  W !,@TEXTGLOB@(I)
+"RTN","utcover",81,0)
+        K @TEXTGLOB
+"RTN","utcover",82,0)
+        Q
+"RTN","utcover",83,0)
+        ;
+"RTN","utcover",84,0)
+LIST(XCLDROUS,TYPE,TEXTGLOB,GLOB)         ;
+"RTN","utcover",85,0)
+        ; ZEXCEPT: TYPE1  - NEWed and set below for recursion
+"RTN","utcover",86,0)
+        ; input - ROULIST - a comma separated list of routine names that will
+"RTN","utcover",87,0)
+        ;       be used to identify desired routines.  Any name
+"RTN","utcover",88,0)
+        ;       that begins with one of the specified values will
+"RTN","utcover",89,0)
+        ;       be included
+"RTN","utcover",90,0)
+        ; input - TYPE - value indicating amount of detail desired
+"RTN","utcover",91,0)
+        ;       3=full with listing of untouched lines
+"RTN","utcover",92,0)
+        ;       2=moderated with listing by tags
+"RTN","utcover",93,0)
+        ;       1=summary with listing by routine
+"RTN","utcover",94,0)
+        ; input - TEXTGLOB - closed global location in which text is returned
+"RTN","utcover",95,0)
+        ; input - GLOB - used for unit tests - specifies global to work with
+"RTN","utcover",96,0)
+        ;                so that coverage data is not impacted
+"RTN","utcover",97,0)
+        ;
+"RTN","utcover",98,0)
+        N CURRCOV,CURRLIN,LINCOV,LINE,LINTOT,ROULIST,ROUNAME,TAG,TOTCOV,TOTLIN,XVAL,LINNUM
+"RTN","utcover",99,0)
+        ;
+"RTN","utcover",100,0)
+        I '$D(GLOB) N GLOB S GLOB=$NA(^TMP("%utCOVREPORT",$J))
+"RTN","utcover",101,0)
+        D TRIMDATA(.XCLDROUS,GLOB) ; remove undesired routines from data
+"RTN","utcover",102,0)
+        ;
+"RTN","utcover",103,0)
+        N JOB,NAME,BASE
+"RTN","utcover",104,0)
+        S TOTCOV=0,TOTLIN=0,LINNUM=0
+"RTN","utcover",105,0)
+        ; F NAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
+"RTN","utcover",106,0)
+        I TYPE>1 S ROUNAME="" F  S ROUNAME=$O(@GLOB@(ROUNAME)) Q:ROUNAME=""  S XVAL=^(ROUNAME) D
+"RTN","utcover",107,0)
+        . S CURRCOV=$P(XVAL,"/"),CURRLIN=$P(XVAL,"/",2)
+"RTN","utcover",108,0)
+        . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="",LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=""
+"RTN","utcover",109,0)
+        . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="Routine "_ROUNAME_"   "_CURRCOV_" out of "_CURRLIN_" lines covered"_$S(CURRLIN>0:"  ("_$P((100*CURRCOV)/CURRLIN,".")_"%)",1:"")
+"RTN","utcover",110,0)
+        . I TYPE=2 S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="  - Summary"
+"RTN","utcover",111,0)
+        . S TAG="" F  S TAG=$O(@GLOB@(ROUNAME,TAG)) Q:TAG=""  S XVAL=^(TAG) D
+"RTN","utcover",112,0)
+        . . S LINCOV=$P(XVAL,"/"),LINTOT=$P(XVAL,"/",2)
+"RTN","utcover",113,0)
+        . . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=" Tag "_TAG_"^"_ROUNAME_"   "_LINCOV_" out of "_LINTOT_" lines covered"
+"RTN","utcover",114,0)
+        . . I TYPE=2 Q
+"RTN","utcover",115,0)
+        . . I LINCOV=LINTOT Q
+"RTN","utcover",116,0)
+        . . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="   the following is a list of lines NOT covered"
+"RTN","utcover",117,0)
+        . . S LINE="" F  S LINE=$O(@GLOB@(ROUNAME,TAG,LINE)) Q:LINE=""  D
+"RTN","utcover",118,0)
+        . . . I LINE=0 S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="   "_TAG_"  "_@GLOB@(ROUNAME,TAG,LINE) Q
+"RTN","utcover",119,0)
+        . . . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="   "_TAG_"+"_LINE_"  "_@GLOB@(ROUNAME,TAG,LINE)
+"RTN","utcover",120,0)
+        . . . Q
+"RTN","utcover",121,0)
+        . . Q
+"RTN","utcover",122,0)
+        . Q
+"RTN","utcover",123,0)
+        ; for type=3 generate a summary at bottom after detail
+"RTN","utcover",124,0)
+        I TYPE=3 N TYPE1 S TYPE1=2 D LIST(.XCLDROUS,2,TEXTGLOB,GLOB) K TYPE1
+"RTN","utcover",125,0)
+        I TYPE=2,$G(TYPE1) Q  ; CAME IN FROM ABOVE LINE
+"RTN","utcover",126,0)
+        ; summarize by just routine name
+"RTN","utcover",127,0)
+        S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="",LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=""
+"RTN","utcover",128,0)
+        S ROUNAME="" F  S ROUNAME=$O(@GLOB@(ROUNAME)) Q:ROUNAME=""  S XVAL=^(ROUNAME) D
+"RTN","utcover",129,0)
+        . S CURRCOV=$P(XVAL,"/"),CURRLIN=$P(XVAL,"/",2)
+"RTN","utcover",130,0)
+        . S TOTCOV=TOTCOV+CURRCOV,TOTLIN=TOTLIN+CURRLIN
+"RTN","utcover",131,0)
+        . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="Routine "_ROUNAME_"   "_CURRCOV_" out of "_CURRLIN_" lines covered"_$S(CURRLIN>0:"  ("_$P((100*CURRCOV)/CURRLIN,".")_"%)",1:"")
+"RTN","utcover",132,0)
+        . Q
+"RTN","utcover",133,0)
+        S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="",LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=""
+"RTN","utcover",134,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",135,0)
+        Q
+"RTN","utcover",136,0)
+        ;
+"RTN","utcover",137,0)
+TRIMDATA(ROULIST,GLOB)     ;
+"RTN","utcover",138,0)
+        N ROUNAME
+"RTN","utcover",139,0)
+        S ROUNAME="" F  S ROUNAME=$O(ROULIST(ROUNAME)) Q:ROUNAME=""  K @GLOB@(ROUNAME)
+"RTN","utcover",140,0)
+        Q
+"RTN","utcover",141,0)
+        ;
 "RTN","utt1")
-0^3^B25860592
+0^3^B26409996
 "RTN","utt1",1,0)
 %utt1 ; VEN/SMH - Testing routines for M-Unit;08/29/14  11:35
 "RTN","utt1",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 4
 "RTN","utt1",3,0)
 %utNITT ; VEN/SMH - Testing routines for M-Unit;2014-04-01  2:04 PM
 "RTN","utt1",4,0)
@@ -2564,12 +3002,14 @@ XTROU ; Routines containing additional tests
  ;;%utt5;
 "RTN","utt1",150,0)
  ;;%utt6;
+"RTN","utt1",151,0)
+ ;;%uttcovr;coverage related tests
 "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;
+ ;;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)
@@ -2595,7 +3035,7 @@ XTENT ;
 "RTN","utt3",1,0)
 %utt3 ; VEN/SMH - Unit Tests Coverage Tests;08/14/14  14:02
 "RTN","utt3",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 4
 "RTN","utt3",3,0)
 XTMUNITV ; VEN/SMH - Unit Tests Coverage Tests;2014-04-16  7:14 PM
 "RTN","utt3",4,0)
@@ -2683,7 +3123,7 @@ INTERNAL(A) ; Counts
 "RTN","utt4",1,0)
 %utt4 ; VEN/SMH - Coverage Test Runner;08/23/14  08:33
 "RTN","utt4",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 4
 "RTN","utt4",3,0)
 XTMUNITW ; VEN/SMH - Coverage Test Runner;2014-04-17  3:30 PM
 "RTN","utt4",4,0)
@@ -2727,7 +3167,7 @@ MAIN ; @TEST - Test coverage calculations
 "RTN","utt5",1,0)
 %utt5 ;JLI - test for aspects of MUnit functionality ;08/29/14  11:23
 "RTN","utt5",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 4
 "RTN","utt5",3,0)
  Q
 "RTN","utt5",4,0)
@@ -2995,11 +3435,11 @@ XTENT ;
 "RTN","utt5",135,0)
  ;;ISUTEST;check ISUTEST inside unit test
 "RTN","utt6")
-0^8^B29243478
+0^8^B30140551
 "RTN","utt6",1,0)
 %utt6 ;JLI - Unit tests for MUnit functionality ;08/29/14  11:43
 "RTN","utt6",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 4
 "RTN","utt6",3,0)
  ;
 "RTN","utt6",4,0)
@@ -3115,117 +3555,123 @@ VERBOSE ;
 "RTN","utt6",59,0)
  ;
 "RTN","utt6",60,0)
- ; now run the unit tests in this routine
+ W !!,"NOW RUNNING UNIT TESTS FOR %uttcovr",!!
 "RTN","utt6",61,0)
- W !!,"NOW RUNNING UNIT TESTS FOR %utt6",!!
+ D EN^%ut("%uttcovr",VERBOSE)
 "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)
+ ; now run the unit tests in this routine
 "RTN","utt6",64,0)
- ; clean up after GUI calls as well
+ W !!,"NOW RUNNING UNIT TESTS FOR %utt6",!!
 "RTN","utt6",65,0)
- K ^TMP("GUI-MUNIT",$J),^TMP("GUINEXT",$J),^TMP("MUNIT-%utRSLT",$J)
+ D EN^%ut("%utt6",VERBOSE)
 "RTN","utt6",66,0)
- Q
+ K ^TMP("%utt5",$J),^TMP("%utt5_C",$J),^TMP("%utt5_G",$J),^TMP("%utt6",$J),^TMP("%utt6_GUISET",$J)
 "RTN","utt6",67,0)
- ;
+ ; clean up after GUI calls as well
 "RTN","utt6",68,0)
- ;
+ K ^TMP("GUI-MUNIT",$J),^TMP("GUINEXT",$J),^TMP("MUNIT-%utRSLT",$J)
 "RTN","utt6",69,0)
- ;           WARNING     --      WARNING     --      WARNING
+ Q
 "RTN","utt6",70,0)
- ; If the number of NEW STYLE tests in %utt5 is increased (it is currently 1), then the following
+ ;
 "RTN","utt6",71,0)
- ; test will need to be updated to reflect the change(s)
+ ;
 "RTN","utt6",72,0)
- ;     END OF WARNING  --  END OF WARNING  --  END OF WARNING
+ ;           WARNING     --      WARNING     --      WARNING
 "RTN","utt6",73,0)
- ;
+ ; If the number of NEW STYLE tests in %utt5 is increased (it is currently 1), then the following
 "RTN","utt6",74,0)
-NEWSTYLE ; tests return of valid new style or @TEST indicators
+ ; test will need to be updated to reflect the change(s)
 "RTN","utt6",75,0)
- N LIST
+ ;     END OF WARNING  --  END OF WARNING  --  END OF WARNING
 "RTN","utt6",76,0)
- D NEWSTYLE^%ut1(.LIST,"%utt5")
+ ;
 "RTN","utt6",77,0)
- D CHKEQ^%ut(LIST,1,"Returned an incorrect number ("_LIST_") of New Style indicators - should be one")
+NEWSTYLE ; tests return of valid new style or @TEST indicators
 "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))
+ N LIST
 "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)")
+ D NEWSTYLE^%ut1(.LIST,"%utt5")
 "RTN","utt6",80,0)
- Q
+ D CHKEQ^%ut(LIST,1,"Returned an incorrect number ("_LIST_") of New Style indicators - should be one")
 "RTN","utt6",81,0)
- ;
+ I LIST>0 D CHKEQ^%ut(LIST(1),"NEWSTYLE^identify new style test indicator functionality","Returned incorrect TAG^reason "_LIST(1))
 "RTN","utt6",82,0)
-CKGUISET ;
+ 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",83,0)
- ; ZEXCEPT: %utt6var - if present, is NEWed and created in code following VERBOSE
+ Q
 "RTN","utt6",84,0)
- I '$D(%utt6var) Q
+ ;
 "RTN","utt6",85,0)
- N MAX
+CKGUISET ;
 "RTN","utt6",86,0)
- S MAX=$O(^TMP("%utt6_GUISET",$J,""),-1)
+ ; ZEXCEPT: %utt6var - if present, is NEWed and created in code following VERBOSE
 "RTN","utt6",87,0)
- D CHKTF^%ut(^TMP("%utt6_GUISET",$J,MAX)["%utt6^NEWSTYLE","GUISET returned incorrect list")
+ I '$D(%utt6var) Q
 "RTN","utt6",88,0)
- Q
+ N MAX
 "RTN","utt6",89,0)
- ;
+ S MAX=$O(^TMP("%utt6_GUISET",$J,""),-1)
 "RTN","utt6",90,0)
-CHKCMDLN ; check command line processing of %utt5
+ D CHKTF^%ut(^TMP("%utt6_GUISET",$J,MAX)["%utt6^NEWSTYLE","GUISET returned incorrect list")
 "RTN","utt6",91,0)
- ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+ Q
 "RTN","utt6",92,0)
- I '$D(%utt6var) Q
+ ;
 "RTN","utt6",93,0)
- D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+CHKCMDLN ; check command line processing of %utt5
 "RTN","utt6",94,0)
- D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
-"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'")
-"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'")
-"RTN","utt6",97,0)
- Q
-"RTN","utt6",98,0)
- ;
-"RTN","utt6",99,0)
-CHKGUI ; check GUI processing of %utt5
-"RTN","utt6",100,0)
  ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
-"RTN","utt6",101,0)
+"RTN","utt6",95,0)
  I '$D(%utt6var) Q
-"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)
+"RTN","utt6",96,0)
+ D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",97,0)
+ D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",98,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'")
+"RTN","utt6",99,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'")
+"RTN","utt6",100,0)
  Q
-"RTN","utt6",107,0)
+"RTN","utt6",101,0)
  ;
+"RTN","utt6",102,0)
+CHKGUI ; check GUI processing of %utt5
+"RTN","utt6",103,0)
+ ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+"RTN","utt6",104,0)
+ I '$D(%utt6var) Q
+"RTN","utt6",105,0)
+ D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",106,0)
+ D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",107,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",108,0)
-XTENT ;
+ 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",109,0)
- ;;CHKCMDLN;check command line processing of %utt5
+ Q
 "RTN","utt6",110,0)
- ;;CHKGUI;check GUI processing of %utt5
+ ;
 "RTN","utt6",111,0)
- ;;CKGUISET;check list of tests returned by GUISET
+XTENT ;
 "RTN","utt6",112,0)
+ ;;CHKCMDLN;check command line processing of %utt5
+"RTN","utt6",113,0)
+ ;;CHKGUI;check GUI processing of %utt5
+"RTN","utt6",114,0)
+ ;;CKGUISET;check list of tests returned by GUISET
+"RTN","utt6",115,0)
  ;;NEWSTYLE;test return of valid new style or @TEST indicators
 "RTN","uttcovr")
-0^9^B2835727
+0^9^B88235384
 "RTN","uttcovr",1,0)
-%uttcovr ;JLI/JIVEYSOFT - runs coverage tests on %ut and %ut1 routines via unit tests ;09/10/14  14:34
+uttcovr ;JLI/JIVEYSOFT - runs coverage tests on %ut and %ut1 routines via unit tests ; 7/3/15 12:39pm
 "RTN","uttcovr",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 4
 "RTN","uttcovr",3,0)
  ;
 "RTN","uttcovr",4,0)
@@ -3233,87 +3679,389 @@ XTENT ;
 "RTN","uttcovr",5,0)
  ;
 "RTN","uttcovr",6,0)
- ; if SHOWALL is true (1) all coverage globals data are listed
+ ; Have it run the following entry points or, if no ^, call EN^%ut with routine name
 "RTN","uttcovr",7,0)
- ; if SHOWALL is false (0), only the %utCOVREPORT global is listed
+ S RUNCODE(1)="^%utt1,%utt1,^%utt6,VERBOSE^%utt6,%uttcovr,^%ut,^%ut1,^%utcover"
 "RTN","uttcovr",8,0)
- I '$D(SHOWALL) N SHOWALL S SHOWALL=0
+ M ^TMP("%uttcovr",$J,"RUNCODE")=RUNCODE
 "RTN","uttcovr",9,0)
- ; set global node so %utt4 doesn't run its own analysis
+ ; need this one separate, or it runs into infinite loop
 "RTN","uttcovr",10,0)
- S ^TMP("%uttcovr",$J)=1
+ S RUNCODE("ENTRY^%uttcovr")=""
 "RTN","uttcovr",11,0)
- ; start analysis of %ut - it calls entry below
+ ; Have the analysis EXCLUDE the following routines from coverage - unit test routines
 "RTN","uttcovr",12,0)
- D COV^%ut1("%ut","D TESTCOVR^%ut",-1)
+ S XCLUDE(1)="%utt1,%utt2,%utt3,%utt4,%utt5,%utt6,%uttcovr"
 "RTN","uttcovr",13,0)
- D LIST("%ut") ; output results of analysis
+ M ^TMP("%uttcovr",$J,"XCLUDE")=XCLUDE
 "RTN","uttcovr",14,0)
- ; start analysis of %ut1
+ D COVERAGE^%utcover("%ut*",.RUNCODE,.XCLUDE,3)
 "RTN","uttcovr",15,0)
- D COV^%ut1("%ut1","D TESTCOVR^%ut1",3)
+ Q
 "RTN","uttcovr",16,0)
- D LIST("%ut1")
+ ;
 "RTN","uttcovr",17,0)
- K ^TMP("%uttcovr",$J)
-"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",27,0)
- D ^%utt1 ; verbose
-"RTN","uttcovr",28,0)
- D EN^%ut("%utt1") ; non-verbose
-"RTN","uttcovr",29,0)
+"RTN","uttcovr",18,0)
+ ; The following are now specified in the initial call to COVERAGE^%
+"RTN","uttcovr",19,0)
+ ;D ^%utt1 ; verbose
+"RTN","uttcovr",20,0)
+ ;D EN^%ut("%utt1") ; non-verbose
+"RTN","uttcovr",21,0)
  ; run tests from top of %utt6, runs both command line and gui analyses
-"RTN","uttcovr",30,0)
- D ^%utt6 ; non-verbose
-"RTN","uttcovr",31,0)
- D VERBOSE^%utt6 ; verbose
-"RTN","uttcovr",32,0)
- Q
-"RTN","uttcovr",33,0)
+"RTN","uttcovr",22,0)
+ ;D ^%utt6 ; non-verbose
+"RTN","uttcovr",23,0)
+ ;D VERBOSE^%utt6 ; verbose
+"RTN","uttcovr",24,0)
+ ; run tests from top of routines
+"RTN","uttcovr",25,0)
+ ;D ^%ut
+"RTN","uttcovr",26,0)
+ ;D ^%ut1
+"RTN","uttcovr",27,0)
  ;
+"RTN","uttcovr",28,0)
+ ; these tests run outside of unit tests to handle CHKLEAKS calls not in unit tests
+"RTN","uttcovr",29,0)
+ ; they need data set, so they are called in here
+"RTN","uttcovr",30,0)
+ ; LEAKSOK ;
+"RTN","uttcovr",31,0)
+ N CODE,LOCATN,MYVALS,X
+"RTN","uttcovr",32,0)
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSOK TEST",MYVALS("X")=""
+"RTN","uttcovr",33,0)
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find no leaks
 "RTN","uttcovr",34,0)
-LIST(ROU) ;
+ ; LEAKSBAD ;
 "RTN","uttcovr",35,0)
- ; ZEXCEPT: SHOWALL - NEWed and set in SHOWALL or entering at %uttcovr
+ N CODE,LOCATN,MYVALS,X
 "RTN","uttcovr",36,0)
- N JOB,NAME,BASE,GLOB
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSBAD TEST - X NOT SPECIFIED"
 "RTN","uttcovr",37,0)
- S JOB=$J
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find X since it isn't indicated
 "RTN","uttcovr",38,0)
- W !!!,ROU_" COVERAGE ANALYSIS"
+ ; try to run coverage
 "RTN","uttcovr",39,0)
- F NAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
+ D COV^%ut("%ut1","D EN^%ut(""%utt5"")",3)
 "RTN","uttcovr",40,0)
- . I 'SHOWALL,NAME'="%utCOVREPORT" Q
+ D COV^%ut("%ut1","D EN^%ut(""%utt5"")",-1)
 "RTN","uttcovr",41,0)
- . W !!!,NAME," GLOBAL DATA",!
+ N RUNCODE S RUNCODE(1)="^%utt4,^%ut" ; M RUNCODE=^TMP("%uttcovr",$J,"RUNCODE")
 "RTN","uttcovr",42,0)
- . S BASE="^TMP("""_NAME_""","_JOB,GLOB=BASE_")"
+ N XCLUDE M XCLUDE=^TMP("%uttcovr",$J,"XCLUDE")
 "RTN","uttcovr",43,0)
- . I $D(GLOB)#2 W !,GLOB,"=",$G(@GLOB)
+ D TESTONLY^%utcover(.RUNCODE)
 "RTN","uttcovr",44,0)
- . F  S GLOB=$Q(@GLOB) Q:GLOB'[BASE  I $D(GLOB)#2 W !,GLOB,"=",@GLOB
+ D COVERAGE^%utcover("%ut*",.RUNCODE,.XCLUDE,3)
 "RTN","uttcovr",45,0)
- . Q
+ N GLT S GLT=$NA(^TMP("%uttcovr-text",$J)) K @GLT
 "RTN","uttcovr",46,0)
+ D LIST^%utcover(.XCLUDE,3,GLT) ; get coverage for listing and trimdata in %utcover
+"RTN","uttcovr",47,0)
+ F I=1:1 Q:'$D(@GLT@(I))  W !,@GLT@(I)
+"RTN","uttcovr",48,0)
+ K @GLT
+"RTN","uttcovr",49,0)
  Q
+"RTN","uttcovr",50,0)
+ ;
+"RTN","uttcovr",51,0)
+RTNANAL ; @TEST - routine analysis
+"RTN","uttcovr",52,0)
+ N ROUS,GLB
+"RTN","uttcovr",53,0)
+ S ROUS("%utt4")=""
+"RTN","uttcovr",54,0)
+ S GLB=$NA(^TMP("%uttcovr-rtnanal",$J)) K @GLB
+"RTN","uttcovr",55,0)
+ D RTNANAL^%ut1(.ROUS,GLB)
+"RTN","uttcovr",56,0)
+ D CHKTF^%ut($D(@GLB@("%utt4","MAIN"))>1,"Not enough 'MAIN' nodes found")
+"RTN","uttcovr",57,0)
+ D CHKTF^%ut($G(@GLB@("%utt4","MAIN",2))["+$SY=47","Check for GT.M not found in expected line")
+"RTN","uttcovr",58,0)
+ D CHKTF^%ut($G(@GLB@("%utt4","MAIN",12))=" QUIT","Final QUIT not on expected line")
+"RTN","uttcovr",59,0)
+ K @GLB
+"RTN","uttcovr",60,0)
+ Q
+"RTN","uttcovr",61,0)
+ ;
+"RTN","uttcovr",62,0)
+COVRPTGL ; @TEST - coverage report returning global
+"RTN","uttcovr",63,0)
+ N GL1,GL2,GL3,GL4
+"RTN","uttcovr",64,0)
+ S GL1=$NA(^TMP("%utCOVCOHORTSAVx",$J)) K @GL1
+"RTN","uttcovr",65,0)
+ S GL2=$NA(^TMP("%utCOVCOHORTx",$J)) K @GL2
+"RTN","uttcovr",66,0)
+ S GL3=$NA(^TMP("%utCOVRESULTx",$J)) K @GL3
+"RTN","uttcovr",67,0)
+ S GL4=$NA(^TMP("%utCOVREPORTx",$J)) K @GL4
+"RTN","uttcovr",68,0)
+ D SETGLOBS(GL1,GL2)
+"RTN","uttcovr",69,0)
+ D COVRPTGL^%ut1(GL1,GL2,GL3,GL4)
+"RTN","uttcovr",70,0)
+ D CHKEQ^%ut($G(@GL4@("%ut1","ACTLINES")),"0/9","Wrong number of lines covered f>>or ACTLINES")
+"RTN","uttcovr",71,0)
+ D CHKEQ^%ut($G(@GL4@("%ut1","ACTLINES",9))," QUIT CNT","Wrong result for last l>>ine not covered for ACTLINES")
+"RTN","uttcovr",72,0)
+ D CHKEQ^%ut($G(@GL4@("%ut1","CHEKTEST")),"8/10","Wrong number of lines covered >>for CHEKTEST")
+"RTN","uttcovr",73,0)
+ D CHKEQ^%ut($G(@GL4@("%ut1","CHEKTEST",39))," . Q","Wrong result for last line >>not covered for CHEKTEST")
+"RTN","uttcovr",74,0)
+ K @GL1,@GL2,@GL3,@GL4
+"RTN","uttcovr",75,0)
+ Q
+"RTN","uttcovr",76,0)
+ ;
+"RTN","uttcovr",77,0)
+COVRPTLS ; @TEST - coverage report returning text in global
+"RTN","uttcovr",78,0)
+ N GL1,GL2,GL3,GL4,VRBOSITY
+"RTN","uttcovr",79,0)
+ S GL1=$NA(^TMP("%utCOVCOHORTSAVx",$J)) K @GL1
+"RTN","uttcovr",80,0)
+ S GL2=$NA(^TMP("%utCOVCOHORTx",$J)) K @GL2
+"RTN","uttcovr",81,0)
+ S GL3=$NA(^TMP("%utCOVRESULTx",$J)) K @GL3
+"RTN","uttcovr",82,0)
+ S GL4=$NA(^TMP("%utCOVREPORTx",$J)) K @GL4
+"RTN","uttcovr",83,0)
+ D SETGLOBS(GL1,GL2)
+"RTN","uttcovr",84,0)
+ S VRBOSITY=1
+"RTN","uttcovr",85,0)
+ D COVRPTLS^%ut1(GL1,GL2,GL3,VRBOSITY,GL4)
+"RTN","uttcovr",86,0)
+ D CHKEQ^%ut("COVERAGE PERCENTAGE: 42.11",$G(@GL4@(5)),"Verbosity 1 - not expected percentage value")
+"RTN","uttcovr",87,0)
+ D CHKEQ^%ut("42.11",$G(@GL4@(9)),"Verbosity 1 - not expected value for line 9")
+"RTN","uttcovr",88,0)
+ D CHKTF^%ut('$D(@GL4@(10)),"Verbosity 1 - unexpected data in 10th line")
+"RTN","uttcovr",89,0)
+ K @GL4
+"RTN","uttcovr",90,0)
+ ;
+"RTN","uttcovr",91,0)
+ S VRBOSITY=2
+"RTN","uttcovr",92,0)
+ D COVRPTLS^%ut1(GL1,GL2,GL3,VRBOSITY,GL4)
+"RTN","uttcovr",93,0)
+ D CHKEQ^%ut("    ACTLINES        0.00",$G(@GL4@(10)),"Verbosity 2 - not expected value for 10th line")
+"RTN","uttcovr",94,0)
+ D CHKEQ^%ut("    CHEKTEST        80.00",$G(@GL4@(11)),"Verbosity 2 - not expected value for 11th line")
+"RTN","uttcovr",95,0)
+ D CHKTF^%ut('$D(@GL4@(12)),"Verbosity 2 - unexpected data for 12th line")
+"RTN","uttcovr",96,0)
+ K @GL4
+"RTN","uttcovr",97,0)
+ ;
+"RTN","uttcovr",98,0)
+ S VRBOSITY=3
+"RTN","uttcovr",99,0)
+ D COVRPTLS^%ut1(GL1,GL2,GL3,VRBOSITY,GL4)
+"RTN","uttcovr",100,0)
+ D CHKEQ^%ut("    ACTLINES        0.00",$G(@GL4@(10)),"Verbosity 3 - unexpected value for line 10")
+"RTN","uttcovr",101,0)
+ D CHKEQ^%ut("ACTLINES+9:  QUIT CNT",$G(@GL4@(19)),"Verbosity 3 - unexpected value for line 19")
+"RTN","uttcovr",102,0)
+ D CHKEQ^%ut("    CHEKTEST        80.00",$G(@GL4@(20)),"Verbosity 3 - unexpected value for line 20")
+"RTN","uttcovr",103,0)
+ D CHKEQ^%ut("CHEKTEST+39:  . Q",$G(@GL4@(22)),"Verbosity 3 - unexpected value for line 22")
+"RTN","uttcovr",104,0)
+ D CHKTF^%ut('$D(@GL4@(23)),"Verbosity 3 - unexpected line 23")
+"RTN","uttcovr",105,0)
+ ;
+"RTN","uttcovr",106,0)
+ K @GL1,@GL2,@GL3,@GL4
+"RTN","uttcovr",107,0)
+ Q
+"RTN","uttcovr",108,0)
+ ;
+"RTN","uttcovr",109,0)
+TRIMDATA ; @TEST - TRIMDATA in %utcover
+"RTN","uttcovr",110,0)
+ N GL1,XCLUD
+"RTN","uttcovr",111,0)
+ S GL1=$NA(^TMP("%uttcovr-trimdata",$J)) K @GL1
+"RTN","uttcovr",112,0)
+ S @GL1@("GOOD",1)="1"
+"RTN","uttcovr",113,0)
+ S @GL1@("BAD",1)="1"
+"RTN","uttcovr",114,0)
+ S XCLUD("BAD")=""
+"RTN","uttcovr",115,0)
+ D TRIMDATA^%utcover(.XCLUD,GL1)
+"RTN","uttcovr",116,0)
+ D CHKTF^%ut($D(@GL1@("GOOD")),"GOOD ENTRY WAS REMOVED")
+"RTN","uttcovr",117,0)
+ D CHKTF^%ut('$D(@GL1@("BAD")),"ENTRY WAS NOT TRIMMED")
+"RTN","uttcovr",118,0)
+ K @GL1,XCLUD
+"RTN","uttcovr",119,0)
+ Q
+"RTN","uttcovr",120,0)
+ ;
+"RTN","uttcovr",121,0)
+LIST ; @TEST - LIST in %utcover
+"RTN","uttcovr",122,0)
+ N GL1,GLT S GL1=$NA(^TMP("%uttcovr-list",$J)),GLT=$NA(^TMP("%uttcovr-text",$J))
+"RTN","uttcovr",123,0)
+ S @GL1@("%ut1")="89/160"
+"RTN","uttcovr",124,0)
+ S @GL1@("%ut1","%ut1")="2/2"
+"RTN","uttcovr",125,0)
+ S @GL1@("%ut1","ACTLINES")="0/9"
+"RTN","uttcovr",126,0)
+ S @GL1@("%ut1","ACTLINES",0)="ACTLINES(GL) ; [Private] $$ ; Count active lines"
+"RTN","uttcovr",127,0)
+ S @GL1@("%ut1","ACTLINES",2)=" N CNT S CNT=0"
+"RTN","uttcovr",128,0)
+ S @GL1@("%ut1","ACTLINES",3)=" N REF S REF=GL"
+"RTN","uttcovr",129,0)
+ S @GL1@("%ut1","ACTLINES",4)=" N GLQL S GLQL=$QL(GL)"
+"RTN","uttcovr",130,0)
+ S @GL1@("%ut1","ACTLINES",5)=" F  S REF=$Q(@REF) Q:REF=""""  Q:(GL'=$NA(@REF,GLQL))  D"
+"RTN","uttcovr",131,0)
+ S @GL1@("%ut1","ACTLINES",6)=" . N REFQL S REFQL=$QL(REF)"
+"RTN","uttcovr",132,0)
+ S @GL1@("%ut1","ACTLINES",7)=" . N LASTSUB S LASTSUB=$QS(REF,REFQL)"
+"RTN","uttcovr",133,0)
+ S @GL1@("%ut1","ACTLINES",8)=" . I LASTSUB?1.N S CNT=CNT+1"
+"RTN","uttcovr",134,0)
+ S @GL1@("%ut1","ACTLINES",9)=" QUIT CNT"
+"RTN","uttcovr",135,0)
+ S @GL1@("%ut1","CHECKTAG")="11/11"
+"RTN","uttcovr",136,0)
+ S @GL1@("%ut1","CHEKTEST")="10/10"
+"RTN","uttcovr",137,0)
+ N XCLUD S XCLUD("%utt1")=""
+"RTN","uttcovr",138,0)
+ D LIST^%utcover(.XCLUD,1,GLT,GL1)
+"RTN","uttcovr",139,0)
+ D CHKEQ^%ut("Routine %ut1   89 out of 160 lines covered  (55%)",$G(@GLT@(3)),"Verbosity 1 - Unexpected text for line 3")
+"RTN","uttcovr",140,0)
+ D CHKEQ^%ut("Overall Analysis 89 out of 160 lines covered (55% coverage)",$G(@GLT@(6)),"Verbosity 1 - unexpected text for line 6")
+"RTN","uttcovr",141,0)
+ D CHKTF^%ut('$D(@GLT@(7)),"Verbosity 1 - Unexpected line 7 present")
+"RTN","uttcovr",142,0)
+ K @GLT
+"RTN","uttcovr",143,0)
+ ;
+"RTN","uttcovr",144,0)
+ D LIST^%utcover(.XCLUD,2,GLT,GL1)
+"RTN","uttcovr",145,0)
+ D CHKEQ^%ut("  - Summary",$G(@GLT@(4)),"Verbosity 2 - unexpected text at line 4")
+"RTN","uttcovr",146,0)
+ D CHKEQ^%ut(" Tag ACTLINES^%ut1   0 out of 9 lines covered",$G(@GLT@(6)),"Verbosity 2 - unexpected text at line 6")
+"RTN","uttcovr",147,0)
+ D CHKEQ^%ut(" Tag CHEKTEST^%ut1   10 out of 10 lines covered",$G(@GLT@(8)),"Verbosity 2 - unexpected text at line 8")
+"RTN","uttcovr",148,0)
+ D CHKTF^%ut($D(@GLT@(14)),"Verbosity 2 - expected line at line 14")
+"RTN","uttcovr",149,0)
+ D CHKTF^%ut('$D(@GLT@(15)),"Verbosity 2 - unexpected line at line 15")
+"RTN","uttcovr",150,0)
+ K @GLT
+"RTN","uttcovr",151,0)
+ ;
+"RTN","uttcovr",152,0)
+ D LIST^%utcover(.XCLUD,3,GLT,GL1)
+"RTN","uttcovr",153,0)
+ D CHKEQ^%ut(" Tag %ut1^%ut1   2 out of 2 lines covered",$G(@GLT@(5)),"Verbosity 3 - Incorrect text at line 5")
+"RTN","uttcovr",154,0)
+ D CHKEQ^%ut("   ACTLINES+9   QUIT CNT",$G(@GLT@(15)),"Verbosity 3 - incorrect line 15")
+"RTN","uttcovr",155,0)
+ D CHKTF^%ut($D(@GLT@(23)),"Verbosity 3 - expected data in line 23")
+"RTN","uttcovr",156,0)
+ D CHKTF^%ut('$D(@GLT@(24)),"Verbosity 3 - did not expect a line 24")
+"RTN","uttcovr",157,0)
+ ;
+"RTN","uttcovr",158,0)
+ K @GL1,@GLT
+"RTN","uttcovr",159,0)
+ Q
+"RTN","uttcovr",160,0)
+ ;
+"RTN","uttcovr",161,0)
+SETGLOBS(GL1,GL2) ; 
+"RTN","uttcovr",162,0)
+ S @GL1@("%ut1","ACTLINES")="ACTLINES"
+"RTN","uttcovr",163,0)
+ S @GL1@("%ut1","ACTLINES",0)="ACTLINES(GL) ; [Private] $$ ; Count active lines"
+"RTN","uttcovr",164,0)
+ S @GL1@("%ut1","ACTLINES",2)=" N CNT S CNT=0"
+"RTN","uttcovr",165,0)
+ S @GL1@("%ut1","ACTLINES",3)=" N REF S REF=GL"
+"RTN","uttcovr",166,0)
+ S @GL1@("%ut1","ACTLINES",4)=" N GLQL S GLQL=$QL(GL)"
+"RTN","uttcovr",167,0)
+ S @GL1@("%ut1","ACTLINES",5)=" F  S REF=$Q(@REF) Q:REF=""""  Q:(GL'=$NA(@REF,GLQL))  D"
+"RTN","uttcovr",168,0)
+ S @GL1@("%ut1","ACTLINES",6)=" . N REFQL S REFQL=$QL(REF)"
+"RTN","uttcovr",169,0)
+ S @GL1@("%ut1","ACTLINES",7)=" . N LASTSUB S LASTSUB=$QS(REF,REFQL)"
+"RTN","uttcovr",170,0)
+ S @GL1@("%ut1","ACTLINES",8)=" . I LASTSUB?1.N S CNT=CNT+1"
+"RTN","uttcovr",171,0)
+ S @GL1@("%ut1","ACTLINES",9)=" QUIT CNT"
+"RTN","uttcovr",172,0)
+ S @GL1@("%ut1","CHEKTEST")="CHEKTEST"
+"RTN","uttcovr",173,0)
+ S @GL1@("%ut1","CHEKTEST",0)="CHEKTEST(%utROU,%ut,%utUETRY) ; Collect Test list."
+"RTN","uttcovr",174,0)
+ S @GL1@("%ut1","CHEKTEST",13)=" N I,LIST"
+"RTN","uttcovr",175,0)
+ S @GL1@("%ut1","CHEKTEST",14)=" S I=$L($T(@(U_%utROU))) I I<0 Q ""-1^Invalid Routine Name"""
+"RTN","uttcovr",176,0)
+ S @GL1@("%ut1","CHEKTEST",31)=" D NEWSTYLE(.LIST,%utROU)"
+"RTN","uttcovr",177,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",178,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",179,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",180,0)
+ S @GL1@("%ut1","CHEKTEST",39)=" . Q"
+"RTN","uttcovr",181,0)
+ S @GL1@("%ut1","CHEKTEST",41)=" QUIT"
+"RTN","uttcovr",182,0)
+ S @GL1@("%ut1","CHEKTEST",9)=" S %ut(""ENTN"")=0 ; Number of test, sub to %utUETRY."
+"RTN","uttcovr",183,0)
+ S @GL2@("%ut1","ACTLINES")="ACTLINES"
+"RTN","uttcovr",184,0)
+ S @GL2@("%ut1","ACTLINES",0)="ACTLINES(GL) ; [Private] $$ ; Count active lines"
+"RTN","uttcovr",185,0)
+ S @GL2@("%ut1","ACTLINES",2)=" N CNT S CNT=0"
+"RTN","uttcovr",186,0)
+ S @GL2@("%ut1","ACTLINES",3)=" N REF S REF=GL"
+"RTN","uttcovr",187,0)
+ S @GL2@("%ut1","ACTLINES",4)=" N GLQL S GLQL=$QL(GL)"
+"RTN","uttcovr",188,0)
+ S @GL2@("%ut1","ACTLINES",5)=" F  S REF=$Q(@REF) Q:REF=""""  Q:(GL'=$NA(@REF,GLQL))  D"
+"RTN","uttcovr",189,0)
+ S @GL2@("%ut1","ACTLINES",6)=" . N REFQL S REFQL=$QL(REF)"
+"RTN","uttcovr",190,0)
+ S @GL2@("%ut1","ACTLINES",7)=" . N LASTSUB S LASTSUB=$QS(REF,REFQL)"
+"RTN","uttcovr",191,0)
+ S @GL2@("%ut1","ACTLINES",8)=" . I LASTSUB?1.N S CNT=CNT+1"
+"RTN","uttcovr",192,0)
+ S @GL2@("%ut1","ACTLINES",9)=" QUIT CNT"
+"RTN","uttcovr",193,0)
+ S @GL2@("%ut1","CHEKTEST")="CHEKTEST"
+"RTN","uttcovr",194,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",195,0)
+ S @GL2@("%ut1","CHEKTEST",39)=" . Q"
+"RTN","uttcovr",196,0)
+ Q
+"RTN","uttcovr",197,0)
+ ;
 "SEC","^DIC",17.9001,17.9001,0,"AUDIT")
 @
 "SEC","^DIC",17.9001,17.9001,0,"DD")
diff --git a/Packman Message MASH_0.1_0 140910.txt b/Packman Message MASH_0.2_0_150703.txt
similarity index 64%
rename from Packman Message MASH_0.1_0 140910.txt
rename to Packman Message MASH_0.2_0_150703.txt
index e495b70..675b5cf 100644
--- a/Packman Message MASH_0.1_0 140910.txt	
+++ b/Packman Message MASH_0.2_0_150703.txt	
@@ -1,145 +1,259 @@
-$TXT Created by IVEY,JOEL L at JIVEY3.JIVEYSOFT.COM  (KIDS) on Wednesday, 09/10/14 at 14:37
+$TXT Created by IVEY,JOEL L at JIVEY3.JIVEYSOFT.COM  (KIDS) on Friday, 07/03/15 at 13:44
  
-Implements the M-Unit Test functionality.
+Changes to functionality include:
+ 
+STARTUP and SHUTDOWN will be run in each routine instead of the first
+instance of STARTUP and SHUTDOWN encountered being the only ones that
+were run.  This change was made because of possible suites of tests
+which have their own STARTUP and SHUTDOWN that need to be run.  Also,
+it does not depend on the order in which test routines are run.
+ 
+While the coverage functionality can only be run on GT.M systems at
+the present time, the routine %utcover has been added to provide
+additional ability to run a number of unit tests at one time so that
+coverage across all of them can be obtained in one run, this includes
+the ability to specify entry at different APIs (e.g., if both verbose
+and nonverbose entries are available) as well as run code which is not
+part of a unit test to include in the analysis.  The routine %uttcovr
+uses this functionality to provide a means of doing coverage analysis
+on the %ut routines and can be used as an example of its usage.
+ 
+A new tag (COV) has been added to the %ut routine (it simply calls
+the one in %ut1) so that all user APIs can be accessed within the %ut
+routine.
+ 
+A potential problem with setting up the %ut namespace in the local 
+instance was addressed by Sam Habiel in the preinstall routine ZZUTPRE.
  
 $END TXT
-$KID MASH*0.1*0
+$KID MASH*0.2*0
 **INSTALL NAME**
-MASH*0.1*0
-"BLD",5528,0)
-MASH*0.1*0^MASH UTILITIES^0^3140910^y
-"BLD",5528,1,0)
-^^2^2^3140829^
-"BLD",5528,1,1,0)
-M-Unit Test functionality to provide basic unit testing framework for M 
-"BLD",5528,1,2,0)
-development.
-"BLD",5528,4,0)
+MASH*0.2*0
+"BLD",9544,0)
+MASH*0.2*0^MASH UTILITIES^0^3150703^n
+"BLD",9544,1,0)
+^^24^24^3150703^^
+"BLD",9544,1,1,0)
+Changes to functionality include:
+"BLD",9544,1,2,0)
+ 
+"BLD",9544,1,3,0)
+STARTUP and SHUTDOWN will be run in each routine instead of the first
+"BLD",9544,1,4,0)
+instance of STARTUP and SHUTDOWN encountered being the only ones that
+"BLD",9544,1,5,0)
+were run.  This change was made because of possible suites of tests
+"BLD",9544,1,6,0)
+which have their own STARTUP and SHUTDOWN that need to be run.  Also,
+"BLD",9544,1,7,0)
+it does not depend on the order in which test routines are run.
+"BLD",9544,1,8,0)
+ 
+"BLD",9544,1,9,0)
+While the coverage functionality can only be run on GT.M systems at
+"BLD",9544,1,10,0)
+the present time, the routine %utcover has been added to provide
+"BLD",9544,1,11,0)
+additional ability to run a number of unit tests at one time so that
+"BLD",9544,1,12,0)
+coverage across all of them can be obtained in one run, this includes
+"BLD",9544,1,13,0)
+the ability to specify entry at different APIs (e.g., if both verbose
+"BLD",9544,1,14,0)
+and nonverbose entries are available) as well as run code which is not
+"BLD",9544,1,15,0)
+part of a unit test to include in the analysis.  The routine %uttcovr
+"BLD",9544,1,16,0)
+uses this functionality to provide a means of doing coverage analysis
+"BLD",9544,1,17,0)
+on the %ut routines and can be used as an example of its usage.
+"BLD",9544,1,18,0)
+ 
+"BLD",9544,1,19,0)
+A new tag (COV) has been added to the %ut routine (it simply calls
+"BLD",9544,1,20,0)
+the one in %ut1) so that all user APIs can be accessed within the %ut
+"BLD",9544,1,21,0)
+routine.
+"BLD",9544,1,22,0)
+ 
+"BLD",9544,1,23,0)
+A potential problem with setting up the %ut namespace in the local 
+"BLD",9544,1,24,0)
+instance was addressed by Sam Habiel in the preinstall routine ZZUTPRE.
+"BLD",9544,4,0)
 ^9.64PA^17.9001^1
-"BLD",5528,4,17.9001,0)
+"BLD",9544,4,17.9001,0)
 17.9001
-"BLD",5528,4,17.9001,222)
+"BLD",9544,4,17.9001,222)
 y^y^f^^n^^y^o^n
-"BLD",5528,4,"B",17.9001,17.9001)
-"BLD",5528,"ABPKG")
+"BLD",9544,4,"B",17.9001,17.9001)
+
+"BLD",9544,6.3)
+5
+"BLD",9544,"ABPKG")
 n
-"BLD",5528,"INI")
+"BLD",9544,"INI")
 ZZUTPRE
-"BLD",5528,"INID")
+"BLD",9544,"INID")
 ^n^n
-"BLD",5528,"INIT")
+"BLD",9544,"INIT")
 ZZUTPOST
-"BLD",5528,"KRN",0)
-^9.67PA^8989.52^19
-"BLD",5528,"KRN",.4,0)
+"BLD",9544,"KRN",0)
+^9.67PA^779.2^20
+"BLD",9544,"KRN",.4,0)
 .4
-"BLD",5528,"KRN",.401,0)
+"BLD",9544,"KRN",.401,0)
 .401
-"BLD",5528,"KRN",.402,0)
+"BLD",9544,"KRN",.402,0)
 .402
-"BLD",5528,"KRN",.403,0)
+"BLD",9544,"KRN",.403,0)
 .403
-"BLD",5528,"KRN",.5,0)
+"BLD",9544,"KRN",.5,0)
 .5
-"BLD",5528,"KRN",.84,0)
+"BLD",9544,"KRN",.84,0)
 .84
-"BLD",5528,"KRN",3.6,0)
+"BLD",9544,"KRN",3.6,0)
 3.6
-"BLD",5528,"KRN",3.8,0)
+"BLD",9544,"KRN",3.8,0)
 3.8
-"BLD",5528,"KRN",9.2,0)
+"BLD",9544,"KRN",9.2,0)
 9.2
-"BLD",5528,"KRN",9.8,0)
+"BLD",9544,"KRN",9.8,0)
 9.8
-"BLD",5528,"KRN",9.8,"NM",0)
-^9.68A^9^9
-"BLD",5528,"KRN",9.8,"NM",1,0)
-ut^^0^B257937062
-"BLD",5528,"KRN",9.8,"NM",2,0)
-ut1^^0^B87092328
-"BLD",5528,"KRN",9.8,"NM",3,0)
-utt1^^0^B25860592
-"BLD",5528,"KRN",9.8,"NM",4,0)
+"BLD",9544,"KRN",9.8,"NM",0)
+^9.68A^10^10
+"BLD",9544,"KRN",9.8,"NM",1,0)
+ut^^0^B268535658
+"BLD",9544,"KRN",9.8,"NM",2,0)
+ut1^^0^B105832889
+"BLD",9544,"KRN",9.8,"NM",3,0)
+utt1^^0^B26409996
+"BLD",9544,"KRN",9.8,"NM",4,0)
 utt2^^0^B473823
-"BLD",5528,"KRN",9.8,"NM",5,0)
+"BLD",9544,"KRN",9.8,"NM",5,0)
 utt3^^0^B1493136
-"BLD",5528,"KRN",9.8,"NM",6,0)
+"BLD",9544,"KRN",9.8,"NM",6,0)
 utt4^^0^B1419637
-"BLD",5528,"KRN",9.8,"NM",7,0)
+"BLD",9544,"KRN",9.8,"NM",7,0)
 utt5^^0^B22421637
-"BLD",5528,"KRN",9.8,"NM",8,0)
-utt6^^0^B29243478
-"BLD",5528,"KRN",9.8,"NM",9,0)
-uttcovr^^0^B2835727
-"BLD",5528,"KRN",9.8,"NM","B","ut",1)
-"BLD",5528,"KRN",9.8,"NM","B","ut1",2)
-"BLD",5528,"KRN",9.8,"NM","B","utt1",3)
-"BLD",5528,"KRN",9.8,"NM","B","utt2",4)
-"BLD",5528,"KRN",9.8,"NM","B","utt3",5)
-"BLD",5528,"KRN",9.8,"NM","B","utt4",6)
-"BLD",5528,"KRN",9.8,"NM","B","utt5",7)
-"BLD",5528,"KRN",9.8,"NM","B","utt6",8)
-"BLD",5528,"KRN",9.8,"NM","B","uttcovr",9)
-"BLD",5528,"KRN",19,0)
+"BLD",9544,"KRN",9.8,"NM",8,0)
+utt6^^0^B30140551
+"BLD",9544,"KRN",9.8,"NM",9,0)
+uttcovr^^0^B88235384
+"BLD",9544,"KRN",9.8,"NM",10,0)
+utcover^^0^B63651128
+"BLD",9544,"KRN",9.8,"NM","B","ut",1)
+
+"BLD",9544,"KRN",9.8,"NM","B","ut1",2)
+
+"BLD",9544,"KRN",9.8,"NM","B","utcover",10)
+
+"BLD",9544,"KRN",9.8,"NM","B","utt1",3)
+
+"BLD",9544,"KRN",9.8,"NM","B","utt2",4)
+
+"BLD",9544,"KRN",9.8,"NM","B","utt3",5)
+
+"BLD",9544,"KRN",9.8,"NM","B","utt4",6)
+
+"BLD",9544,"KRN",9.8,"NM","B","utt5",7)
+
+"BLD",9544,"KRN",9.8,"NM","B","utt6",8)
+
+"BLD",9544,"KRN",9.8,"NM","B","uttcovr",9)
+
+"BLD",9544,"KRN",19,0)
 19
-"BLD",5528,"KRN",19,"NM",0)
+"BLD",9544,"KRN",19,"NM",0)
 ^9.68A^3^3
-"BLD",5528,"KRN",19,"NM",1,0)
+"BLD",9544,"KRN",19,"NM",1,0)
 utMUNIT^^0
-"BLD",5528,"KRN",19,"NM",2,0)
+"BLD",9544,"KRN",19,"NM",2,0)
 utMUNIT GROUP EDIT^^0
-"BLD",5528,"KRN",19,"NM",3,0)
+"BLD",9544,"KRN",19,"NM",3,0)
 utMUNIT GROUP RUN^^0
-"BLD",5528,"KRN",19,"NM","B","utMUNIT",1)
-"BLD",5528,"KRN",19,"NM","B","utMUNIT GROUP EDIT",2)
-"BLD",5528,"KRN",19,"NM","B","utMUNIT GROUP RUN",3)
-"BLD",5528,"KRN",19.1,0)
+"BLD",9544,"KRN",19,"NM","B","utMUNIT",1)
+
+"BLD",9544,"KRN",19,"NM","B","utMUNIT GROUP EDIT",2)
+
+"BLD",9544,"KRN",19,"NM","B","utMUNIT GROUP RUN",3)
+
+"BLD",9544,"KRN",19.1,0)
 19.1
-"BLD",5528,"KRN",101,0)
+"BLD",9544,"KRN",101,0)
 101
-"BLD",5528,"KRN",409.61,0)
+"BLD",9544,"KRN",409.61,0)
 409.61
-"BLD",5528,"KRN",771,0)
+"BLD",9544,"KRN",771,0)
 771
-"BLD",5528,"KRN",870,0)
+"BLD",9544,"KRN",779.2,0)
+779.2
+"BLD",9544,"KRN",870,0)
 870
-"BLD",5528,"KRN",8989.51,0)
+"BLD",9544,"KRN",8989.51,0)
 8989.51
-"BLD",5528,"KRN",8989.52,0)
+"BLD",9544,"KRN",8989.52,0)
 8989.52
-"BLD",5528,"KRN",8994,0)
+"BLD",9544,"KRN",8994,0)
 8994
-"BLD",5528,"KRN",8994,"NM",0)
+"BLD",9544,"KRN",8994,"NM",0)
 ^9.68A^3^3
-"BLD",5528,"KRN",8994,"NM",1,0)
+"BLD",9544,"KRN",8994,"NM",1,0)
 utMUNIT-TEST GROUP LOAD^^0
-"BLD",5528,"KRN",8994,"NM",2,0)
+"BLD",9544,"KRN",8994,"NM",2,0)
 utMUNIT-TEST LOAD^^0
-"BLD",5528,"KRN",8994,"NM",3,0)
+"BLD",9544,"KRN",8994,"NM",3,0)
 utMUNIT-TEST NEXT^^0
-"BLD",5528,"KRN",8994,"NM","B","utMUNIT-TEST GROUP LOAD",1)
-"BLD",5528,"KRN",8994,"NM","B","utMUNIT-TEST LOAD",2)
-"BLD",5528,"KRN",8994,"NM","B","utMUNIT-TEST NEXT",3)
-"BLD",5528,"KRN","B",.4,.4)
-"BLD",5528,"KRN","B",.401,.401)
-"BLD",5528,"KRN","B",.402,.402)
-"BLD",5528,"KRN","B",.403,.403)
-"BLD",5528,"KRN","B",.5,.5)
-"BLD",5528,"KRN","B",.84,.84)
-"BLD",5528,"KRN","B",3.6,3.6)
-"BLD",5528,"KRN","B",3.8,3.8)
-"BLD",5528,"KRN","B",9.2,9.2)
-"BLD",5528,"KRN","B",9.8,9.8)
-"BLD",5528,"KRN","B",19,19)
-"BLD",5528,"KRN","B",19.1,19.1)
-"BLD",5528,"KRN","B",101,101)
-"BLD",5528,"KRN","B",409.61,409.61)
-"BLD",5528,"KRN","B",771,771)
-"BLD",5528,"KRN","B",870,870)
-"BLD",5528,"KRN","B",8989.51,8989.51)
-"BLD",5528,"KRN","B",8989.52,8989.52)
-"BLD",5528,"KRN","B",8994,8994)
-"BLD",5528,"QUES",0)
+"BLD",9544,"KRN",8994,"NM","B","utMUNIT-TEST GROUP LOAD",1)
+
+"BLD",9544,"KRN",8994,"NM","B","utMUNIT-TEST LOAD",2)
+
+"BLD",9544,"KRN",8994,"NM","B","utMUNIT-TEST NEXT",3)
+
+"BLD",9544,"KRN","B",.4,.4)
+
+"BLD",9544,"KRN","B",.401,.401)
+
+"BLD",9544,"KRN","B",.402,.402)
+
+"BLD",9544,"KRN","B",.403,.403)
+
+"BLD",9544,"KRN","B",.5,.5)
+
+"BLD",9544,"KRN","B",.84,.84)
+
+"BLD",9544,"KRN","B",3.6,3.6)
+
+"BLD",9544,"KRN","B",3.8,3.8)
+
+"BLD",9544,"KRN","B",9.2,9.2)
+
+"BLD",9544,"KRN","B",9.8,9.8)
+
+"BLD",9544,"KRN","B",19,19)
+
+"BLD",9544,"KRN","B",19.1,19.1)
+
+"BLD",9544,"KRN","B",101,101)
+
+"BLD",9544,"KRN","B",409.61,409.61)
+
+"BLD",9544,"KRN","B",771,771)
+
+"BLD",9544,"KRN","B",779.2,779.2)
+
+"BLD",9544,"KRN","B",870,870)
+
+"BLD",9544,"KRN","B",8989.51,8989.51)
+
+"BLD",9544,"KRN","B",8989.52,8989.52)
+
+"BLD",9544,"KRN","B",8994,8994)
+
+"BLD",9544,"QDEF")
+^^^^NO^^^^NO^^NO
+"BLD",9544,"QUES",0)
 ^9.62^^
 "DATA",17.9001,1,0)
 TESTS FOR UNIT TEST ROUTINES
@@ -164,10 +278,13 @@ M-UNIT TEST GROUP
 "FIA",17.9001,0,1)
 y^y^f^^n^^y^o^n
 "FIA",17.9001,0,10)
+
 "FIA",17.9001,0,11)
+
 "FIA",17.9001,0,"RLRO")
+
 "FIA",17.9001,0,"VR")
-0.1^MASH
+0.2^MASH
 "FIA",17.9001,17.9001)
 0
 "FIA",17.9001,17.90011)
@@ -178,77 +295,77 @@ y^y^f^^n^^y^o^n
 ZZUTPRE
 "INIT")
 ZZUTPOST
-"KRN",19,10068,-1)
+"KRN",19,11538,-1)
 0^1
-"KRN",19,10068,0)
+"KRN",19,11538,0)
 utMUNIT^M-Unit Tester^^B^^^^^^^^
-"KRN",19,10068,1,0)
+"KRN",19,11538,1,0)
 ^^1^1^3140805^
-"KRN",19,10068,1,1,0)
+"KRN",19,11538,1,1,0)
 This is the context option for M-Unit Test functionality.
-"KRN",19,10068,"RPC",0)
+"KRN",19,11538,"RPC",0)
 ^19.05P^3^3
-"KRN",19,10068,"RPC",1,0)
+"KRN",19,11538,"RPC",1,0)
 utMUNIT-TEST GROUP LOAD
-"KRN",19,10068,"RPC",2,0)
+"KRN",19,11538,"RPC",2,0)
 utMUNIT-TEST LOAD
-"KRN",19,10068,"RPC",3,0)
+"KRN",19,11538,"RPC",3,0)
 utMUNIT-TEST NEXT
-"KRN",19,10068,"U")
+"KRN",19,11538,"U")
 M-UNIT TESTER
-"KRN",19,10069,-1)
+"KRN",19,11539,-1)
 0^2
-"KRN",19,10069,0)
+"KRN",19,11539,0)
 utMUNIT GROUP EDIT^M-Unit Test Group Edit^^E^^^^^^^^TOOLKIT
-"KRN",19,10069,1,0)
+"KRN",19,11539,1,0)
 ^19.06^6^6^3031030^^^
-"KRN",19,10069,1,1,0)
+"KRN",19,11539,1,1,0)
 This option can be used to maintain a listing of unit tests related to a 
-"KRN",19,10069,1,2,0)
+"KRN",19,11539,1,2,0)
 specific topic.  The Group identifies the topic, and the unit tests 
-"KRN",19,10069,1,3,0)
+"KRN",19,11539,1,3,0)
 related to that topic are added in the multiple.  Unit Tests can be run 
-"KRN",19,10069,1,4,0)
+"KRN",19,11539,1,4,0)
 by selecting a group, and all unit tests included in the multiple will be 
-"KRN",19,10069,1,5,0)
+"KRN",19,11539,1,5,0)
 used for the test.  In addition, any other references under the XTROU tag 
-"KRN",19,10069,1,6,0)
+"KRN",19,11539,1,6,0)
 in any of the included test routines will be included in the run.
-"KRN",19,10069,30)
+"KRN",19,11539,30)
 %ut(17.9001,
-"KRN",19,10069,31)
+"KRN",19,11539,31)
 AEMQL
-"KRN",19,10069,50)
+"KRN",19,11539,50)
 17.9001
-"KRN",19,10069,51)
+"KRN",19,11539,51)
 .01;1
-"KRN",19,10069,"U")
+"KRN",19,11539,"U")
 M-UNIT TEST GROUP EDIT
-"KRN",19,10070,-1)
+"KRN",19,11540,-1)
 0^3
-"KRN",19,10070,0)
+"KRN",19,11540,0)
 utMUNIT GROUP RUN^Run M-Unit Tests From Test Groups^^R^^^^^^^^TOOLKIT
-"KRN",19,10070,1,0)
+"KRN",19,11540,1,0)
 ^^2^2^3031030^
-"KRN",19,10070,1,1,0)
+"KRN",19,11540,1,1,0)
 Provides a means of initiating a unit test run from the menu system based 
-"KRN",19,10070,1,2,0)
+"KRN",19,11540,1,2,0)
 on entries in the M-UNIT TEST GROUP file (#17.9001).
-"KRN",19,10070,25)
+"KRN",19,11540,25)
 PICKSET^%ut
-"KRN",19,10070,"U")
+"KRN",19,11540,"U")
 RUN M-UNIT TESTS FROM TEST GRO
-"KRN",8994,1866,-1)
+"KRN",8994,3261,-1)
 0^1
-"KRN",8994,1866,0)
+"KRN",8994,3261,0)
 utMUNIT-TEST GROUP LOAD^GUISET^%ut^4^^^^1
-"KRN",8994,1867,-1)
+"KRN",8994,3262,-1)
 0^2
-"KRN",8994,1867,0)
+"KRN",8994,3262,0)
 utMUNIT-TEST LOAD^GUILOAD^%ut^4^^^^1
-"KRN",8994,1868,-1)
+"KRN",8994,3263,-1)
 0^3
-"KRN",8994,1868,0)
+"KRN",8994,3263,0)
 utMUNIT-TEST NEXT^GUINEXT^%ut^4^^^^1
 "MBREQ")
 0
@@ -260,24 +377,68 @@ REMOTE PROCEDURE
 19;18;;;OPT^XPDTA;OPTF1^XPDIA;OPTE1^XPDIA;OPTF2^XPDIA;;OPTDEL^XPDIA
 "ORD",18,19,0)
 OPTION
-"PKG",201,-1)
+"PKG",222,-1)
 1^1
-"PKG",201,0)
+"PKG",222,0)
 MASH UTILITIES^%u^Utilities associated with the M Advanced Shell
-"PKG",201,20,0)
+"PKG",222,20,0)
 ^9.402P^^
-"PKG",201,22,0)
+"PKG",222,22,0)
 ^9.49I^1^1
-"PKG",201,22,1,0)
-0.1
-"PKG",201,22,1,"PAH",1,0)
-0^3140910^2802
-"PKG",201,22,1,"PAH",1,1,0)
-^^2^2^3140910
-"PKG",201,22,1,"PAH",1,1,1,0)
-M-Unit Test functionality to provide basic unit testing framework for M 
-"PKG",201,22,1,"PAH",1,1,2,0)
-development.
+"PKG",222,22,1,0)
+0.2
+"PKG",222,22,1,"PAH",1,0)
+0^3150703
+"PKG",222,22,1,"PAH",1,1,0)
+^^24^24^3150703
+"PKG",222,22,1,"PAH",1,1,1,0)
+Changes to functionality include:
+"PKG",222,22,1,"PAH",1,1,2,0)
+ 
+"PKG",222,22,1,"PAH",1,1,3,0)
+STARTUP and SHUTDOWN will be run in each routine instead of the first
+"PKG",222,22,1,"PAH",1,1,4,0)
+instance of STARTUP and SHUTDOWN encountered being the only ones that
+"PKG",222,22,1,"PAH",1,1,5,0)
+were run.  This change was made because of possible suites of tests
+"PKG",222,22,1,"PAH",1,1,6,0)
+which have their own STARTUP and SHUTDOWN that need to be run.  Also,
+"PKG",222,22,1,"PAH",1,1,7,0)
+it does not depend on the order in which test routines are run.
+"PKG",222,22,1,"PAH",1,1,8,0)
+ 
+"PKG",222,22,1,"PAH",1,1,9,0)
+While the coverage functionality can only be run on GT.M systems at
+"PKG",222,22,1,"PAH",1,1,10,0)
+the present time, the routine %utcover has been added to provide
+"PKG",222,22,1,"PAH",1,1,11,0)
+additional ability to run a number of unit tests at one time so that
+"PKG",222,22,1,"PAH",1,1,12,0)
+coverage across all of them can be obtained in one run, this includes
+"PKG",222,22,1,"PAH",1,1,13,0)
+the ability to specify entry at different APIs (e.g., if both verbose
+"PKG",222,22,1,"PAH",1,1,14,0)
+and nonverbose entries are available) as well as run code which is not
+"PKG",222,22,1,"PAH",1,1,15,0)
+part of a unit test to include in the analysis.  The routine %uttcovr
+"PKG",222,22,1,"PAH",1,1,16,0)
+uses this functionality to provide a means of doing coverage analysis
+"PKG",222,22,1,"PAH",1,1,17,0)
+on the %ut routines and can be used as an example of its usage.
+"PKG",222,22,1,"PAH",1,1,18,0)
+ 
+"PKG",222,22,1,"PAH",1,1,19,0)
+A new tag (COV) has been added to the %ut routine (it simply calls
+"PKG",222,22,1,"PAH",1,1,20,0)
+the one in %ut1) so that all user APIs can be accessed within the %ut
+"PKG",222,22,1,"PAH",1,1,21,0)
+routine.
+"PKG",222,22,1,"PAH",1,1,22,0)
+ 
+"PKG",222,22,1,"PAH",1,1,23,0)
+A potential problem with setting up the %ut namespace in the local 
+"PKG",222,22,1,"PAH",1,1,24,0)
+instance was addressed by Sam Habiel in the preinstall routine ZZUTPRE.
 "QUES","XPF1",0)
 Y
 "QUES","XPF1","??")
@@ -305,7 +466,7 @@ YO
 "QUES","XPI1","A")
 Want KIDS to INHIBIT LOGONs during the install
 "QUES","XPI1","B")
-YES
+NO
 "QUES","XPI1","M")
 D XPI1^XPDIQ
 "QUES","XPM1",0)
@@ -315,6 +476,7 @@ PO^VA(200,:EM
 "QUES","XPM1","A")
 Enter the Coordinator for Mail Group '|FLAG|'
 "QUES","XPM1","B")
+
 "QUES","XPM1","M")
 D XPM1^XPDIQ
 "QUES","XPO1",0)
@@ -324,7 +486,7 @@ Y
 "QUES","XPO1","A")
 Want KIDS to Rebuild Menu Trees Upon Completion of Install
 "QUES","XPO1","B")
-YES
+NO
 "QUES","XPO1","M")
 D XPO1^XPDIQ
 "QUES","XPZ1",0)
@@ -334,7 +496,7 @@ Y
 "QUES","XPZ1","A")
 Want to DISABLE Scheduled Options, Menu Options, and Protocols
 "QUES","XPZ1","B")
-YES
+NO
 "QUES","XPZ1","M")
 D XPZ1^XPDIQ
 "QUES","XPZ2",0)
@@ -348,377 +510,377 @@ NO
 "QUES","XPZ2","M")
 D XPZ2^XPDIQ
 "RTN")
-11
+12
 "RTN","ZZUTPOST")
-0^^B30449799
+0^^B39206871
 "RTN","ZZUTPOST",1,0)
-ut01POST ;VEN-SMH/JLI - post install for M-Unit Test software ;08/28/14  12:29
+ut01POST        ;VEN-SMH/JLI - post install for M-Unit Test software ;08/28/14  12:29
 "RTN","ZZUTPOST",2,0)
- ;;0.1;MASH UTILITIES
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","ZZUTPOST",3,0)
- N X,I
+        N X,I
 "RTN","ZZUTPOST",4,0)
- I +$SY=47 D  R X:$G(DTIME,300) D MES^XPDUTL(" ")
+        I +$SY=47 D  R X:$G(DTIME,300) D MES^XPDUTL(" ")
 "RTN","ZZUTPOST",5,0)
- . S X(1)=" "
+        . S X(1)=" "
 "RTN","ZZUTPOST",6,0)
- . S X(2)="In the next section, as it tries to copy the ut* routines"
+        . 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:"
+        . S X(3)="to %ut* routines watch for text that indicates the following:"
 "RTN","ZZUTPOST",8,0)
- . S X(4)=" "
+        . S X(4)=" "
 "RTN","ZZUTPOST",9,0)
- . S X(5)="cp: cannot create regular file `/_ut.m': Permission denied"
+        . S X(5)="cp: cannot create regular file `/_ut.m': Permission denied"
 "RTN","ZZUTPOST",10,0)
- . S X(6)=" "
+        . S X(6)=" "
 "RTN","ZZUTPOST",11,0)
- . S X(7)="If this is seen, respond Yes at the prompt after the attempt:"
+        . 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: "
+        . 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
+        . F I=1:1:18 D MES^XPDUTL(" ") ; create a blank screen for text
 "RTN","ZZUTPOST",14,0)
- . D MES^XPDUTL(.X)
+        . D MES^XPDUTL(.X)
 "RTN","ZZUTPOST",15,0)
- . Q
+        . Q
 "RTN","ZZUTPOST",16,0)
- D RENAME
+        D RENAME
 "RTN","ZZUTPOST",17,0)
- I +$SY=47 D  R X:$G(DTIME,300) I "Yy"[$E($G(X)) D GTMPROB
+        I +$SY=47 D  R X:$G(DTIME,300) I "Yy"[$E($G(X)) D GTMPROB
 "RTN","ZZUTPOST",18,0)
- . K X
+        . K X
 "RTN","ZZUTPOST",19,0)
- . S X(1)=" "
+        . S X(1)=" "
 "RTN","ZZUTPOST",20,0)
- . S X(2)="  Your entry on the next line may not echo"
+        . 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// "
+        . S X(3)="If error text was seen enter Y (and RETURN):  NO// "
 "RTN","ZZUTPOST",22,0)
- . D MES^XPDUTL(.X)
+        . D MES^XPDUTL(.X)
 "RTN","ZZUTPOST",23,0)
- . Q
+        . Q
 "RTN","ZZUTPOST",24,0)
- Q
+        Q
 "RTN","ZZUTPOST",25,0)
- ;
+        ;
 "RTN","ZZUTPOST",26,0)
-RENAME ;
+RENAME  ;
 "RTN","ZZUTPOST",27,0)
- N %S,%D ; Source, destination
+        N %S,%D ; Source, destination
 "RTN","ZZUTPOST",28,0)
- S U="^"
+        S U="^"
 "RTN","ZZUTPOST",29,0)
- S %S="ut^ut1^utt1^utt2^utt3^utt4^utt5^utt6^uttcovr"
+        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"
+        S %D="%ut^%ut1^%utt1^%utt2^%utt3^%utt4^%utt5^%utt6^%uttcovr"
 "RTN","ZZUTPOST",31,0)
- ;
+        ;
 "RTN","ZZUTPOST",32,0)
-MOVE ; rename % routines
+MOVE    ; rename % routines
 "RTN","ZZUTPOST",33,0)
- N %,X,Y,M
+        N %,X,Y,M
 "RTN","ZZUTPOST",34,0)
- F %=1:1:$L(%D,"^") D  D MES(M) I +$SY=47 D MES(" ")
+        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
+        . S M="",X=$P(%S,U,%) ; from
 "RTN","ZZUTPOST",36,0)
- . S Y=$P(%D,U,%) ; to
+        . S Y=$P(%D,U,%) ; to
 "RTN","ZZUTPOST",37,0)
- . Q:X=""
+        . Q:X=""
 "RTN","ZZUTPOST",38,0)
- . S M="Routine: "_$J(X,8)
+        . S M="Routine: "_$J(X,8)
 "RTN","ZZUTPOST",39,0)
- . Q:Y=""  I $T(^@X)=""  S M=M_"  Missing" Q
+        . Q:Y=""  I $T(^@X)=""  S M=M_"  Missing" Q
 "RTN","ZZUTPOST",40,0)
- . S M=M_" Loaded, "
+        . S M=M_" Loaded, "
 "RTN","ZZUTPOST",41,0)
- . D COPY(X,Y)
+        . D COPY(X,Y)
 "RTN","ZZUTPOST",42,0)
- . S M=M_"Saved as "_$J(Y,8)
+        . S M=M_"Saved as "_$J(Y,8)
 "RTN","ZZUTPOST",43,0)
- ;
+        ;
 "RTN","ZZUTPOST",44,0)
- QUIT  ; END
+        QUIT  ; END
 "RTN","ZZUTPOST",45,0)
- ;
+        ;
 "RTN","ZZUTPOST",46,0)
-COPY(FROM,TO) ;
+COPY(FROM,TO)   ;
 "RTN","ZZUTPOST",47,0)
- N XVAL
+        N XVAL
 "RTN","ZZUTPOST",48,0)
- I +$SYSTEM=0 S XVAL="ZL @FROM ZS @TO" X XVAL QUIT
+        I +$SYSTEM=0 S XVAL="ZL @FROM ZS @TO" X XVAL QUIT
 "RTN","ZZUTPOST",49,0)
- I +$SYSTEM=47 DO  QUIT
+        I +$SYSTEM=47 DO  QUIT
 "RTN","ZZUTPOST",50,0)
- . S FROM=$$PATH(FROM)
+        . S FROM=$$PATH(FROM)
 "RTN","ZZUTPOST",51,0)
- . S TO=$$PATH(TO,"WRITE")
+        . S TO=$$PATH(TO,"WRITE")
 "RTN","ZZUTPOST",52,0)
- . N CMD S CMD="cp "_FROM_" "_TO
+        . N CMD S CMD="cp "_FROM_" "_TO
 "RTN","ZZUTPOST",53,0)
- . O "cp":(shell="/bin/sh":command=CMD:WRITEONLY)::"PIPE"
+        . O "cp":(shell="/bin/sh":command=CMD:WRITEONLY)::"PIPE"
 "RTN","ZZUTPOST",54,0)
- . U "cp" C "cp"
+        . U "cp" C "cp"
 "RTN","ZZUTPOST",55,0)
- QUIT
+        QUIT
 "RTN","ZZUTPOST",56,0)
- ;
+        ;
 "RTN","ZZUTPOST",57,0)
-PATH(ROUTINE,MODE) ; for GT.M return source file with path for a routine
+PATH(ROUTINE,MODE)      ; for GT.M return source file with path for a routine
 "RTN","ZZUTPOST",58,0)
- ;input: ROUTINE=Name of routine
+        ;input: ROUTINE=Name of routine
 "RTN","ZZUTPOST",59,0)
- ;       MODE="READ" or "WRITE" defaults to READ
+        ;       MODE="READ" or "WRITE" defaults to READ
 "RTN","ZZUTPOST",60,0)
- ;output: Full filename
+        ;output: Full filename
 "RTN","ZZUTPOST",61,0)
- ;
+        ;
 "RTN","ZZUTPOST",62,0)
- S MODE=$G(MODE,"READ") ;set MODE to default value
+        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
+        N FILE S FILE=$TR(ROUTINE,"%","_")_".m" ;convert rtn name to filename
 "RTN","ZZUTPOST",64,0)
- N ZRO S ZRO=$ZRO
+        N ZRO S ZRO=$ZRO
 "RTN","ZZUTPOST",65,0)
- ;
+        ;
 "RTN","ZZUTPOST",66,0)
- ; Get source routine
+        ; Get source routine
 "RTN","ZZUTPOST",67,0)
- N %ZR
+        N %ZR
 "RTN","ZZUTPOST",68,0)
- I MODE="READ" D SILENT^%RSEL(ROUTINE,"SRC") Q %ZR(ROUTINE)_FILE
+        I MODE="READ" D SILENT^%RSEL(ROUTINE,"SRC") Q %ZR(ROUTINE)_FILE
 "RTN","ZZUTPOST",69,0)
- ;
+        ;
 "RTN","ZZUTPOST",70,0)
- ; We are writing. Parse directories and get 1st routine directory
+        ; We are writing. Parse directories and get 1st routine directory
 "RTN","ZZUTPOST",71,0)
- N DIRS
+        N DIRS
 "RTN","ZZUTPOST",72,0)
- D PARSEZRO(.DIRS,ZRO)
+        D PARSEZRO(.DIRS,ZRO)
 "RTN","ZZUTPOST",73,0)
- N PATH S PATH=$$ZRO1ST(.DIRS)
+        N PATH S PATH=$$ZRO1ST(.DIRS)
 "RTN","ZZUTPOST",74,0)
- ;
+        ;
 "RTN","ZZUTPOST",75,0)
- QUIT PATH_FILE ;end of PATH return directory and filename
+        QUIT PATH_FILE ;end of PATH return directory and filename
 "RTN","ZZUTPOST",76,0)
- ;
+        ;
 "RTN","ZZUTPOST",77,0)
- ;
+        ;
 "RTN","ZZUTPOST",78,0)
-PARSEZRO(DIRS,ZRO) ; Parse $zroutines properly into an array
+PARSEZRO(DIRS,ZRO)      ; Parse $zroutines properly into an array
 "RTN","ZZUTPOST",79,0)
- N PIECE
+        N PIECE
 "RTN","ZZUTPOST",80,0)
- N I
+        N I
 "RTN","ZZUTPOST",81,0)
- F I=1:1:$L(ZRO," ") S PIECE(I)=$P(ZRO," ",I)
+        F I=1:1:$L(ZRO," ") S PIECE(I)=$P(ZRO," ",I)
 "RTN","ZZUTPOST",82,0)
- N CNT S CNT=1
+        N CNT S CNT=1
 "RTN","ZZUTPOST",83,0)
- F I=0:0 S I=$O(PIECE(I)) Q:'I  D
+        F I=0:0 S I=$O(PIECE(I)) Q:'I  D
 "RTN","ZZUTPOST",84,0)
- . S DIRS(CNT)=$G(DIRS(CNT))_PIECE(I)
+        . S DIRS(CNT)=$G(DIRS(CNT))_PIECE(I)
 "RTN","ZZUTPOST",85,0)
- . I DIRS(CNT)["("&(DIRS(CNT)[")") S CNT=CNT+1 QUIT
+        . I DIRS(CNT)["("&(DIRS(CNT)[")") S CNT=CNT+1 QUIT
 "RTN","ZZUTPOST",86,0)
- . I DIRS(CNT)'["("&(DIRS(CNT)'[")") S CNT=CNT+1 QUIT
+        . I DIRS(CNT)'["("&(DIRS(CNT)'[")") S CNT=CNT+1 QUIT
 "RTN","ZZUTPOST",87,0)
- . S DIRS(CNT)=DIRS(CNT)_" " ; prep for next piece
+        . S DIRS(CNT)=DIRS(CNT)_" " ; prep for next piece
 "RTN","ZZUTPOST",88,0)
- QUIT
+        QUIT
 "RTN","ZZUTPOST",89,0)
- ;
+        ;
 "RTN","ZZUTPOST",90,0)
-ZRO1ST(DIRS) ; $$ Get first routine directory
+ZRO1ST(DIRS)    ; $$ Get first routine directory
 "RTN","ZZUTPOST",91,0)
- N OUT ; $$ return
+        N OUT ; $$ return
 "RTN","ZZUTPOST",92,0)
- N %1 S %1=DIRS(1) ; 1st directory
+        N %1 S %1=DIRS(1) ; 1st directory
 "RTN","ZZUTPOST",93,0)
- ; Parse with (...)
+        ; Parse with (...)
 "RTN","ZZUTPOST",94,0)
- I %1["(" DO
+        I %1["(" DO
 "RTN","ZZUTPOST",95,0)
- . S OUT=$P(%1,"(",2)
+        . S OUT=$P(%1,"(",2)
 "RTN","ZZUTPOST",96,0)
- . I OUT[" " S OUT=$P(OUT," ")
+        . I OUT[" " S OUT=$P(OUT," ")
 "RTN","ZZUTPOST",97,0)
- . E  S OUT=$P(OUT,")")
+        . E  S OUT=$P(OUT,")")
 "RTN","ZZUTPOST",98,0)
- ; no parens
+        ; no parens
 "RTN","ZZUTPOST",99,0)
- E  S OUT=%1
+        E  S OUT=%1
 "RTN","ZZUTPOST",100,0)
- ;
+        ;
 "RTN","ZZUTPOST",101,0)
- ; Add trailing slash
+        ; Add trailing slash
 "RTN","ZZUTPOST",102,0)
- I $E(OUT,$L(OUT))'="/" S OUT=OUT_"/"
+        I $E(OUT,$L(OUT))'="/" S OUT=OUT_"/"
 "RTN","ZZUTPOST",103,0)
- QUIT OUT
+        QUIT OUT
 "RTN","ZZUTPOST",104,0)
- ;
+        ;
 "RTN","ZZUTPOST",105,0)
-MES(T,B) ;Write message.
+MES(T,B)        ;Write message.
 "RTN","ZZUTPOST",106,0)
- S B=$G(B)
+        S B=$G(B)
 "RTN","ZZUTPOST",107,0)
- I $L($T(BMES^XPDUTL)) D BMES^XPDUTL(T):B,MES^XPDUTL(T):'B Q
+        I $L($T(BMES^XPDUTL)) D BMES^XPDUTL(T):B,MES^XPDUTL(T):'B Q
 "RTN","ZZUTPOST",108,0)
- W:B ! W !,T
+        W:B ! W !,T
 "RTN","ZZUTPOST",109,0)
- Q
+        Q
 "RTN","ZZUTPOST",110,0)
- ;
+        ;
 "RTN","ZZUTPOST",111,0)
-TEST ; @TEST - TESTING TESTING
+TEST    ; @TEST - TESTING TESTING
 "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"
+        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)
+        N DIRS D PARSEZRO(.DIRS,ZR)
 "RTN","ZZUTPOST",115,0)
- N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+        N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
 "RTN","ZZUTPOST",116,0)
- I FIRSTDIR'="p" S $EC=",U1,"
+        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"
+        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)
+        N DIRS D PARSEZRO(.DIRS,ZR)
 "RTN","ZZUTPOST",120,0)
- N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+        N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
 "RTN","ZZUTPOST",121,0)
- I FIRSTDIR'="/var/abc/r/" S $EC=",U1,"
+        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"
+        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)
+        N DIRS D PARSEZRO(.DIRS,ZR)
 "RTN","ZZUTPOST",125,0)
- N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+        N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
 "RTN","ZZUTPOST",126,0)
- I FIRSTDIR'="/abc/def" S $EC=",U1,"
+        I FIRSTDIR'="/abc/def" S $EC=",U1,"
 "RTN","ZZUTPOST",127,0)
- ;
+        ;
 "RTN","ZZUTPOST",128,0)
- WRITE "All tests have run successfully!",!
+        WRITE "All tests have run successfully!",!
 "RTN","ZZUTPOST",129,0)
- QUIT
+        QUIT
 "RTN","ZZUTPOST",130,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
+        N X
 "RTN","ZZUTPOST",133,0)
- S X(1)=" "
+        S X(1)=" "
 "RTN","ZZUTPOST",134,0)
- S X(2)="*** An error occurred during renaming of routines to %ut*."
+        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."
+        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"
+        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 "
+        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',"
+        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"
+        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"
+        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."
+        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"
+        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"
+        S X(11)="*** the %ut and %ut1 routines to confirm they are working"
 "RTN","ZZUTPOST",144,0)
- S X(12)=" "
+        S X(12)=" "
 "RTN","ZZUTPOST",145,0)
- S X(13)="  Press Enter to continue: "
+        S X(13)="  Press Enter to continue: "
 "RTN","ZZUTPOST",146,0)
- D MES^XPDUTL(.X)
+        D MES^XPDUTL(.X)
 "RTN","ZZUTPOST",147,0)
- R X:$G(DTIME,300)
+        R X:$G(DTIME,300)
 "RTN","ZZUTPOST",148,0)
- Q
+        Q
 "RTN","ZZUTPRE")
-0^^B3651860
+0^^B6741733
 "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
 "RTN","ZZUTPRE",2,0)
- ;;0.1;MASH UTILITIES
+ ;;0.2;MASH UTILITIES;;;Build 5
 "RTN","ZZUTPRE",3,0)
- ;
+        ;
 "RTN","ZZUTPRE",4,0)
- ; The following is used to create, if it does not exist, the MASH UTILITIES
+        ; The following is used to create, if it does not exist, the MASH UTILITIES
 "RTN","ZZUTPRE",5,0)
- ; package, and to assign the %u namespace to this package.  This special
+        ; 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
+        ; processing is necessary, since the input transform currently will not accept a
 "RTN","ZZUTPRE",7,0)
- ; % or lower case character in the namespace.
+        ; % or lower case character in the namespace.
 "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
+        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",9,0)
- ; and if necessary, as in CACHE, map %ut routine and namespace in the current account.
+        ; and if necessary, as in CACHE, map %ut routine and namespace in the current account.
 "RTN","ZZUTPRE",10,0)
- I +$SY=0 D CACHEMAP ; This routine is CACHE specific
+        I +$SY=0 D CACHEMAP ; This routine is CACHE specific
 "RTN","ZZUTPRE",11,0)
- Q
+        Q
 "RTN","ZZUTPRE",12,0)
- ; The following code was provided by Sam Habiel to map %
+        ; The following code was provided by Sam Habiel to map %
 "RTN","ZZUTPRE",13,0)
-CACHEMAP ; Map %ut* Globals and Routines away from %SYS in Cache
+CACHEMAP        ; Map %ut* Globals and Routines away from %SYS in Cache
 "RTN","ZZUTPRE",14,0)
- ; Get current namespace
+        ; Get current namespace
 "RTN","ZZUTPRE",15,0)
- N NMSP
+        N NMSP
 "RTN","ZZUTPRE",16,0)
- I $P($P($ZV,") ",2),"(")<2012 S NMSP=$ZU(5)
+        I $P($P($ZV,") ",2),"(")<2012 S NMSP=$ZU(5)
 "RTN","ZZUTPRE",17,0)
- I $P($P($ZV,") ",2),"(")>2011 S NMSP=$NAMESPACE
+        I $P($P($ZV,") ",2),"(")>2011 S NMSP=$NAMESPACE
 "RTN","ZZUTPRE",18,0)
- ;
+        ;
 "RTN","ZZUTPRE",19,0)
- ; Map %ut globals away from %SYS
+        ; Map %ut globals away from %SYS
 "RTN","ZZUTPRE",20,0)
- ZN "%SYS" ; Go to SYS
+        ZN "%SYS" ; Go to SYS
 "RTN","ZZUTPRE",21,0)
- N % S %=##class(Config.Configuration).GetGlobalMapping(NMSP,"%ut*","",NMSP,NMSP)
+        N % S %=##class(Config.Configuration).GetGlobalMapping(NMSP,"%ut*","",NMSP,NMSP)
 "RTN","ZZUTPRE",22,0)
- I '% S %=##class(Config.Configuration).AddGlobalMapping(NMSP,"%ut*","",NMSP,NMSP)
+        I '% S %=##class(Config.Configuration).AddGlobalMapping(NMSP,"%ut*","",NMSP,NMSP)
 "RTN","ZZUTPRE",23,0)
- I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) QUIT
+        I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) QUIT
 "RTN","ZZUTPRE",24,0)
- ;
+        ;
 "RTN","ZZUTPRE",25,0)
- ; Map %ut routines away from %SYS
+        ; Map %ut routines away from %SYS
 "RTN","ZZUTPRE",26,0)
- N A S A("Database")=NMSP
+        N A S A("Database")=NMSP
 "RTN","ZZUTPRE",27,0)
- N % S %=##Class(Config.MapRoutines).Get(NMSP,"%ut*",.A)
+        N % S %=##Class(Config.MapRoutines).Get(NMSP,"%ut*",.A)
 "RTN","ZZUTPRE",28,0)
- S A("Database")=NMSP
+        S A("Database")=NMSP
 "RTN","ZZUTPRE",29,0)
- I '% S %=##Class(Config.MapRoutines).Create(NMSP,"%ut*",.A)
+        I '% S %=##Class(Config.MapRoutines).Create(NMSP,"%ut*",.A)
 "RTN","ZZUTPRE",30,0)
- I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) QUIT
+        I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) QUIT
 "RTN","ZZUTPRE",31,0)
- ZN NMSP ; Go back
+        ZN NMSP ; Go back
 "RTN","ZZUTPRE",32,0)
- QUIT
+        QUIT
 "RTN","ut")
-0^1^B257937062
+0^1^B268535658
 "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 ; 7/2/15 1:12pm
 "RTN","ut",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","ut",3,0)
  ;
 "RTN","ut",4,0)
@@ -800,901 +962,903 @@ CACHEMAP ; Map %ut* Globals and Routines away from %SYS in Cache
 "RTN","ut",42,0)
  ;              Created M-UNIT TEST GROUP file at 17.9001 based on the 17.9001 file
 "RTN","ut",43,0)
- Q
+ ; 141030 JLI - Removed tag TESTCOVR and code under it, not necessary
 "RTN","ut",44,0)
- ;
+ ;              since %uttcovr can handle all of the calling needed
 "RTN","ut",45,0)
-EN(%utRNAM,%utVERB,%utBREAK) ; .SR Entry point with primary test routine name, optional 1 for verbose output
+ ;              Added call to run routine %utt6 if run from the top,
 "RTN","ut",46,0)
- N %utLIST,%utROU,%ut
+ ;              since this will run the full range of unit tests
 "RTN","ut",47,0)
- I '+$G(%utVERB) S %utVERB=0
+ ;              Modified STARTUP and SHUTDOWN commands to handle in
 "RTN","ut",48,0)
- S %utLIST=1,%utROU(%utLIST)=%utRNAM
+ ;              each routine where they are available, since only
 "RTN","ut",49,0)
- D SETUT
+ ;              running one STARTUP and SHUTDOWN (the first seen by
 "RTN","ut",50,0)
- D EN1(.%utROU,%utLIST)
+ ;              the program) restricted their use in suites of multiple
 "RTN","ut",51,0)
- Q
+ ;              tests.
 "RTN","ut",52,0)
- ;
+ ; 150101 JLI - Added COV entry to %ut (in addition to current in %ut1) so it is easier
 "RTN","ut",53,0)
-SETUT ;
+ ;              to remember how to use it.
 "RTN","ut",54,0)
- ; VEN/SMH 26JUL2013
+ ; 150621 JLI - Added a global location to pick up summary data for a unit test call, so
 "RTN","ut",55,0)
- I '($D(IO)#2) S IO=$P
+ ;              programs running multiple calls can generate a summary if desired.
 "RTN","ut",56,0)
- S U="^"
+ D ^%utt6 ; runs unit tests on all of it
 "RTN","ut",57,0)
- ; VEN/SMH 26JUL2013 END
+ Q
 "RTN","ut",58,0)
  ;
 "RTN","ut",59,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+EN(%utRNAM,%utVERB,%utBREAK) ; .SR Entry point with primary test routine name, optional 1 for verbose output
 "RTN","ut",60,0)
- S %ut("IO")=IO
+ N %utLIST,%utROU,%ut
 "RTN","ut",61,0)
- S %ut=1 ; set to identify unit test being run check with $$ISUTEST^%ut()
+ I '+$G(%utVERB) S %utVERB=0
 "RTN","ut",62,0)
- ;
+ S %utLIST=1,%utROU(%utLIST)=%utRNAM
 "RTN","ut",63,0)
- ; ZEXCEPT: %utBREAK
+ K ^TMP("%ut",$J,"UTVALS")
 "RTN","ut",64,0)
- I $G(%utBREAK) S %ut("BREAK")=1
+ D SETUT
 "RTN","ut",65,0)
- Q
+ D EN1(.%utROU,%utLIST)
 "RTN","ut",66,0)
- ;
+ Q
 "RTN","ut",67,0)
-EN1(%utROU,%utLIST) ;
+ ;
 "RTN","ut",68,0)
- ; VEN/SMH 26JUL2013 - This block is refactored to fix problems with
+SETUT ;
 "RTN","ut",69,0)
- ; SETUP and TEARDOWN not happening at the right time
+ ; VEN/SMH 26JUL2013
 "RTN","ut",70,0)
- N %utERRL,%utK,%utI,%utJ,%utSTRT
+ I '($D(IO)#2) S IO=$P
 "RTN","ut",71,0)
- ; ZEXCEPT: %utVERB   -- ARGUMENT TO EN
+ S U="^"
 "RTN","ut",72,0)
- ; ZEXCEPT: %utGUI      -- CONDITIONALLY DEFINED BY GUINEXT
+ ; VEN/SMH 26JUL2013 END
 "RTN","ut",73,0)
- ; ZEXCEPT: %ut  -- NEWED IN EN
+ ;
 "RTN","ut",74,0)
- ;
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
 "RTN","ut",75,0)
- ; Structure map for %ut
+ S %ut("IO")=IO
 "RTN","ut",76,0)
- ; -- CURR = Counter for routine number. Used as sub in %utROU
+ S %ut=1 ; set to identify unit test being run check with $$ISUTEST^%ut()
 "RTN","ut",77,0)
- ; -- ECNT = Entry point count in loop (cf. NERT); VEN/SMH - Needed?
+ ;
 "RTN","ut",78,0)
- ; -- FAIL = Number of failures
+ ; ZEXCEPT: %utBREAK
 "RTN","ut",79,0)
- ; -- CHK  = Number of checks ran (TF/EQ/FAIL)
+ I $G(%utBREAK) S %ut("BREAK")=1
 "RTN","ut",80,0)
- ; -- NENT = Number of entry points ran
+ Q
 "RTN","ut",81,0)
- ; -- ERRN = Number of errors
+ ;
 "RTN","ut",82,0)
- S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
+EN1(%utROU,%utLIST) ;
 "RTN","ut",83,0)
- ;
+ ; VEN/SMH 26JUL2013 - This block is refactored to fix problems with
 "RTN","ut",84,0)
- ; -- GET LIST OF ROUTINES --
+ ; SETUP and TEARDOWN not happening at the right time
 "RTN","ut",85,0)
- ; first get any tree of routines from this one
+ N %utERRL,%utK,%utI,%utJ,%utSTRT
 "RTN","ut",86,0)
- D GETTREE^%ut1(.%utROU,.%utLIST)
+ ; ZEXCEPT: %utVERB   -- ARGUMENT TO EN
 "RTN","ut",87,0)
- ;
+ ; ZEXCEPT: %utGUI      -- CONDITIONALLY DEFINED BY GUINEXT
 "RTN","ut",88,0)
- ; -- STARTUP --
+ ; ZEXCEPT: %ut  -- NEWED IN EN
 "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
+ ; Structure map for %ut
 "RTN","ut",91,0)
- . I $T(@("STARTUP^"_%utROU(%ut("CURR"))))'="" S %utSTRT="STARTUP^"_%utROU(%ut("CURR"))
+ ; -- CURR = Counter for routine number. Used as sub in %utROU
 "RTN","ut",92,0)
- . Q
+ ; -- ECNT = Entry point count in loop (cf. NERT); VEN/SMH - Needed?
 "RTN","ut",93,0)
- ; 070224 - end of addition JLI
+ ; -- FAIL = Number of failures
 "RTN","ut",94,0)
- ;
+ ; -- CHK  = Number of checks ran (TF/EQ/FAIL)
 "RTN","ut",95,0)
- ;
+ ; -- NENT = Number of entry points ran
 "RTN","ut",96,0)
- ; Now process each routine that has been referenced
+ ; -- ERRN = Number of errors
 "RTN","ut",97,0)
- S %ut("CURR")=0
+ S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
 "RTN","ut",98,0)
- F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D
+ ;
 "RTN","ut",99,0)
- . N %utETRY ; Test list to run
+ ; -- GET LIST OF ROUTINES --
 "RTN","ut",100,0)
- . ;
+ ; first get any tree of routines from this one
 "RTN","ut",101,0)
- . ; Collect Test list.
+ D GETTREE^%ut1(.%utROU,.%utLIST)
 "RTN","ut",102,0)
- . D CHEKTEST^%ut1(%utROU(%ut("CURR")),.%ut,.%utETRY)
+ ;
 "RTN","ut",103,0)
- . ;
+ ; Now process each routine that has been referenced
 "RTN","ut",104,0)
- . ; if a SETUP entry point exists, save it off in %ut
+ N CURRROU
 "RTN","ut",105,0)
- . N %utSETUP S %utSETUP="SETUP^"_%utROU(%ut("CURR"))
+ S %ut("CURR")=0
 "RTN","ut",106,0)
- . S %ut("LINE")=$T(@%utSETUP) I %ut("LINE")'="" S %ut("SETUP")=%utSETUP
+ 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",107,0)
- . K %utSETUP ; we're done!
+ . ; 141018 - add ability to run STARTUP and SHUTDOWN in each routine JLI
 "RTN","ut",108,0)
- . ;
+ . I $T(@("STARTUP^"_CURRROU))'="" D @("STARTUP^"_CURRROU) ; 141018
 "RTN","ut",109,0)
- . ; if a TEARDOWN entry point exists, ditto
+ . N %utETRY ; Test list to run
 "RTN","ut",110,0)
- . N %utTEARDOWN S %utTEARDOWN="TEARDOWN^"_%utROU(%ut("CURR"))
+ . ;
 "RTN","ut",111,0)
- . S %ut("LINE")=$T(@%utTEARDOWN) I %ut("LINE")'="" S %ut("TEARDOWN")=%utTEARDOWN
+ . ; Collect Test list.
 "RTN","ut",112,0)
- . K %utTEARDOWN ; done here.
+ . D CHEKTEST^%ut1(%utROU(%ut("CURR")),.%ut,.%utETRY)
 "RTN","ut",113,0)
  . ;
 "RTN","ut",114,0)
- . ; VEN/SMH 26JUL2013 - this block changed to correct running of setup and teardown
+ . ; if a SETUP entry point exists, save it off in %ut
 "RTN","ut",115,0)
- . ; run each of the specified entry points
+ . S %ut("SETUP")="" ; 141018 need to clear any previous values JLI
 "RTN","ut",116,0)
- . ;
+ . N %utSETUP S %utSETUP="SETUP^"_%utROU(%ut("CURR"))
 "RTN","ut",117,0)
- . ; == THIS FOR/DO BLOCK IS THE CENTRAL TEST RUNNER ==
+ . S %ut("LINE")=$T(@%utSETUP) I %ut("LINE")'="" S %ut("SETUP")=%utSETUP
 "RTN","ut",118,0)
- . S %utI=0
+ . K %utSETUP ; we're done!
 "RTN","ut",119,0)
- . F  S %utI=$O(%utETRY(%utI)) Q:%utI'>0  S %ut("ENUM")=%ut("ERRN")+%ut("FAIL") D
+ . ;
 "RTN","ut",120,0)
- . . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . ; if a TEARDOWN entry point exists, ditto
 "RTN","ut",121,0)
- . . ;
+ . S %ut("TEARDOWN")="" ; 141018 need to clear any previous values JLI
 "RTN","ut",122,0)
- . . ; Run Set-up Code (only if present)
+ . N %utTEARDOWN S %utTEARDOWN="TEARDOWN^"_%utROU(%ut("CURR"))
 "RTN","ut",123,0)
- . . S %ut("ENT")=$G(%ut("SETUP")) ; Current entry
+ . S %ut("LINE")=$T(@%utTEARDOWN) I %ut("LINE")'="" S %ut("TEARDOWN")=%utTEARDOWN
 "RTN","ut",124,0)
- . . S %ut("NAME")="Set-up Code"
+ . K %utTEARDOWN ; done here.
 "RTN","ut",125,0)
- . . D:%ut("ENT")]"" @%ut("ENT")
+ . ;
 "RTN","ut",126,0)
- . . ;
+ . ; VEN/SMH 26JUL2013 - this block changed to correct running of setup and teardown
 "RTN","ut",127,0)
- . . ; Run actual test
+ . ; run each of the specified entry points
 "RTN","ut",128,0)
- . . S %ut("ECNT")=%ut("ECNT")+1
+ . ;
 "RTN","ut",129,0)
- . . S %ut("NAME")=%utETRY(%utI,"NAME")
+ . ; == THIS FOR/DO BLOCK IS THE CENTRAL TEST RUNNER ==
 "RTN","ut",130,0)
- . . S %ut("ENT")=%utETRY(%utI)_"^"_%utROU(%ut("CURR"))
+ . S %utI=0
 "RTN","ut",131,0)
- . . I %utVERB,'$D(%utGUI) D VERBOSE1(.%utETRY,%utI) ; Say what we executed.
+ . F  S %utI=$O(%utETRY(%utI)) Q:%utI'>0  S %ut("ENUM")=%ut("ERRN")+%ut("FAIL") D
 "RTN","ut",132,0)
- . . D @%ut("ENT")
+ . . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",133,0)
  . . ;
 "RTN","ut",134,0)
- . . ; Run Teardown Code (only if present)
+ . . ; Run Set-up Code (only if present)
 "RTN","ut",135,0)
- . . S %ut("ENT")=$G(%ut("TEARDOWN"))
+ . . S %ut("ENT")=$G(%ut("SETUP")) ; Current entry
 "RTN","ut",136,0)
- . . S %ut("NAME")="Teardown Code"
+ . . S %ut("NAME")="Set-up Code"
 "RTN","ut",137,0)
  . . D:%ut("ENT")]"" @%ut("ENT")
 "RTN","ut",138,0)
  . . ;
 "RTN","ut",139,0)
- . . ; ENUM = Number of errors + failures
+ . . ; Run actual test
 "RTN","ut",140,0)
- . . ; Only print out the success message [OK] If our error number remains
+ . . S %ut("ECNT")=%ut("ECNT")+1
 "RTN","ut",141,0)
- . . ; the same as when we started the loop.
+ . . S %ut("NAME")=%utETRY(%utI,"NAME")
 "RTN","ut",142,0)
- . . I %utVERB,'$D(%utGUI) D
+ . . S %ut("ENT")=%utETRY(%utI)_"^"_%utROU(%ut("CURR"))
 "RTN","ut",143,0)
- . . . I %ut("ENUM")=(%ut("ERRN")+%ut("FAIL")) D VERBOSE(.%utETRY,%utI,1) I 1
+ . . I %utVERB,'$D(%utGUI) D VERBOSE1(.%utETRY,%utI) ; Say what we executed.
 "RTN","ut",144,0)
- . . . E  D VERBOSE(.%utETRY,%utI,0)
+ . . D @%ut("ENT")
 "RTN","ut",145,0)
- . ;
+ . . ;
 "RTN","ut",146,0)
- . ;
+ . . ; Run Teardown Code (only if present)
 "RTN","ut",147,0)
- . ; keep a %utCNT of number of entry points executed across all routines
+ . . S %ut("ENT")=$G(%ut("TEARDOWN"))
 "RTN","ut",148,0)
- . S %ut("NENT")=%ut("NENT")+%ut("ENTN")
+ . . S %ut("NAME")="Teardown Code"
 "RTN","ut",149,0)
- . Q
+ . . D:%ut("ENT")]"" @%ut("ENT")
 "RTN","ut",150,0)
- ;
+ . . ;
 "RTN","ut",151,0)
- ; -- SHUTDOWN --
+ . . ; ENUM = Number of errors + failures
 "RTN","ut",152,0)
- ; 070224 - following code added to allow one overall SHUTDOWN code JLI
+ . . ; Only print out the success message [OK] If our error number remains
 "RTN","ut",153,0)
- N XTFINISH
+ . . ; the same as when we started the loop.
 "RTN","ut",154,0)
- S %ut("CURR")=0
+ . . I %utVERB,'$D(%utGUI) D
 "RTN","ut",155,0)
- F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D  I $G(XTFINISH)'="" D @XTFINISH Q
+ . . . I %ut("ENUM")=(%ut("ERRN")+%ut("FAIL")) D VERBOSE(.%utETRY,%utI,1) I 1
 "RTN","ut",156,0)
- . I $T(@("SHUTDOWN^"_%utROU(%ut("CURR"))))'="" S XTFINISH="SHUTDOWN^"_%utROU(%ut("CURR"))
+ . . . E  D VERBOSE(.%utETRY,%utI,0)
 "RTN","ut",157,0)
- . Q
+ . ;
 "RTN","ut",158,0)
- ; 070224 - End of addition JLI
+ . ;
 "RTN","ut",159,0)
- ; and output the results
+ . ; keep a %utCNT of number of entry points executed across all routines
 "RTN","ut",160,0)
- D SETIO
+ . S %ut("NENT")=%ut("NENT")+%ut("ENTN")
 "RTN","ut",161,0)
- W !!,"Ran ",%utLIST," Routine",$S(%utLIST>1:"s",1:""),", ",%ut("NENT")," Entry Tag",$S(%ut("NENT")>1:"s",1:"")
+ . Q
 "RTN","ut",162,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
+ ; -- SHUTDOWN --
 "RTN","ut",164,0)
- Q
+ D SETIO
 "RTN","ut",165,0)
- ; -- end EN1
+ W !!,"Ran ",%utLIST," Routine",$S(%utLIST>1:"s",1:""),", ",%ut("NENT")," Entry Tag",$S(%ut("NENT")>1:"s",1:"")
 "RTN","ut",166,0)
-VERBOSE(%utETRY,%utI,SUCCESS) ; Say whether we succeeded or failed.
+ 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",167,0)
- ; ZEXCEPT: %ut - NEWED IN EN
+ 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",168,0)
- D SETIO
+ D RESETIO
 "RTN","ut",169,0)
- N I F I=$X+3:1:73 W "-"
+ Q
 "RTN","ut",170,0)
- W ?73
+ ; -- end EN1
 "RTN","ut",171,0)
- I $G(SUCCESS) W "[OK]"
+VERBOSE(%utETRY,%utI,SUCCESS) ; Say whether we succeeded or failed.
 "RTN","ut",172,0)
- E  W "[FAIL]"
+ ; ZEXCEPT: %ut - NEWED IN EN
 "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)
+"RTN","ut",174,0)
+ N I F I=$X+3:1:73 W "-"
+"RTN","ut",175,0)
+ W ?73
+"RTN","ut",176,0)
+ I $G(SUCCESS) W "[OK]"
+"RTN","ut",177,0)
+ E  W "[FAIL]"
+"RTN","ut",178,0)
  D RESETIO
+"RTN","ut",179,0)
+ Q
+"RTN","ut",180,0)
+ ;
 "RTN","ut",181,0)
- Q
+VERBOSE1(%utETRY,%utI) ; Print out the entry point info
 "RTN","ut",182,0)
-CHKTF(XTSTVAL,XTERMSG) ; Entry point for checking True or False values
+ ; ZEXCEPT: %ut - NEWED IN EN
 "RTN","ut",183,0)
- ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
+ D SETIO
 "RTN","ut",184,0)
- ; ZEXCEPT: %ut - NEWED IN EN
+ W !,%utETRY(%utI) I $G(%utETRY(%utI,"NAME"))'="" W " - ",%utETRY(%utI,"NAME")
 "RTN","ut",185,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ D RESETIO
 "RTN","ut",186,0)
- I '$D(XTSTVAL) D NVLDARG Q
+ 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
+CHKTF(XTSTVAL,XTERMSG) ; Entry point for checking True or False values
 "RTN","ut",189,0)
- I '$D(%utGUI) D
-"RTN","ut",190,0)
- . D SETIO
-"RTN","ut",191,0)
- . I 'XTSTVAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " D
-"RTN","ut",192,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)
- . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-"RTN","ut",194,0)
- . . Q
-"RTN","ut",195,0)
- . I XTSTVAL W "."
-"RTN","ut",196,0)
- . D RESETIO
-"RTN","ut",197,0)
- . Q
-"RTN","ut",198,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)
- Q
-"RTN","ut",200,0)
- ;
-"RTN","ut",201,0)
-CHKEQ(XTEXPECT,XTACTUAL,XTERMSG) ; Entry point for checking values to see if they are EQUAL
-"RTN","ut",202,0)
- N FAILMSG
-"RTN","ut",203,0)
- ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
-"RTN","ut",204,0)
- ; ZEXCEPT: %ut  -- NEWED IN EN
-"RTN","ut",205,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)
- S XTACTUAL=$G(XTACTUAL),XTEXPECT=$G(XTEXPECT)
-"RTN","ut",208,0)
- I $G(XTERMSG)="" S XTERMSG="no failure message provided"
-"RTN","ut",209,0)
- S %ut("CHK")=%ut("CHK")+1
-"RTN","ut",210,0)
- I XTEXPECT'=XTACTUAL S FAILMSG="<"_XTEXPECT_"> vs <"_XTACTUAL_"> - "
-"RTN","ut",211,0)
- I '$D(%utGUI) D
-"RTN","ut",212,0)
- . D SETIO
-"RTN","ut",213,0)
- . I XTEXPECT'=XTACTUAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W FAILMSG,XTERMSG,! D
-"RTN","ut",214,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)
-     . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-"RTN","ut",216,0)
- . . Q
-"RTN","ut",217,0)
- . E  W "."
-"RTN","ut",218,0)
- . D RESETIO
-"RTN","ut",219,0)
- . Q
-"RTN","ut",220,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)
- Q
-"RTN","ut",222,0)
- ;
-"RTN","ut",223,0)
-FAIL(XTERMSG) ; Entry point for generating a failure message
-"RTN","ut",224,0)
- ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
-"RTN","ut",225,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"RTN","ut",226,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
-"RTN","ut",227,0)
- I $G(XTERMSG)="" S XTERMSG="no failure message provided"
-"RTN","ut",228,0)
- S %ut("CHK")=%ut("CHK")+1
-"RTN","ut",229,0)
- I '$D(%utGUI) D
-"RTN","ut",230,0)
- . D SETIO
-"RTN","ut",231,0)
- . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
-"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")
-"RTN","ut",233,0)
- . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-"RTN","ut",234,0)
- . . Q
-"RTN","ut",235,0)
- . D RESETIO
-"RTN","ut",236,0)
- . Q
-"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
-"RTN","ut",239,0)
-SUCCEED ; Entry point for forcing a success (Thx David Whitten)
-"RTN","ut",240,0)
  ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
-"RTN","ut",241,0)
+"RTN","ut",190,0)
  ; ZEXCEPT: %ut - NEWED IN EN
-"RTN","ut",242,0)
- ; Switch IO and write out the dot for activity
-"RTN","ut",243,0)
+"RTN","ut",191,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut",192,0)
+ I '$D(XTSTVAL) D NVLDARG Q
+"RTN","ut",193,0)
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+"RTN","ut",194,0)
+ S %ut("CHK")=$G(%ut("CHK"))+1
+"RTN","ut",195,0)
  I '$D(%utGUI) D
-"RTN","ut",244,0)
+"RTN","ut",196,0)
  . D SETIO
-"RTN","ut",245,0)
- . W "."
-"RTN","ut",246,0)
+"RTN","ut",197,0)
+ . I 'XTSTVAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " D
+"RTN","ut",198,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",199,0)
+ . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+"RTN","ut",200,0)
+ . . Q
+"RTN","ut",201,0)
+ . I XTSTVAL W "."
+"RTN","ut",202,0)
  . D RESETIO
-"RTN","ut",247,0)
+"RTN","ut",203,0)
+ . Q
+"RTN","ut",204,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",205,0)
+ Q
+"RTN","ut",206,0)
  ;
-"RTN","ut",248,0)
- ; Increment test counter
-"RTN","ut",249,0)
+"RTN","ut",207,0)
+CHKEQ(XTEXPECT,XTACTUAL,XTERMSG) ; Entry point for checking values to see if they are EQUAL
+"RTN","ut",208,0)
+ N FAILMSG
+"RTN","ut",209,0)
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+"RTN","ut",210,0)
+ ; ZEXCEPT: %ut  -- NEWED IN EN
+"RTN","ut",211,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut",212,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",213,0)
+ S XTACTUAL=$G(XTACTUAL),XTEXPECT=$G(XTEXPECT)
+"RTN","ut",214,0)
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+"RTN","ut",215,0)
  S %ut("CHK")=%ut("CHK")+1
+"RTN","ut",216,0)
+ I XTEXPECT'=XTACTUAL S FAILMSG="<"_XTEXPECT_"> vs <"_XTACTUAL_"> - "
+"RTN","ut",217,0)
+ I '$D(%utGUI) D
+"RTN","ut",218,0)
+ . D SETIO
+"RTN","ut",219,0)
+ . I XTEXPECT'=XTACTUAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W FAILMSG,XTERMSG,! D
+"RTN","ut",220,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",221,0)
+     . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+"RTN","ut",222,0)
+ . . Q
+"RTN","ut",223,0)
+ . E  W "."
+"RTN","ut",224,0)
+ . D RESETIO
+"RTN","ut",225,0)
+ . Q
+"RTN","ut",226,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",227,0)
+ Q
+"RTN","ut",228,0)
+ ;
+"RTN","ut",229,0)
+FAIL(XTERMSG) ; Entry point for generating a failure message
+"RTN","ut",230,0)
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+"RTN","ut",231,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",232,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut",233,0)
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+"RTN","ut",234,0)
+ S %ut("CHK")=%ut("CHK")+1
+"RTN","ut",235,0)
+ I '$D(%utGUI) D
+"RTN","ut",236,0)
+ . D SETIO
+"RTN","ut",237,0)
+ . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+"RTN","ut",238,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",239,0)
+ . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+"RTN","ut",240,0)
+ . . Q
+"RTN","ut",241,0)
+ . D RESETIO
+"RTN","ut",242,0)
+ . Q
+"RTN","ut",243,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",244,0)
+ Q
+"RTN","ut",245,0)
+ ;
+"RTN","ut",246,0)
+SUCCEED ; Entry point for forcing a success (Thx David Whitten)
+"RTN","ut",247,0)
+ ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
+"RTN","ut",248,0)
+ ; ZEXCEPT: %ut - NEWED IN EN
+"RTN","ut",249,0)
+ ; Switch IO and write out the dot for activity
 "RTN","ut",250,0)
- QUIT
+ I '$D(%utGUI) D
 "RTN","ut",251,0)
- ;
+ . D SETIO
 "RTN","ut",252,0)
-CHKLEAKS(%utCODE,%utLOC,%utINPT) ; functionality to check for variable leaks on executing a section of code
+ . W "."
 "RTN","ut",253,0)
- ; %utCODE - A string that specifies the code that is to be XECUTED and checked for leaks.
+ . D RESETIO
 "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
+ ; Increment test counter
 "RTN","ut",256,0)
- ; %utINPT - An optional variable which may be passed by reference.  This may
+ S %ut("CHK")=%ut("CHK")+1
 "RTN","ut",257,0)
- ;           be used to pass any variable values, etc. into the code to be
+ QUIT
 "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.
+CHKLEAKS(%utCODE,%utLOC,%utINPT) ; functionality to check for variable leaks on executing a section of code
 "RTN","ut",260,0)
- ;              e.g., (using NAME as my current namespace)
+ ; %utCODE - A string that specifies the code that is to be XECUTED and checked for leaks.
 "RTN","ut",261,0)
- ;                   S CODE="S %utINPT=$$ENTRY^ROUTINE(ZZVALUE1,ZZVALUE2)"
+ ;            this should be a complete piece of code (e.g., "S X=$$NOW^XLFDT()" or "D EN^%ut(""ROUNAME"")")
 "RTN","ut",262,0)
- ;                   S NAMELOC="ENTRY^ROUTINE leak test"   (or simply "ENTRY^ROUTINE")
+ ; %utLOC  - A string that is used to indicate the code tested for variable leaks
 "RTN","ut",263,0)
- ;                   S NAMEINPT("ZZVALUE1")=ZZVALUE1
+ ; %utINPT - An optional variable which may be passed by reference.  This may
 "RTN","ut",264,0)
- ;                   S NAMEINPT("ZZVALUE2")=ZZVALUE2
+ ;           be used to pass any variable values, etc. into the code to be
 "RTN","ut",265,0)
- ;                   D CHKLEAKS^%ut(CODE,NAMELOC,.NAMEINPT)
+ ;           XECUTED.  In this case, set the subscript to the variable name and the
 "RTN","ut",266,0)
- ;
+ ;           value of the subscripted variable to the desired value of the subscript.
 "RTN","ut",267,0)
- ;           If part of a unit test, any leaked variables in ENTRY^ROUTINE which result
+ ;              e.g., (using NAME as my current namespace)
 "RTN","ut",268,0)
- ;           from running the code with the variables indicated will be shown as FAILUREs.
+ ;                   S CODE="S %utINPT=$$ENTRY^ROUTINE(ZZVALUE1,ZZVALUE2)"
 "RTN","ut",269,0)
- ;
+ ;                   S NAMELOC="ENTRY^ROUTINE leak test"   (or simply "ENTRY^ROUTINE")
 "RTN","ut",270,0)
- ;           If called outside of a unit test, any leaked variables will be printed to the
+ ;                   S NAMEINPT("ZZVALUE1")=ZZVALUE1
 "RTN","ut",271,0)
- ;           current device.
+ ;                   S NAMEINPT("ZZVALUE2")=ZZVALUE2
 "RTN","ut",272,0)
- ;
+ ;                   D CHKLEAKS^%ut(CODE,NAMELOC,.NAMEINPT)
 "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
+ ;           If part of a unit test, any leaked variables in ENTRY^ROUTINE which result
 "RTN","ut",275,0)
- ; ZEXCEPT: %utVAR - handled by exclusive NEW
+ ;           from running the code with the variables indicated will be shown as FAILUREs.
 "RTN","ut",276,0)
  ;
 "RTN","ut",277,0)
- ; ACTIVATE ANY VARIABLES PASSED AS SUBSCRIPTS TO %utINPT TO THEIR VALUES
+ ;           If called outside of a unit test, any leaked variables will be printed to the
 "RTN","ut",278,0)
- S %utVAR=" " F  S %utVAR=$O(%utINPT(%utVAR)) Q:%utVAR=""  S (@%utVAR)=%utINPT(%utVAR)
+ ;           current device.
 "RTN","ut",279,0)
- X %utCODE
+ ;
 "RTN","ut",280,0)
- N ZZUTVAR S ZZUTVAR="%"
+ N (%utCODE,%utLOC,%utINPT,DUZ,IO,U,%utERRL,%ut,%utGUI,%utERR,%utI,%utJ,%utK,%utLIST,%utROU,%utSTRT,XTGUISEP)
 "RTN","ut",281,0)
- I $G(%ut)=1 D
+ ; ZEXCEPT: %ut - part of exclusive NEW TESTS FOR EXISTENCE ONLY
 "RTN","ut",282,0)
- . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) D FAIL^%ut(%utLOC_" VARIABLE LEAK: "_ZZUTVAR)
+ ; ZEXCEPT: %utVAR - handled by exclusive NEW
 "RTN","ut",283,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)
- . Q
+ ; ACTIVATE ANY VARIABLES PASSED AS SUBSCRIPTS TO %utINPT TO THEIR VALUES
 "RTN","ut",285,0)
- I '($G(%ut)=1) D
+ S %utVAR=" " F  S %utVAR=$O(%utINPT(%utVAR)) Q:%utVAR=""  S (@%utVAR)=%utINPT(%utVAR)
 "RTN","ut",286,0)
- . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) W !,%utLOC_" VARIABLE LEAK: "_ZZUTVAR
+ X %utCODE
 "RTN","ut",287,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
+ N ZZUTVAR S ZZUTVAR="%"
 "RTN","ut",288,0)
- . Q
+ I $G(%ut)=1 D
 "RTN","ut",289,0)
- Q
+ . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) D FAIL^%ut(%utLOC_" VARIABLE LEAK: "_ZZUTVAR)
 "RTN","ut",290,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",291,0)
-NVLDARG ; generate message for invalid arguments to test
+ . Q
 "RTN","ut",292,0)
- N XTERMSG
+ I '($G(%ut)=1) D
 "RTN","ut",293,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) W !,%utLOC_" VARIABLE LEAK: "_ZZUTVAR
 "RTN","ut",294,0)
- ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+ . 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",295,0)
- ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ . Q
 "RTN","ut",296,0)
- S XTERMSG="NO VALUES INPUT TO CHKEQ^%ut - no evaluation possible"
+ Q
 "RTN","ut",297,0)
- I '$D(%utGUI) D
+ ;
 "RTN","ut",298,0)
- . D SETIO
+NVLDARG ; generate message for invalid arguments to test
 "RTN","ut",299,0)
- . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+ N XTERMSG
 "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")
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
 "RTN","ut",301,0)
- . . Q
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
 "RTN","ut",302,0)
- . D RESETIO
-"RTN","ut",303,0)
- . Q
-"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
-"RTN","ut",305,0)
- Q
-"RTN","ut",306,0)
- ;
-"RTN","ut",307,0)
-ERROR ; record errors
-"RTN","ut",308,0)
- ; ZEXCEPT: %utERRL,%utGUI,%utERR -CREATED IN SETUP, KILLED IN END
-"RTN","ut",309,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"RTN","ut",310,0)
  ; ZEXCEPT: XTGUISEP - newed in GUINEXT
-"RTN","ut",311,0)
- S %ut("CHK")=%ut("CHK")+1
-"RTN","ut",312,0)
- I '$D(%utGUI) D ERROR1
-"RTN","ut",313,0)
- I $D(%utGUI) D
-"RTN","ut",314,0)
- . S %ut("CNT")=%ut("CNT")+1
-"RTN","ut",315,0)
- . S %utERR=%utERR+1
-"RTN","ut",316,0)
- . S @%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"ERROR"_XTGUISEP_$S(+$SY=47:$ZS,1:$ZE)
-"RTN","ut",317,0)
- . Q
-"RTN","ut",318,0)
- S @($S(+$SY=47:"$ZS",1:"$ZE")_"="_""""""),$EC=""
-"RTN","ut",319,0)
- Q
-"RTN","ut",320,0)
- ;
-"RTN","ut",321,0)
-ERROR1 ;
-"RTN","ut",322,0)
- I $G(%ut("BREAK")) BREAK  ; if we are asked to break upon error, please do so!
-"RTN","ut",323,0)
- ; ZEXCEPT: %utERRL -CREATED IN SETUP, KILLED IN END
-"RTN","ut",324,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"RTN","ut",325,0)
- D SETIO
-"RTN","ut",326,0)
- W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - Error: " W $S(+$SY=47:$ZS,1:$ZE),! D
-"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")
-"RTN","ut",328,0)
- . Q
-"RTN","ut",329,0)
- D RESETIO
-"RTN","ut",330,0)
- Q
-"RTN","ut",331,0)
-SETIO ; Set M-Unit Device to write the results to...
-"RTN","ut",332,0)
- ; ZEXCEPT: %ut  -- NEWED ON ENTRY
-"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",355,0)
-RUNSET(SETNAME,VERBOSE) ; .SR Run with Specified Selection of MUnit Test Group
-"RTN","ut",356,0)
- N Y,%utROU,%utLIST,%utVERB
-"RTN","ut",357,0)
- Q:$G(SETNAME)=""
-"RTN","ut",358,0)
- S %utVERB=$G(VERBOSE,0)
-"RTN","ut",359,0)
- S Y=+$$FIND1^DIC(17.9001,"","X",SETNAME) Q:Y'>0
-"RTN","ut",360,0)
- D GETSET(Y,.%utROU,.%utLIST)
-"RTN","ut",361,0)
- N Y,SETNAME,%ut
-"RTN","ut",362,0)
- D SETUT
-"RTN","ut",363,0)
- D EN1(.%utROU,%utLIST)
-"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)
- N %utROU,%utLIST,%ut
-"RTN","ut",386,0)
- D SETUT
-"RTN","ut",387,0)
- S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
-"RTN","ut",388,0)
- D GETSET(XTSET,.%utROU,.%utLIST)
-"RTN","ut",389,0)
- D GETLIST(.%utROU,%utLIST,%ut("RSLT"))
-"RTN","ut",390,0)
- S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
-"RTN","ut",391,0)
- S %utRSLT=%ut("RSLT")
-"RTN","ut",392,0)
- Q
-"RTN","ut",393,0)
- ;
-"RTN","ut",394,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)
- N %utROU,%ut
-"RTN","ut",396,0)
- D SETUT
-"RTN","ut",397,0)
- S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
-"RTN","ut",398,0)
- S %utROU(1)=%utROUN
-"RTN","ut",399,0)
- D GETLIST(.%utROU,1,%ut("RSLT"))
-"RTN","ut",400,0)
- S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
-"RTN","ut",401,0)
- S %utRSLT=%ut("RSLT")
-"RTN","ut",402,0)
- Q
-"RTN","ut",403,0)
- ;
-"RTN","ut",404,0)
-GETLIST(%utROU,%utLIST,%utRSLT) ; called from GUISET, GUILOAD
-"RTN","ut",405,0)
- N I,%utROUL,%utROUN,%ut,XTCOMNT,XTVALUE,%utCNT
-"RTN","ut",406,0)
- S XTVALUE=$NA(^TMP("GUI-MUNIT",$J)) K @XTVALUE
-"RTN","ut",407,0)
- S %utCNT=0,XTCOMNT=""
-"RTN","ut",408,0)
- D GETTREE^%ut1(.%utROU,%utLIST)
-"RTN","ut",409,0)
- F I=1:1 Q:'$D(%utROU(I))  S %utROUL(%utROU(I))=""
-"RTN","ut",410,0)
- S %utROUN="" F  S %utROUN=$O(%utROUL(%utROUN)) Q:%utROUN=""  D LOAD(%utROUN,.%utCNT,XTVALUE,XTCOMNT,.%utROUL)
-"RTN","ut",411,0)
- M @%utRSLT=@XTVALUE
-"RTN","ut",412,0)
- K @%utRSLT@("SHUTDOWN")
-"RTN","ut",413,0)
- K @%utRSLT@("STARTUP")
-"RTN","ut",414,0)
- S @XTVALUE@("LASTROU")="" ; Use this to keep track of place in routines
-"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)
- ; XTGUISEP - added 110719 to provide for changing separator for GUI
-"RTN","ut",436,0)
- ;            return from ^ to another value ~~^~~  so that data returned
-"RTN","ut",437,0)
- ;            is not affected by ^ values in the data - if not present
-"RTN","ut",438,0)
- ;            sets value to default ^
-"RTN","ut",439,0)
- N %utETRY,%utROUT,XTOLROU,XTVALUE,%utERR,%utGUI
-"RTN","ut",440,0)
- N %ut
-"RTN","ut",441,0)
- I $G(XTGUISEP)="" S XTGUISEP="^"
-"RTN","ut",442,0)
- D SETUT
-"RTN","ut",443,0)
- S %ut("LOC")=%utLOC
-"RTN","ut",444,0)
- S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
-"RTN","ut",445,0)
- S XTVALUE=$NA(^TMP("GUI-MUNIT",$J))
-"RTN","ut",446,0)
- S %ut("RSLT")=$NA(^TMP("GUINEXT",$J)) K @%ut("RSLT")
-"RTN","ut",447,0)
- S %utRSLT=%ut("RSLT")
-"RTN","ut",448,0)
- S %utETRY=$P(%utLOC,U),%utROUT=$P(%utLOC,U,2),XTOLROU=$G(@XTVALUE@("LASTROU"))
-"RTN","ut",449,0)
- S %utGUI=1
-"RTN","ut",450,0)
- S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
-"RTN","ut",451,0)
- ; I %utROUT'=XTOLROU D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ;140731 JLI - commented out
-"RTN","ut",452,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)
- . I XTOLROU="",$D(@XTVALUE@("STARTUP")) D
-"RTN","ut",455,0)
- . . S %ut("LOC")=@XTVALUE@("STARTUP")
-"RTN","ut",456,0)
- . . N $ETRAP S $ETRAP="D ERROR^%ut"
-"RTN","ut",457,0)
- . . D @(@XTVALUE@("STARTUP"))
-"RTN","ut",458,0)
+"RTN","ut",303,0)
+ S XTERMSG="NO VALUES INPUT TO CHKEQ^%ut - no evaluation possible"
+"RTN","ut",304,0)
+ I '$D(%utGUI) D
+"RTN","ut",305,0)
+ . D SETIO
+"RTN","ut",306,0)
+ . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+"RTN","ut",307,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",308,0)
  . . Q
+"RTN","ut",309,0)
+ . D RESETIO
+"RTN","ut",310,0)
+ . Q
+"RTN","ut",311,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",312,0)
+ Q
+"RTN","ut",313,0)
+ ;
+"RTN","ut",314,0)
+ERROR ; record errors
+"RTN","ut",315,0)
+ ; ZEXCEPT: %utERRL,%utGUI,%utERR -CREATED IN SETUP, KILLED IN END
+"RTN","ut",316,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",317,0)
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+"RTN","ut",318,0)
+ S %ut("CHK")=%ut("CHK")+1
+"RTN","ut",319,0)
+ I '$D(%utGUI) D ERROR1
+"RTN","ut",320,0)
+ I $D(%utGUI) D
+"RTN","ut",321,0)
+ . S %ut("CNT")=%ut("CNT")+1
+"RTN","ut",322,0)
+ . S %utERR=%utERR+1
+"RTN","ut",323,0)
+ . S @%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"ERROR"_XTGUISEP_$S(+$SY=47:$ZS,1:$ZE)
+"RTN","ut",324,0)
+ . Q
+"RTN","ut",325,0)
+ S @($S(+$SY=47:"$ZS",1:"$ZE")_"="_""""""),$EC=""
+"RTN","ut",326,0)
+ Q
+"RTN","ut",327,0)
+ ;
+"RTN","ut",328,0)
+ERROR1 ;
+"RTN","ut",329,0)
+ I $G(%ut("BREAK")) BREAK  ; if we are asked to break upon error, please do so!
+"RTN","ut",330,0)
+ ; ZEXCEPT: %utERRL -CREATED IN SETUP, KILLED IN END
+"RTN","ut",331,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",332,0)
+ D SETIO
+"RTN","ut",333,0)
+ W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - Error: " W $S(+$SY=47:$ZS,1:$ZE),! D
+"RTN","ut",334,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",335,0)
+ . Q
+"RTN","ut",336,0)
+ D RESETIO
+"RTN","ut",337,0)
+ Q
+"RTN","ut",338,0)
+SETIO ; Set M-Unit Device to write the results to...
+"RTN","ut",339,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",340,0)
+ I $IO'=%ut("IO") S (IO(0),%ut("DEV","OLD"))=$IO USE %ut("IO") SET IO=$IO
+"RTN","ut",341,0)
+ QUIT
+"RTN","ut",342,0)
+ ;
+"RTN","ut",343,0)
+RESETIO ; Reset $IO back to the original device if we changed it.
+"RTN","ut",344,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",345,0)
+ I $D(%ut("DEV","OLD")) S IO(0)=%ut("IO") U %ut("DEV","OLD") S IO=$IO K %ut("DEV","OLD")
+"RTN","ut",346,0)
+ QUIT
+"RTN","ut",347,0)
+ ;
+"RTN","ut",348,0)
+ISUTEST() ; .SUPPORTED API TO DETERMINE IF CURRENTLY IN UNIT TEST
+"RTN","ut",349,0)
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+"RTN","ut",350,0)
+ Q $G(%ut)=1
+"RTN","ut",351,0)
+ ;
+"RTN","ut",352,0)
+PICKSET ; .OPT Interactive selection of MUnit Test Group
+"RTN","ut",353,0)
+ N DIC,Y,%utROU,%utLIST,DIR 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",354,0)
+ Q
+"RTN","ut",355,0)
+ ;
+"RTN","ut",356,0)
+RUNSET(SETNAME,VERBOSE) ; .SR Run with Specified Selection of MUnit Test Group
+"RTN","ut",357,0)
+ N Y,%utROU,%utLIST,%utVERB
+"RTN","ut",358,0)
+ Q:$G(SETNAME)=""
+"RTN","ut",359,0)
+ S %utVERB=$G(VERBOSE,0)
+"RTN","ut",360,0)
+ S Y=+$$FIND1^DIC(17.9001,"","X",SETNAME) Q:Y'>0
+"RTN","ut",361,0)
+ D GETSET(Y,.%utROU,.%utLIST)
+"RTN","ut",362,0)
+ N Y,SETNAME,%ut
+"RTN","ut",363,0)
+ D SETUT
+"RTN","ut",364,0)
+ D EN1(.%utROU,%utLIST)
+"RTN","ut",365,0)
+ Q
+"RTN","ut",366,0)
+ ;
+"RTN","ut",367,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",368,0)
+DOSET(IEN,%utVERB) ; 140731 JLI added %utVERB as a second argument
+"RTN","ut",369,0)
+ ; IEN - Internal entry number for selected set of tests in the MUNIT TEST GROUP file (#17.9001)
+"RTN","ut",370,0)
+ ; %utVERB - optional input that indicates verbose output is permitted
+"RTN","ut",371,0)
+ ;
+"RTN","ut",372,0)
+ N %utROU,%utLIST
+"RTN","ut",373,0)
+ I '$D(%utVERB) S %utVERB=0
+"RTN","ut",374,0)
+ S %utLIST=0
+"RTN","ut",375,0)
+ D GETSET($G(IEN),.%utROU,.%utLIST)
+"RTN","ut",376,0)
+ I %utLIST>0  N IEN,%ut D SETUT,EN1(.%utROU,%utLIST)
+"RTN","ut",377,0)
+ Q
+"RTN","ut",378,0)
+ ;
+"RTN","ut",379,0)
+GETSET(IEN,%utROU,%utLIST) ;  JLI 140731 - called from PICKSET, RUNSET, DOSET, GUISET
+"RTN","ut",380,0)
+ N IENS,%utROOT
+"RTN","ut",381,0)
+ S IENS=IEN_"," D GETS^DIQ(17.9001,IENS,"1*","","%utROOT")
+"RTN","ut",382,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",383,0)
+ Q
+"RTN","ut",384,0)
+ ;
+"RTN","ut",385,0)
+COV(NMSP,COVCODE,VERBOSITY) ; simply make it callable from %ut1 as well (along with other APIs) JLI 150101
+"RTN","ut",386,0)
+ D COV^%ut1(NMSP,COVCODE,+$G(VERBOSITY)) ; see COV^%ut1 for description of arguments
+"RTN","ut",387,0)
+ Q
+"RTN","ut",388,0)
+ ;
+"RTN","ut",389,0)
+GUISET(%utRSLT,XTSET) ; Entry point for GUI start with selected Test Set IEN - called by %ut-TEST GROUP LOAD rpc
+"RTN","ut",390,0)
+ N %utROU,%utLIST,%ut
+"RTN","ut",391,0)
+ D SETUT
+"RTN","ut",392,0)
+ S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
+"RTN","ut",393,0)
+ D GETSET(XTSET,.%utROU,.%utLIST)
+"RTN","ut",394,0)
+ D GETLIST(.%utROU,%utLIST,%ut("RSLT"))
+"RTN","ut",395,0)
+ S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
+"RTN","ut",396,0)
+ S %utRSLT=%ut("RSLT")
+"RTN","ut",397,0)
+ Q
+"RTN","ut",398,0)
+ ;
+"RTN","ut",399,0)
+GUILOAD(%utRSLT,%utROUN) ; Entry point for GUI start with %utROUN containing primary routine name - called by %ut-TEST LOAD rpc
+"RTN","ut",400,0)
+ N %utROU,%ut
+"RTN","ut",401,0)
+ D SETUT
+"RTN","ut",402,0)
+ S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
+"RTN","ut",403,0)
+ S %utROU(1)=%utROUN
+"RTN","ut",404,0)
+ D GETLIST(.%utROU,1,%ut("RSLT"))
+"RTN","ut",405,0)
+ S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
+"RTN","ut",406,0)
+ S %utRSLT=%ut("RSLT")
+"RTN","ut",407,0)
+ Q
+"RTN","ut",408,0)
+ ;
+"RTN","ut",409,0)
+GETLIST(%utROU,%utLIST,%utRSLT) ; called from GUISET, GUILOAD
+"RTN","ut",410,0)
+ N I,%utROUL,%utROUN,%ut,XTCOMNT,XTVALUE,%utCNT
+"RTN","ut",411,0)
+ S XTVALUE=$NA(^TMP("GUI-MUNIT",$J)) K @XTVALUE
+"RTN","ut",412,0)
+ S %utCNT=0,XTCOMNT=""
+"RTN","ut",413,0)
+ D GETTREE^%ut1(.%utROU,%utLIST)
+"RTN","ut",414,0)
+ F I=1:1 Q:'$D(%utROU(I))  S %utROUL(%utROU(I))=""
+"RTN","ut",415,0)
+ S %utROUN="" F  S %utROUN=$O(%utROUL(%utROUN)) Q:%utROUN=""  D LOAD(%utROUN,.%utCNT,XTVALUE,XTCOMNT,.%utROUL)
+"RTN","ut",416,0)
+ M @%utRSLT=@XTVALUE
+"RTN","ut",417,0)
+ K @%utRSLT@("SHUTDOWN")
+"RTN","ut",418,0)
+ K @%utRSLT@("STARTUP")
+"RTN","ut",419,0)
+ S @XTVALUE@("LASTROU")="" ; Use this to keep track of place in routines
+"RTN","ut",420,0)
+ Q
+"RTN","ut",421,0)
+ ;
+"RTN","ut",422,0)
+ ; generate list of unit test routines, entry points and comments on test for entry point
+"RTN","ut",423,0)
+LOAD(%utROUN,%utNCNT,XTVALUE,XTCOMNT,%utROUL) ; called from GETLIST, and recursively from LOAD
+"RTN","ut",424,0)
+ I $T(@("^"_%utROUN))="" S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_"^^*** ERROR - ROUTINE NAME NOT FOUND" Q
+"RTN","ut",425,0)
+ S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_U_XTCOMNT
+"RTN","ut",426,0)
+ ;N %utI,XTX1,XTX2,LINE
+"RTN","ut",427,0)
+ N %utI,XTX1,XTX2,LINE,LIST,I
+"RTN","ut",428,0)
+ ; 100622 JLI added code to identify STARTUP and TEARDOWN
+"RTN","ut",429,0)
+ I $T(@("STARTUP^"_%utROUN))'="",'$D(@XTVALUE@("STARTUP")) S @XTVALUE@("STARTUP")="STARTUP^"_%utROUN
+"RTN","ut",430,0)
+ I $T(@("SHUTDOWN^"_%utROUN))'="",'$D(@XTVALUE@("SHUTDOWN")) S @XTVALUE@("SHUTDOWN")="SHUTDOWN^"_%utROUN
+"RTN","ut",431,0)
+ ; JLI 140731 handle @TEST identified test tags
+"RTN","ut",432,0)
+ D NEWSTYLE^%ut1(.LIST,%utROUN)
+"RTN","ut",433,0)
+ F I=1:1:LIST S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_LIST(I)
+"RTN","ut",434,0)
+ ; JLI 140731 end of @TEST addition
+"RTN","ut",435,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",436,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",437,0)
+ Q
+"RTN","ut",438,0)
+ ;
+"RTN","ut",439,0)
+GUINEXT(%utRSLT,%utLOC,XTGUISEP) ; Entry point for GUI execute next test - called by %ut-TEST NEXT rpc
+"RTN","ut",440,0)
+ ; XTGUISEP - added 110719 to provide for changing separator for GUI
+"RTN","ut",441,0)
+ ;            return from ^ to another value ~~^~~  so that data returned
+"RTN","ut",442,0)
+ ;            is not affected by ^ values in the data - if not present
+"RTN","ut",443,0)
+ ;            sets value to default ^
+"RTN","ut",444,0)
+ N %utETRY,%utROUT,XTOLROU,XTVALUE,%utERR,%utGUI
+"RTN","ut",445,0)
+ N %ut
+"RTN","ut",446,0)
+ I $G(XTGUISEP)="" S XTGUISEP="^"
+"RTN","ut",447,0)
+ D SETUT
+"RTN","ut",448,0)
+ S %ut("LOC")=%utLOC
+"RTN","ut",449,0)
+ S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
+"RTN","ut",450,0)
+ S XTVALUE=$NA(^TMP("GUI-MUNIT",$J))
+"RTN","ut",451,0)
+ S %ut("RSLT")=$NA(^TMP("GUINEXT",$J)) K @%ut("RSLT")
+"RTN","ut",452,0)
+ S %utRSLT=%ut("RSLT")
+"RTN","ut",453,0)
+ S %utETRY=$P(%utLOC,U),%utROUT=$P(%utLOC,U,2),XTOLROU=$G(@XTVALUE@("LASTROU"))
+"RTN","ut",454,0)
+ S %utGUI=1
+"RTN","ut",455,0)
+ S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
+"RTN","ut",456,0)
+ ; I %utROUT'=XTOLROU D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ;140731 JLI - commented out
+"RTN","ut",457,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",458,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",459,0)
- . S @XTVALUE@("LASTROU")=%utROUT I %utROUT'="",$T(@("SETUP^"_%utROUT))'="" D
+ . I XTOLROU="",$D(@XTVALUE@("STARTUP")) D
 "RTN","ut",460,0)
- . . S %ut("LOC")="SETUP^"_%utROUT
+ . . S %ut("LOC")=@XTVALUE@("STARTUP")
 "RTN","ut",461,0)
  . . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",462,0)
- . . D @("SETUP^"_%utROUT)
+ . . D @(@XTVALUE@("STARTUP"))
 "RTN","ut",463,0)
  . . Q
 "RTN","ut",464,0)
- . I %utROUT="",$D(@XTVALUE@("SHUTDOWN")) D
+ . S @XTVALUE@("LASTROU")=%utROUT I %utROUT'="",$T(@("SETUP^"_%utROUT))'="" D
 "RTN","ut",465,0)
- . . S %ut("LOC")=@XTVALUE@("SHUTDOWN")
+ . . S %ut("LOC")="SETUP^"_%utROUT
 "RTN","ut",466,0)
  . . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",467,0)
- . . D @(@XTVALUE@("SHUTDOWN"))
+ . . D @("SETUP^"_%utROUT)
 "RTN","ut",468,0)
  . . Q
 "RTN","ut",469,0)
- . Q
+ . I %utROUT="",$D(@XTVALUE@("SHUTDOWN")) D
 "RTN","ut",470,0)
- S %ut("LOC")=%utLOC
+ . . S %ut("LOC")=@XTVALUE@("SHUTDOWN")
 "RTN","ut",471,0)
- S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
+ . . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",472,0)
- D  ; to limit range of error trap so we continue through other tests
+ . . D @(@XTVALUE@("SHUTDOWN"))
 "RTN","ut",473,0)
- . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . . Q
 "RTN","ut",474,0)
- . D @%ut("LOC")
-"RTN","ut",475,0)
  . Q
+"RTN","ut",475,0)
+ S %ut("LOC")=%utLOC
 "RTN","ut",476,0)
- I $T(@("TEARDOWN^"_%utROUT))'="" D
+ S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
 "RTN","ut",477,0)
- . S %ut("LOC")="TEARDOWN^"_%utROUT
+ D  ; to limit range of error trap so we continue through other tests
 "RTN","ut",478,0)
  . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",479,0)
- . D @("TEARDOWN^"_%utROUT)
+ . D @%ut("LOC")
 "RTN","ut",480,0)
  . Q
 "RTN","ut",481,0)
- S @%ut("RSLT")@(1)=%ut("CHK")_XTGUISEP_(%ut("CNT")-1-%utERR)_XTGUISEP_%utERR
+ I $T(@("TEARDOWN^"_%utROUT))'="" D
 "RTN","ut",482,0)
- Q
+ . S %ut("LOC")="TEARDOWN^"_%utROUT
 "RTN","ut",483,0)
- ;
+ . N $ETRAP S $ETRAP="D ERROR^%ut"
 "RTN","ut",484,0)
-TESTCOVR ; entry under coverage analysis
+ . D @("TEARDOWN^"_%utROUT)
 "RTN","ut",485,0)
- D ENTRY^%uttcovr ; does analysis while running various unit tests
+ . Q
 "RTN","ut",486,0)
- Q
+ S @%ut("RSLT")@(1)=%ut("CHK")_XTGUISEP_(%ut("CNT")-1-%utERR)_XTGUISEP_%utERR
 "RTN","ut",487,0)
+ Q
+"RTN","ut",488,0)
  ;
 "RTN","ut1")
-0^2^B87092328
+0^2^B105832889
 "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 ; 7/2/15 10:45pm
 "RTN","ut1",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","ut1",3,0)
  ;
 "RTN","ut1",4,0)
@@ -1726,511 +1890,847 @@ TESTCOVR ; entry under coverage analysis
 "RTN","ut1",17,0)
  ;
 "RTN","ut1",18,0)
- Q
+ D ^%utt6 ; runs unit tests from several perspectives
 "RTN","ut1",19,0)
- ;
+ Q
 "RTN","ut1",20,0)
-CHEKTEST(%utROU,%ut,%utUETRY) ; Collect Test list.
+ ;
 "RTN","ut1",21,0)
- ; %utROU - input - Name of routine to check for tags with @TEST attribute
+CHEKTEST(%utROU,%ut,%utUETRY) ; Collect Test list.
 "RTN","ut1",22,0)
- ; %ut - input/output - passed by reference
+ ; %utROU - input - Name of routine to check for tags with @TEST attribute
 "RTN","ut1",23,0)
- ; %utUETRY - input/output - passed by reference
+ ; %ut - input/output - passed by reference
 "RTN","ut1",24,0)
- ;
+ ; %utUETRY - input/output - passed by reference
 "RTN","ut1",25,0)
- ; Test list collected in two ways:
+ ;
 "RTN","ut1",26,0)
- ; - @TEST on labellines
+ ; Test list collected in two ways:
 "RTN","ut1",27,0)
- ; - Offsets of XTENT
+ ; - @TEST on labellines
 "RTN","ut1",28,0)
- ;
+ ; - Offsets of XTENT
 "RTN","ut1",29,0)
- S %ut("ENTN")=0 ; Number of test, sub to %utUETRY.
+ ;
 "RTN","ut1",30,0)
- ;
+ S %ut("ENTN")=0 ; Number of test, sub to %utUETRY.
 "RTN","ut1",31,0)
- ; This stanza and everything below is for collecting @TEST.
-"RTN","ut1",32,0)
- ; VEN/SMH - block refactored to use $TEXT instead of ^%ZOSF("LOAD")
-"RTN","ut1",33,0)
- N I,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)
- 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",32,0)
+ ; This stanza and everything below is for collecting @TEST.
+"RTN","ut1",33,0)
+ ; VEN/SMH - block refactored to use $TEXT instead of ^%ZOSF("LOAD")
+"RTN","ut1",34,0)
+ N I,LIST
+"RTN","ut1",35,0)
+ S I=$L($T(@(U_%utROU))) I I<0 Q "-1^Invalid Routine Name"
+"RTN","ut1",36,0)
+ ; 140731 JLI - the following SMH code is replaced by the code below
+"RTN","ut1",37,0)
+ ; Complexity galore: $TEXT loops through routine
+"RTN","ut1",38,0)
+ ; IF tab or space isn't the first character ($C(9,32)) and line contains @TEST
+"RTN","ut1",39,0)
+ ; Load that line as a testing entry point
+"RTN","ut1",40,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",41,0)
+ ; . N TAGNAME,CHAR,NPAREN S TAGNAME="",NPAREN=0
+"RTN","ut1",42,0)
+ ; . F  Q:LINE=""  S CHAR=$E(LINE),LINE=$E(LINE,2,999) Q:CHAR=""  Q:" ("[CHAR  S TAGNAME=TAGNAME_CHAR
+"RTN","ut1",43,0)
+ ; . ; should be no paren or arguments
+"RTN","ut1",44,0)
+ ; . I CHAR="(" Q
+"RTN","ut1",45,0)
+ ; . F  Q:LINE=""  S CHAR=$E(LINE) Q:" ;"'[CHAR  S LINE=$E(LINE,2,999)
+"RTN","ut1",46,0)
+ ; . I $$UP($E(LINE,1,5))="@TEST" S LINE=$E(LINE,6,999) D
+"RTN","ut1",47,0)
+ ; . . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=TAGNAME
+"RTN","ut1",48,0)
+ ; . . F  Q:LINE=""  S CHAR=$E(LINE) Q:CHAR?1AN  S LINE=$E(LINE,2,999)
+"RTN","ut1",49,0)
+ ; . . S %utUETRY(%ut("ENTN"),"NAME")=LINE
+"RTN","ut1",50,0)
+ ; JLI 140731 - end of code replaced by following code
+"RTN","ut1",51,0)
+ ; JLI 140731 - the following code replaces the code above
+"RTN","ut1",52,0)
+ D NEWSTYLE(.LIST,%utROU)
+"RTN","ut1",53,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",54,0)
+ ; JLI 140731 - end of replacement code
 "RTN","ut1",55,0)
  ;
 "RTN","ut1",56,0)
- ; This Stanza is to collect XTENT offsets
+ ;
 "RTN","ut1",57,0)
- N %utUI F %utUI=1:1 S %ut("ELIN")=$T(@("XTENT+"_%utUI_"^"_%utROU)) Q:$P(%ut("ELIN"),";",3)=""  D
+ ; This Stanza is to collect XTENT offsets
 "RTN","ut1",58,0)
- . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=$P(%ut("ELIN"),";",3),%utUETRY(%ut("ENTN"),"NAME")=$P(%ut("ELIN"),";",4)
+ N %utUI F %utUI=1:1 S %ut("ELIN")=$T(@("XTENT+"_%utUI_"^"_%utROU)) Q:$P(%ut("ELIN"),";",3)=""  D
 "RTN","ut1",59,0)
- . Q
+ . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=$P(%ut("ELIN"),";",3),%utUETRY(%ut("ENTN"),"NAME")=$P(%ut("ELIN"),";",4)
 "RTN","ut1",60,0)
- ;
+ . Q
 "RTN","ut1",61,0)
- QUIT
+ ;
 "RTN","ut1",62,0)
- ;
+ QUIT
 "RTN","ut1",63,0)
- ; VEN/SMH 26JUL2013 - Moved GETTREE here.
+ ;
 "RTN","ut1",64,0)
-GETTREE(%utROU,%utULIST) ;
+ ; VEN/SMH 26JUL2013 - Moved GETTREE here.
 "RTN","ut1",65,0)
- ; first get any other routines this one references for running subsequently
+GETTREE(%utROU,%utULIST) ;
 "RTN","ut1",66,0)
- ; then any that they refer to as well
+ ; first get any other routines this one references for running subsequently
 "RTN","ut1",67,0)
- ; this builds a tree of all routines referred to by any routine including each only once
+ ; then any that they refer to as well
 "RTN","ut1",68,0)
- N %utUK,%utUI,%utUJ,%utURNAM,%utURLIN
+ ; this builds a tree of all routines referred to by any routine including each only once
 "RTN","ut1",69,0)
- F %utUK=1:1 Q:'$D(%utROU(%utUK))  D
+ N %utUK,%utUI,%utUJ,%utURNAM,%utURLIN
 "RTN","ut1",70,0)
- . F %utUI=1:1 S %utURLIN=$T(@("XTROU+"_%utUI_"^"_%utROU(%utUK))) S %utURNAM=$P(%utURLIN,";",3) Q:%utURNAM=""  D
+ F %utUK=1:1 Q:'$D(%utROU(%utUK))  D
 "RTN","ut1",71,0)
- . . F %utUJ=1:1:%utULIST I %utROU(%utUJ)=%utURNAM S %utURNAM="" Q
+ . F %utUI=1:1 S %utURLIN=$T(@("XTROU+"_%utUI_"^"_%utROU(%utUK))) S %utURNAM=$P(%utURLIN,";",3) Q:%utURNAM=""  D
 "RTN","ut1",72,0)
- . . I %utURNAM'="",$T(@("+1^"_%utURNAM))="" W:'$D(XWBOS) "Referenced routine ",%utURNAM," not found.",! Q
+ . . F %utUJ=1:1:%utULIST I %utROU(%utUJ)=%utURNAM S %utURNAM="" Q
 "RTN","ut1",73,0)
- . . S:%utURNAM'="" %utULIST=%utULIST+1,%utROU(%utULIST)=%utURNAM
+ . . I %utURNAM'="",$T(@("+1^"_%utURNAM))="" W:'$D(XWBOS) "Referenced routine ",%utURNAM," not found.",! Q
 "RTN","ut1",74,0)
- QUIT
+ . . S:%utURNAM'="" %utULIST=%utULIST+1,%utROU(%utULIST)=%utURNAM
 "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)
- K LIST S LIST=0
-"RTN","ut1",83,0)
- ; search routine by line for a tag and @TEST declaration
-"RTN","ut1",84,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)
- Q
-"RTN","ut1",86,0)
- ;
-"RTN","ut1",87,0)
-CHECKTAG(LINE) ; JLI 140726 check line to determine @test TAG
-"RTN","ut1",88,0)
- ; LINE - input - Line of code to be checked
-"RTN","ut1",89,0)
- ; returns null line if not @TEST line, otherwise TAG^NOTE
-"RTN","ut1",90,0)
- N TAG,NOTE,CHAR
-"RTN","ut1",91,0)
- I $E(LINE)=" " Q "" ; test entry must have a tag
-"RTN","ut1",92,0)
- I $$UP(LINE)'["@TEST" Q "" ; must have @TEST declaration
-"RTN","ut1",93,0)
- I $P($$UP(LINE),"@TEST")["(" Q "" ; can't have an argument
-"RTN","ut1",94,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)
- F  Q:NOTE=""  S CHAR=$E(NOTE),NOTE=$E(NOTE,2,$L(NOTE)) I " ;"'[CHAR Q  ;
-"RTN","ut1",96,0)
- I $L(NOTE)'=0 Q "" ; @TEST must be first text on line
-"RTN","ut1",97,0)
- F  Q:$E(LINE)'=" "  S LINE=$E(LINE,2,$L(LINE)) ; remove leading spaces from test info
-"RTN","ut1",98,0)
- S TAG=TAG_U_LINE
-"RTN","ut1",99,0)
- Q TAG
-"RTN","ut1",100,0)
- ;
-"RTN","ut1",101,0)
- ; VEN/SMH 17DEC2013 - Remove dependence on VISTA - Uppercase here instead of XLFSTR.
-"RTN","ut1",102,0)
-UP(X) ;
-"RTN","ut1",103,0)
- Q $TR(X,"abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ")
-"RTN","ut1",104,0)
- ;
-"RTN","ut1",105,0)
-COV(NMSP,COVCODE,VERBOSITY) ; VEN/SMH - PUBLIC ENTRY POINT; Coverage calculations
-"RTN","ut1",106,0)
- ; NMSP: Namespace of the routines to analyze. End with * to include all routines.
-"RTN","ut1",107,0)
- ;       Not using * will only include the routine with NMSP name.
-"RTN","ut1",108,0)
- ;       e.g. PSOM* will include all routines starting with PSOM
-"RTN","ut1",109,0)
- ;            PSOM will only include PSOM.
-"RTN","ut1",110,0)
- ; COVCODE: Mumps code to run over which coverage will be calculated. Typically Unit Tests.
-"RTN","ut1",111,0)
- ; VERBOSITY (optional): Scalar from -1 to 3.
-"RTN","ut1",112,0)
- ;    - -1 = Global output in ^TMP("%utCOVREPORT",$J)
-"RTN","ut1",113,0)
- ;    - 0 = Print only total coverage
-"RTN","ut1",114,0)
- ;    - 1 = Break down by routine
-"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.
-"RTN","ut1",117,0)
- ;
-"RTN","ut1",118,0)
- Q:'(+$SY=47)  ; GT.M only!
-"RTN","ut1",119,0)
- ;
-"RTN","ut1",120,0)
- ; ZEXCEPT: CTRAP - not really a variable
-"RTN","ut1",121,0)
- S VERBOSITY=+$G(VERBOSITY) ; Get 0 if not passed.
-"RTN","ut1",122,0)
- N %ZR ; GT.M specific
-"RTN","ut1",123,0)
- D SILENT^%RSEL(NMSP,"SRC") ; GT.M specific. On Cache use $O(^$R(RTN)).
-"RTN","ut1",124,0)
- ;
-"RTN","ut1",125,0)
- N RN S RN=""
-"RTN","ut1",126,0)
- W "Loading routines to test coverage...",!
-"RTN","ut1",127,0)
- F  S RN=$O(%ZR(RN)) Q:RN=""  W RN," " D
-"RTN","ut1",128,0)
- . N L2 S L2=$T(+2^@RN)
-"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
-"RTN","ut1",131,0)
- ;
-"RTN","ut1",132,0)
- N RTNS M RTNS=%ZR
-"RTN","ut1",133,0)
- K %ZR
-"RTN","ut1",134,0)
- ;
-"RTN","ut1",135,0)
- N GL
-"RTN","ut1",136,0)
- S GL=$NA(^TMP("%utCOVCOHORT",$J))
-"RTN","ut1",137,0)
- K @GL
-"RTN","ut1",138,0)
- D RTNANAL(.RTNS,GL)
-"RTN","ut1",139,0)
- K ^TMP("%utCOVCOHORTSAV",$J)
-"RTN","ut1",140,0)
- M ^TMP("%utCOVCOHORTSAV",$J)=^TMP("%utCOVCOHORT",$J)
-"RTN","ut1",141,0)
- ;
-"RTN","ut1",142,0)
- ;
-"RTN","ut1",143,0)
- K ^TMP("%utCOVRESULT",$J)
-"RTN","ut1",144,0)
- VIEW "TRACE":1:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M START PROFILING
-"RTN","ut1",145,0)
- DO  ; Run the code, but keep our variables to ourselves.
-"RTN","ut1",146,0)
- . NEW $ETRAP,$ESTACK
-"RTN","ut1",147,0)
- . SET $ETRAP="Q:($ES&$Q) -9 Q:$ES  W ""CTRL-C ENTERED"""
-"RTN","ut1",148,0)
- . USE $PRINCIPAL:(CTRAP=$C(3))
-"RTN","ut1",149,0)
- . NEW (DUZ,IO,COVCODE,U,DILOCKTM,DISYS,DT,DTIME,IOBS,IOF,IOM,ION,IOS,IOSL,IOST,IOT,IOXY)
-"RTN","ut1",150,0)
- . XECUTE COVCODE
-"RTN","ut1",151,0)
- VIEW "TRACE":0:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M STOP PROFILING
-"RTN","ut1",152,0)
- ;
-"RTN","ut1",153,0)
- D COVCOV($NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J))) ; Venn diagram matching between globals
-"RTN","ut1",154,0)
- ;
-"RTN","ut1",155,0)
- ; Report
-"RTN","ut1",156,0)
- I VERBOSITY=-1 D
-"RTN","ut1",157,0)
- . K ^TMP("%utCOVREPORT",$J)
-"RTN","ut1",158,0)
- . D COVRPTGL($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),$NA(^TMP("%utCOVREPORT",$J)))
-"RTN","ut1",159,0)
- E  D COVRPT($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),VERBOSITY)
-"RTN","ut1",160,0)
- ;
-"RTN","ut1",161,0)
  QUIT
-"RTN","ut1",162,0)
+"RTN","ut1",76,0)
  ;
+"RTN","ut1",77,0)
+NEWSTYLE(LIST,ROUNAME) ; JLI 140726 identify and return list of newstyle tags or entries for this routine
+"RTN","ut1",78,0)
+ ; LIST - input, passed by reference - returns containing array with list of tags identified as tests
+"RTN","ut1",79,0)
+ ;                   LIST indicates number of tags identified, LIST(n)=tag^test_info where tag is entry point for test
+"RTN","ut1",80,0)
+ ; ROUNAME - input - routine name in which tests should be identified
+"RTN","ut1",81,0)
+ ;
+"RTN","ut1",82,0)
+ N I,VALUE,LINE
+"RTN","ut1",83,0)
+ K LIST S LIST=0
+"RTN","ut1",84,0)
+ ; search routine by line for a tag and @TEST declaration
+"RTN","ut1",85,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",86,0)
+ Q
+"RTN","ut1",87,0)
+ ;
+"RTN","ut1",88,0)
+CHECKTAG(LINE) ; JLI 140726 check line to determine @test TAG
+"RTN","ut1",89,0)
+ ; LINE - input - Line of code to be checked
+"RTN","ut1",90,0)
+ ; returns null line if not @TEST line, otherwise TAG^NOTE
+"RTN","ut1",91,0)
+ N TAG,NOTE,CHAR
+"RTN","ut1",92,0)
+ I $E(LINE)=" " Q "" ; test entry must have a tag
+"RTN","ut1",93,0)
+ I $$UP(LINE)'["@TEST" Q "" ; must have @TEST declaration
+"RTN","ut1",94,0)
+ I $P($$UP(LINE),"@TEST")["(" Q "" ; can't have an argument
+"RTN","ut1",95,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",96,0)
+ F  Q:NOTE=""  S CHAR=$E(NOTE),NOTE=$E(NOTE,2,$L(NOTE)) I " ;"'[CHAR Q  ;
+"RTN","ut1",97,0)
+ I $L(NOTE)'=0 Q "" ; @TEST must be first text on line
+"RTN","ut1",98,0)
+ F  Q:$E(LINE)'=" "  S LINE=$E(LINE,2,$L(LINE)) ; remove leading spaces from test info
+"RTN","ut1",99,0)
+ S TAG=TAG_U_LINE
+"RTN","ut1",100,0)
+ Q TAG
+"RTN","ut1",101,0)
+ ;
+"RTN","ut1",102,0)
+ ; VEN/SMH 17DEC2013 - Remove dependence on VISTA - Uppercase here instead of XLFSTR.
+"RTN","ut1",103,0)
+UP(X) ;
+"RTN","ut1",104,0)
+ Q $TR(X,"abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+"RTN","ut1",105,0)
+ ;
+"RTN","ut1",106,0)
+COV(NMSP,COVCODE,VERBOSITY) ; VEN/SMH - PUBLIC ENTRY POINT; Coverage calculations
+"RTN","ut1",107,0)
+ ; NMSP: Namespace of the routines to analyze. End with * to include all routines.
+"RTN","ut1",108,0)
+ ;       Not using * will only include the routine with NMSP name.
+"RTN","ut1",109,0)
+ ;       e.g. PSOM* will include all routines starting with PSOM
+"RTN","ut1",110,0)
+ ;            PSOM will only include PSOM.
+"RTN","ut1",111,0)
+ ; COVCODE: Mumps code to run over which coverage will be calculated. Typically Unit Tests.
+"RTN","ut1",112,0)
+ ; VERBOSITY (optional): Scalar from -1 to 3.
+"RTN","ut1",113,0)
+ ;    - -1 = Global output in ^TMP("%utCOVREPORT",$J)
+"RTN","ut1",114,0)
+ ;    - 0 = Print only total coverage
+"RTN","ut1",115,0)
+ ;    - 1 = Break down by routine
+"RTN","ut1",116,0)
+ ;    - 2 = Break down by routine and tag
+"RTN","ut1",117,0)
+ ;    - 3 = Break down by routine and tag, and print lines that didn't execute for each tag.
+"RTN","ut1",118,0)
+ ;
+"RTN","ut1",119,0)
+ ; ZEXCEPT: %utcovxx - SET and KILLED in this code at top level
+"RTN","ut1",120,0)
+ Q:'(+$SY=47)  ; GT.M only!
+"RTN","ut1",121,0)
+ ;
+"RTN","ut1",122,0)
+ ; ZEXCEPT: CTRAP - not really a variable
+"RTN","ut1",123,0)
+ S VERBOSITY=+$G(VERBOSITY) ; Get 0 if not passed.
+"RTN","ut1",124,0)
+ N %ZR ; GT.M specific
+"RTN","ut1",125,0)
+ D SILENT^%RSEL(NMSP,"SRC") ; GT.M specific. On Cache use $O(^$R(RTN)).
+"RTN","ut1",126,0)
+ ;
+"RTN","ut1",127,0)
+ N RN S RN=""
+"RTN","ut1",128,0)
+ W !,"Loading routines to test coverage...",!
+"RTN","ut1",129,0)
+ F  S RN=$O(%ZR(RN)) Q:RN=""  W RN," " D
+"RTN","ut1",130,0)
+ . N L2 S L2=$T(+2^@RN)
+"RTN","ut1",131,0)
+ . S L2=$TR(L2,$C(9,32)) ; Translate spaces and tabs out
+"RTN","ut1",132,0)
+ . I $E(L2,1,2)'=";;" K %ZR(RN)  ; Not a human produced routine
+"RTN","ut1",133,0)
+ ;
+"RTN","ut1",134,0)
+ N RTNS M RTNS=%ZR
+"RTN","ut1",135,0)
+ K %ZR
+"RTN","ut1",136,0)
+ ;
+"RTN","ut1",137,0)
+ N GL
+"RTN","ut1",138,0)
+ S GL=$NA(^TMP("%utCOVCOHORT",$J))
+"RTN","ut1",139,0)
+ I '$D(^TMP("%utcovrunning",$J)) K @GL
+"RTN","ut1",140,0)
+ D RTNANAL(.RTNS,GL)
+"RTN","ut1",141,0)
+ I '$D(^TMP("%utcovrunning",$J)) D
+"RTN","ut1",142,0)
+ . K ^TMP("%utCOVCOHORTSAV",$J)
+"RTN","ut1",143,0)
+ . M ^TMP("%utCOVCOHORTSAV",$J)=^TMP("%utCOVCOHORT",$J)
+"RTN","ut1",144,0)
+ . K ^TMP("%utCOVRESULT",$J)
+"RTN","ut1",145,0)
+ . S ^TMP("%utcovrunning",$J)=1,%utcovxx=1
+"RTN","ut1",146,0)
+ . VIEW "TRACE":1:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M START PROFILING
+"RTN","ut1",147,0)
+ . Q
+"RTN","ut1",148,0)
+ DO  ; Run the code, but keep our variables to ourselves.
+"RTN","ut1",149,0)
+ . NEW $ETRAP,$ESTACK
+"RTN","ut1",150,0)
+ . SET $ETRAP="Q:($ES&$Q) -9 Q:$ES  W ""CTRL-C ENTERED"""
+"RTN","ut1",151,0)
+ . USE $PRINCIPAL:(CTRAP=$C(3))
+"RTN","ut1",152,0)
+ . NEW (DUZ,IO,COVCODE,U,DILOCKTM,DISYS,DT,DTIME,IOBS,IOF,IOM,ION,IOS,IOSL,IOST,IOT,IOXY)
+"RTN","ut1",153,0)
+ . XECUTE COVCODE
+"RTN","ut1",154,0)
+ . Q
+"RTN","ut1",155,0)
+ ; GT.M STOP PROFILING if this is the original level that started it
+"RTN","ut1",156,0)
+ I $D(^TMP("%utcovrunning",$J)),$D(%utcovxx) VIEW "TRACE":0:$NA(^TMP("%utCOVRESULT",$J)) K %utcovxx,^TMP("%utcovrunning",$J)
+"RTN","ut1",157,0)
+ ;
+"RTN","ut1",158,0)
+ I '$D(^TMP("%utcovrunning",$J)) D
+"RTN","ut1",159,0)
+ . D COVCOV($NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J))) ; Venn diagram matching between globals
+"RTN","ut1",160,0)
+ . ; Report
+"RTN","ut1",161,0)
+ . I VERBOSITY=-1 D
+"RTN","ut1",162,0)
+ . . K ^TMP("%utCOVREPORT",$J)
 "RTN","ut1",163,0)
-RTNANAL(RTNS,GL) ; [Private] - Routine Analysis
+ . . D COVRPTGL($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),$NA(^TMP("%utCOVREPORT",$J)))
 "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.
+ . E  D COVRPT($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),VERBOSITY)
 "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).
+ . Q
 "RTN","ut1",167,0)
- ; tags by themselves don't count toward the total.
+ QUIT
 "RTN","ut1",168,0)
  ;
 "RTN","ut1",169,0)
- N RTN S RTN=""
+RTNANAL(RTNS,GL) ; [Private] - Routine Analysis
 "RTN","ut1",170,0)
- F  S RTN=$O(RTNS(RTN)) Q:RTN=""  D                       ; for each routine
+ ; Create a global similar to the trace global produced by GT.M in GL
 "RTN","ut1",171,0)
- . N TAG
+ ; Only non-comment lines are stored.
 "RTN","ut1",172,0)
- . S TAG=RTN                                              ; start the tags at the first
+ ; 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",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)
+ ; tags by themselves don't count toward the total.
 "RTN","ut1",174,0)
- . . I $E(LN)?1A D  QUIT                                  ; formal line
+ ;
 "RTN","ut1",175,0)
- . . . N T                                                ; Terminator
+ N RTN S RTN=""
 "RTN","ut1",176,0)
- . . . N J F J=1:1:$L(LN) S T=$E(LN,J) Q:T'?1AN           ; Loop to...
+ F  S RTN=$O(RTNS(RTN)) Q:RTN=""  D                       ; for each routine
 "RTN","ut1",177,0)
- . . . S TAG=$E(LN,1,J-1)                                 ; Get tag
+ . N TAG
 "RTN","ut1",178,0)
- . . . S @GL@(RTN,TAG)=TAG                                ; store line
+ . S TAG=RTN                                              ; start the tags at the first
 "RTN","ut1",179,0)
- . . . I T="(" S @GL@(RTN,TAG,0)=LN                       ; formal list
+ . 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",180,0)
- . . . E  D                                               ; No formal list
+ . . I $E(LN)?1A D  QUIT                                  ; formal line
 "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
+ . . . N T                                                ; Terminator
 "RTN","ut1",182,0)
- . . . . I $E(LNTR)=";" QUIT                              ; Comment
+ . . . N J F J=1:1:$L(LN) S T=$E(LN,J) Q:T'?1AN           ; Loop to...
 "RTN","ut1",183,0)
- . . . . S @GL@(RTN,TAG,0)=LN                             ; Otherwise, store for testing
+ . . . S TAG=$E(LN,1,J-1)                                 ; Get tag
 "RTN","ut1",184,0)
- . . . S I=0                                              ; Start offsets from zero (first one at the for will be 1)
+ . . . S @GL@(RTN,TAG)=TAG                                ; store line
 "RTN","ut1",185,0)
- . . I $C(32,9)[$E(LN) D  QUIT                            ; Regular line
+ . . . I T="(" S @GL@(RTN,TAG,0)=LN                       ; formal list
 "RTN","ut1",186,0)
- . . . N LNTR S LNTR=$TR(LN,$C(32,9))                     ; Remove all spaces and tabs
+ . . . E  D                                               ; No formal list
 "RTN","ut1",187,0)
- . . . I $E(LNTR)=";" QUIT                                ; Comment line -- don't want.
+ . . . . 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",188,0)
- . . . S @GL@(RTN,TAG,I)=LN                               ; Record line
+ . . . . I $E(LNTR)=";" QUIT                              ; Comment
 "RTN","ut1",189,0)
- QUIT
+ . . . . S @GL@(RTN,TAG,0)=LN                             ; Otherwise, store for testing
 "RTN","ut1",190,0)
- ;
+ . . . S I=0                                              ; Start offsets from zero (first one at the for will be 1)
 "RTN","ut1",191,0)
-ACTLINES(GL) ; [Private] $$ ; Count active lines
+ . . I $C(32,9)[$E(LN) D  QUIT                            ; Regular line
 "RTN","ut1",192,0)
- ;
+ . . . N LNTR S LNTR=$TR(LN,$C(32,9,46))                     ; Remove all spaces and tabs - JLI 150202 remove periods as well
 "RTN","ut1",193,0)
- N CNT S CNT=0
+ . . . I $E(LNTR)=";" QUIT                                ; Comment line -- don't want.
 "RTN","ut1",194,0)
- N REF S REF=GL
+ . . . S @GL@(RTN,TAG,I)=LN                               ; Record line
 "RTN","ut1",195,0)
- N GLQL S GLQL=$QL(GL)
+ QUIT
 "RTN","ut1",196,0)
- F  S REF=$Q(@REF) Q:REF=""  Q:(GL'=$NA(@REF,GLQL))  D
+ ;
 "RTN","ut1",197,0)
- . N REFQL S REFQL=$QL(REF)
+ACTLINES(GL) ; [Private] $$ ; Count active lines
 "RTN","ut1",198,0)
- . N LASTSUB S LASTSUB=$QS(REF,REFQL)
+ ;
 "RTN","ut1",199,0)
- . I LASTSUB?1.N S CNT=CNT+1
+ N CNT S CNT=0
 "RTN","ut1",200,0)
- QUIT CNT
+ N REF S REF=GL
 "RTN","ut1",201,0)
- ;
+ N GLQL S GLQL=$QL(GL)
 "RTN","ut1",202,0)
-COVCOV(C,R) ; [Private] - Analyze coverage Cohort vs Result
+ F  S REF=$Q(@REF) Q:REF=""  Q:(GL'=$NA(@REF,GLQL))  D
 "RTN","ut1",203,0)
- N RTN S RTN=""
+ . N REFQL S REFQL=$QL(REF)
 "RTN","ut1",204,0)
- F  S RTN=$O(@C@(RTN)) Q:RTN=""  D  ; For each routine in cohort set
+ . N LASTSUB S LASTSUB=$QS(REF,REFQL)
 "RTN","ut1",205,0)
- . I '$D(@R@(RTN)) QUIT             ; Not present in result set
+ . I LASTSUB?1.N S CNT=CNT+1
 "RTN","ut1",206,0)
- . N TAG S TAG=""
+ QUIT CNT
 "RTN","ut1",207,0)
- . F  S TAG=$O(@R@(RTN,TAG)) Q:TAG=""  D  ; For each tag in the routine in the result set
+ ;
 "RTN","ut1",208,0)
- . . N LN S LN=""
+COVCOV(C,R) ; [Private] - Analyze coverage Cohort vs Result
 "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
-"RTN","ut1",210,0)
- . . . I $D(@C@(RTN,TAG,LN)) K ^(LN)  ; if present in cohort, kill off
-"RTN","ut1",211,0)
- QUIT
-"RTN","ut1",212,0)
- ;
-"RTN","ut1",213,0)
-COVRPT(C,S,R,V) ; [Private] - Coverage Report
-"RTN","ut1",214,0)
- ; C = COHORT    - Global name
-"RTN","ut1",215,0)
- ; S = SURVIVORS - Global name
-"RTN","ut1",216,0)
- ; R = RESULT    - Global name
-"RTN","ut1",217,0)
- ; V = Verbosity - Scalar from -1 to 3
-"RTN","ut1",218,0)
- N ORIGLINES S ORIGLINES=$$ACTLINES(C)
-"RTN","ut1",219,0)
- N LEFTLINES S LEFTLINES=$$ACTLINES(S)
-"RTN","ut1",220,0)
- W !!
-"RTN","ut1",221,0)
- W "ORIG: "_ORIGLINES,!
-"RTN","ut1",222,0)
- W "LEFT: "_LEFTLINES,!
-"RTN","ut1",223,0)
- W "COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00),!
-"RTN","ut1",224,0)
- W !!
-"RTN","ut1",225,0)
- W "BY ROUTINE:",!
-"RTN","ut1",226,0)
- I V=0 QUIT  ; No verbosity. Don't print routine detail
-"RTN","ut1",227,0)
  N RTN S RTN=""
-"RTN","ut1",228,0)
- F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
-"RTN","ut1",229,0)
- . N O S O=$$ACTLINES($NA(@C@(RTN)))
-"RTN","ut1",230,0)
- . N L S L=$$ACTLINES($NA(@S@(RTN)))
-"RTN","ut1",231,0)
- . W ?3,RTN,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
-"RTN","ut1",232,0)
- . I V=1 QUIT  ; Just print the routine coverage for V=1
-"RTN","ut1",233,0)
+"RTN","ut1",210,0)
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D  ; For each routine in cohort set
+"RTN","ut1",211,0)
+ . I '$D(@R@(RTN)) QUIT             ; Not present in result set
+"RTN","ut1",212,0)
  . N TAG S TAG=""
-"RTN","ut1",234,0)
- . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
-"RTN","ut1",235,0)
- . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
-"RTN","ut1",236,0)
- . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
-"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
-"RTN","ut1",239,0)
+"RTN","ut1",213,0)
+ . F  S TAG=$O(@R@(RTN,TAG)) Q:TAG=""  D  ; For each tag in the routine in the result set
+"RTN","ut1",214,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)
+"RTN","ut1",215,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",216,0)
+ . . . I $D(@C@(RTN,TAG,LN)) K ^(LN)  ; if present in cohort, kill off
+"RTN","ut1",217,0)
  QUIT
-"RTN","ut1",242,0)
+"RTN","ut1",218,0)
  ;
-"RTN","ut1",243,0)
-COVRPTGL(C,S,R,OUT) ; [Private] - Coverage Global for silent invokers
-"RTN","ut1",244,0)
+"RTN","ut1",219,0)
+COVRPT(C,S,R,V) ; [Private] - Coverage Report
+"RTN","ut1",220,0)
  ; C = COHORT    - Global name
-"RTN","ut1",245,0)
+"RTN","ut1",221,0)
  ; S = SURVIVORS - Global name
-"RTN","ut1",246,0)
+"RTN","ut1",222,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)
+"RTN","ut1",223,0)
+ ; V = Verbosity - Scalar from -1 to 3
+"RTN","ut1",224,0)
+ ; JLI 150702 -  modified to be able to do unit tests on setting up the text via COVRPTLS
+"RTN","ut1",225,0)
+ N X
+"RTN","ut1",226,0)
+ S X=$NA(^TMP("%ut1-covrpt",$J)) K @X
+"RTN","ut1",227,0)
+ D COVRPTLS(C,S,R,V,X)
+"RTN","ut1",228,0)
+ F I=1:1 Q:'$D(@X@(I))  W !,@X@(I)
+"RTN","ut1",229,0)
+ K @X
+"RTN","ut1",230,0)
  Q
-"RTN","ut1",267,0)
+"RTN","ut1",231,0)
  ;
+"RTN","ut1",232,0)
+COVRPTLS(C,S,R,V,X) ;
+"RTN","ut1",233,0)
+ ;
+"RTN","ut1",234,0)
+ N LINNUM S LINNUM=0
+"RTN","ut1",235,0)
+ N ORIGLINES S ORIGLINES=$$ACTLINES(C)
+"RTN","ut1",236,0)
+ N LEFTLINES S LEFTLINES=$$ACTLINES(S)
+"RTN","ut1",237,0)
+ ;W !!
+"RTN","ut1",238,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="",LINNUM=LINNUM+1,@X@(LINNUM)=""
+"RTN","ut1",239,0)
+ ;W "ORIG: "_ORIGLINES,!
+"RTN","ut1",240,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="ORIG: "_ORIGLINES
+"RTN","ut1",241,0)
+ ;W "LEFT: "_LEFTLINES,!
+"RTN","ut1",242,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="LEFT: "_LEFTLINES
+"RTN","ut1",243,0)
+ ;W "COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00),!
+"RTN","ut1",244,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00)
+"RTN","ut1",245,0)
+ ;W !!
+"RTN","ut1",246,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="",LINNUM=LINNUM+1,@X@(LINNUM)=""
+"RTN","ut1",247,0)
+ ;W "BY ROUTINE:",!
+"RTN","ut1",248,0)
+ S LINNUM=LINNUM+1,@X@(LINNUM)="BY ROUTINE:"
+"RTN","ut1",249,0)
+ I V=0 QUIT  ; No verbosity. Don't print routine detail
+"RTN","ut1",250,0)
+ N RTN S RTN=""
+"RTN","ut1",251,0)
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
+"RTN","ut1",252,0)
+ . N O S O=$$ACTLINES($NA(@C@(RTN)))
+"RTN","ut1",253,0)
+ . N L S L=$$ACTLINES($NA(@S@(RTN)))
+"RTN","ut1",254,0)
+ . ;W ?3,RTN,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+"RTN","ut1",255,0)
+ . N XX S XX="  "_RTN_"                    ",XX=$E(XX,1,20)
+"RTN","ut1",256,0)
+ . S LINNUM=LINNUM+1,@X@(LINNUM)=XX+$S(O:$J(O-L/O*100,"",2),1:"100.00")
+"RTN","ut1",257,0)
+ . I V=1 QUIT  ; Just print the routine coverage for V=1
+"RTN","ut1",258,0)
+ . N TAG S TAG=""
+"RTN","ut1",259,0)
+ . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
+"RTN","ut1",260,0)
+ . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
+"RTN","ut1",261,0)
+ . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
+"RTN","ut1",262,0)
+ . . ;W ?5,TAG,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+"RTN","ut1",263,0)
+ . . S XX="    "_TAG_"                  ",XX=$E(XX,1,20)
+"RTN","ut1",264,0)
+ . . S LINNUM=LINNUM+1,@X@(LINNUM)=XX_$S(O:$J(O-L/O*100,"",2),1:"100.00")
+"RTN","ut1",265,0)
+ . . I V=2 QUIT  ; Just print routine/tags coverage for V=2; V=3 print uncovered lines
+"RTN","ut1",266,0)
+ . . N LN S LN=""
+"RTN","ut1",267,0)
+ . . ;F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  W TAG_"+"_LN_": "_^(LN),!
+"RTN","ut1",268,0)
+ . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  S LINNUM=LINNUM+1,@X@(LINNUM)=TAG_"+"_LN_": "_^(LN)
+"RTN","ut1",269,0)
+ . . Q
+"RTN","ut1",270,0)
+ . Q
+"RTN","ut1",271,0)
+ QUIT
+"RTN","ut1",272,0)
+ ;
+"RTN","ut1",273,0)
+COVRPTGL(C,S,R,OUT) ; [Private] - Coverage Global for silent invokers
+"RTN","ut1",274,0)
+ ; C = COHORT    - Global name
+"RTN","ut1",275,0)
+ ; S = SURVIVORS - Global name
+"RTN","ut1",276,0)
+ ; R = RESULT    - Global name
+"RTN","ut1",277,0)
+ ; OUT = OUTPUT  - Global name
+"RTN","ut1",278,0)
+ ;
+"RTN","ut1",279,0)
+ N O S O=$$ACTLINES(C)
+"RTN","ut1",280,0)
+ N L S L=$$ACTLINES(S)
+"RTN","ut1",281,0)
+ S @OUT=(O-L)_"/"_O
+"RTN","ut1",282,0)
+ N RTN,TAG,LN S (RTN,TAG,LN)=""
+"RTN","ut1",283,0)
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
+"RTN","ut1",284,0)
+ . N O S O=$$ACTLINES($NA(@C@(RTN)))
+"RTN","ut1",285,0)
+ . N L S L=$$ACTLINES($NA(@S@(RTN)))
+"RTN","ut1",286,0)
+ . S @OUT@(RTN)=(O-L)_"/"_O
+"RTN","ut1",287,0)
+ . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
+"RTN","ut1",288,0)
+ . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
+"RTN","ut1",289,0)
+ . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
+"RTN","ut1",290,0)
+ . . S @OUT@(RTN,TAG)=(O-L)_"/"_O
+"RTN","ut1",291,0)
+ . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  S @OUT@(RTN,TAG,LN)=@S@(RTN,TAG,LN)
+"RTN","ut1",292,0)
+ QUIT
+"RTN","ut1",293,0)
+ ;
+"RTN","utcover")
+0^10^B63651128
+"RTN","utcover",1,0)
+%utcover        ;JLI - generic coverage and unit test runner ; 7/3/15 2:54am
+"RTN","utcover",2,0)
+ ;;0.1;MASH UTILITIES;;;Build 5
+"RTN","utcover",3,0)
+        ;
+"RTN","utcover",4,0)
+        Q
+"RTN","utcover",5,0)
+        ;
+"RTN","utcover",6,0)
+TESTONLY(TESTROUS)      ; RUN TESTS FOR SPECIFIED ROUTINES
+"RTN","utcover",7,0)
+        ; input TESTROUS - passed by reference - array of routine names to run tests for
+"RTN","utcover",8,0)
+        ;               specify those to be called directly by including ^ as part of
+"RTN","utcover",9,0)
+        ;               TAG^ROUTINE or ^ROUTINE.
+"RTN","utcover",10,0)
+        ;               ROUTINE names without a ^ will be called as EN^%ut("ROUTINE")
+"RTN","utcover",11,0)
+        ;               Sometimes to get complete coverage, different entry points may
+"RTN","utcover",12,0)
+        ;               need to be called (e.g., at top and for VERBOSE), these should each
+"RTN","utcover",13,0)
+        ;               be included.
+"RTN","utcover",14,0)
+        ;               If the subscript is a number, it will take the list of comma separated
+"RTN","utcover",15,0)
+        ;               values as the routines.  If the the subscript is not a number, it will
+"RTN","utcover",16,0)
+        ;               take it as a routine to be added to the list, then if the value of the
+"RTN","utcover",17,0)
+        ;               contains a comma separated list of routines, they will be added as well.
+"RTN","utcover",18,0)
+        ;               Thus a value of
+"RTN","utcover",19,0)
+        ;                 TESTROUS(1)="A^ROU1,^ROU1,^ROU2,ROU3"
+"RTN","utcover",20,0)
+        ;               or a value of
+"RTN","utcover",21,0)
+        ;                 TESTROUS("A^ROU1")="^ROU1,^ROU2,ROU3"
+"RTN","utcover",22,0)
+        ;               will both result in tests for
+"RTN","utcover",23,0)
+        ;                 D A^ROU1,^ROU1,^ROU2,EN^%ut("ROU3")
+"RTN","utcover",24,0)
+        K ^TMP("%utCOVER",$J,"TESTROUS")
+"RTN","utcover",25,0)
+        M ^TMP("%utCOVER",$J,"TESTROUS")=TESTROUS
+"RTN","utcover",26,0)
+        ;
+"RTN","utcover",27,0)
+COVENTRY        ; setup of COVERAGE NEWs most variables, so TESTROUS passed by global
+"RTN","utcover",28,0)
+        ;
+"RTN","utcover",29,0)
+        N I,ROU,VAL,VALS,UTDATA,TESTS,TESTROUS
+"RTN","utcover",30,0)
+        M TESTROUS=^TMP("%utCOVER",$J,"TESTROUS")
+"RTN","utcover",31,0)
+        S ROU="" F  S ROU=$O(TESTROUS(ROU)) Q:ROU=""  D
+"RTN","utcover",32,0)
+        . I ROU'=+ROU S TESTS(ROU)=""
+"RTN","utcover",33,0)
+        . F I=1:1 S VAL=$P(TESTROUS(ROU),",",I) Q:VAL=""  S TESTS(VAL)=""
+"RTN","utcover",34,0)
+        . Q
+"RTN","utcover",35,0)
+        S ROU="" F  S ROU=$O(TESTS(ROU)) Q:ROU=""  D
+"RTN","utcover",36,0)
+        . W !!,"RUNNING ",ROU
+"RTN","utcover",37,0)
+        . I ROU[U D @ROU
+"RTN","utcover",38,0)
+        . I ROU'[U D @("EN^%ut("""_ROU_""")")
+"RTN","utcover",39,0)
+        . S VALS=$G(^TMP("%ut",$J,"UTVALS")) I VALS="" Q
+"RTN","utcover",40,0)
+        . F I=1:1 S VAL=$P(VALS,U,I) Q:VAL=""  S UTDATA(I)=$G(UTDATA(I))+VAL
+"RTN","utcover",41,0)
+        . K ^TMP("%ut",$J)
+"RTN","utcover",42,0)
+        . Q
+"RTN","utcover",43,0)
+        I $D(UTDATA) D
+"RTN","utcover",44,0)
+        . W !!!,"------------ SUMMARY ------------"
+"RTN","utcover",45,0)
+        . W !,"Ran ",UTDATA(1)," Routine",$S(UTDATA(1)>1:"s",1:""),", ",UTDATA(2)," Entry Tag",$S(UTDATA(2)>1:"s",1:"")
+"RTN","utcover",46,0)
+        . 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","utcover",47,0)
+        . Q
+"RTN","utcover",48,0)
+        Q
+"RTN","utcover",49,0)
+        ;
+"RTN","utcover",50,0)
+COVERAGE(ROUNMSP,TESTROUS,XCLDROUS,RESLTLVL)    ; run coverage analysis
+"RTN","utcover",51,0)
+        ; input ROUNMSP - Namespace for routine(s) to be analyzed
+"RTN","utcover",52,0)
+        ;                 ROUNAME will result in only the routine ROUNAME being analyzed
+"RTN","utcover",53,0)
+        ;                 ROUN* will result in all routines beginning with ROUN being analyzed
+"RTN","utcover",54,0)
+        ; input TESTROUS - passed by reference - see TESTROUS description for JUSTTEST
+"RTN","utcover",55,0)
+        ; input XCLDROUS - passed by reference - routines passed in a manner similar to TESTROUS,
+"RTN","utcover",56,0)
+        ;                  but only the routine names, whether as arguments or a comma separated
+"RTN","utcover",57,0)
+        ;                  list of routines, will be excluded from the analysis of coverage.  These
+"RTN","utcover",58,0)
+        ;                  would normally be names of routines which are only for unit tests, or
+"RTN","utcover",59,0)
+        ;                  others which should not be included in the analysis for some reason.
+"RTN","utcover",60,0)
+        ; input RESLTLVL - This value determines the amount of information to be generated for the
+"RTN","utcover",61,0)
+        ;                  analysis.  A missing or null value will be considered to be level 1
+"RTN","utcover",62,0)
+        ;                     1  -  Listing of analysis only for routine overall
+"RTN","utcover",63,0)
+        ;                     2  -  Listing of analysis for routine overall and for each TAG
+"RTN","utcover",64,0)
+        ;                     3  -  Full analysis for each tag, and lists out those lines which were
+"RTN","utcover",65,0)
+        ;                           not executed during the analysis
+"RTN","utcover",66,0)
+        ;
+"RTN","utcover",67,0)
+        N I,ROU,TYPE,VAL,XCLUDE
+"RTN","utcover",68,0)
+        S RESLTLVL=$G(RESLTLVL,1)
+"RTN","utcover",69,0)
+        I (RESLTLVL<1) S RESLTLVL=1
+"RTN","utcover",70,0)
+        I (RESLTLVL>3) S RESLTLVL=3
+"RTN","utcover",71,0)
+        M ^TMP("%utCOVER",$J,"TESTROUS")=TESTROUS ; 
+"RTN","utcover",72,0)
+        D COV^%ut1(ROUNMSP,"D COVENTRY^%utCOVER",-1)
+"RTN","utcover",73,0)
+        K ^TMP("%utCOVER",$J,"TESTROUS")
+"RTN","utcover",74,0)
+        S ROU="" F  S ROU=$O(XCLDROUS(ROU)) Q:ROU=""  D
+"RTN","utcover",75,0)
+        . I ROU'=+ROU S XCLUDE(ROU)=""
+"RTN","utcover",76,0)
+        . F I=1:1 S VAL=$P(XCLDROUS(ROU),",",I) Q:VAL=""  S XCLUDE(VAL)=""
+"RTN","utcover",77,0)
+        . Q
+"RTN","utcover",78,0)
+        N TEXTGLOB S TEXTGLOB=$NA(^TMP("%utcover-text",$J))
+"RTN","utcover",79,0)
+        D LIST(.XCLUDE,RESLTLVL,TEXTGLOB)
+"RTN","utcover",80,0)
+        F I=1:1 Q:'$D(@TEXTGLOB@(I))  W !,@TEXTGLOB@(I)
+"RTN","utcover",81,0)
+        K @TEXTGLOB
+"RTN","utcover",82,0)
+        Q
+"RTN","utcover",83,0)
+        ;
+"RTN","utcover",84,0)
+LIST(XCLDROUS,TYPE,TEXTGLOB,GLOB)         ;
+"RTN","utcover",85,0)
+        ; ZEXCEPT: TYPE1  - NEWed and set below for recursion
+"RTN","utcover",86,0)
+        ; input - ROULIST - a comma separated list of routine names that will
+"RTN","utcover",87,0)
+        ;       be used to identify desired routines.  Any name
+"RTN","utcover",88,0)
+        ;       that begins with one of the specified values will
+"RTN","utcover",89,0)
+        ;       be included
+"RTN","utcover",90,0)
+        ; input - TYPE - value indicating amount of detail desired
+"RTN","utcover",91,0)
+        ;       3=full with listing of untouched lines
+"RTN","utcover",92,0)
+        ;       2=moderated with listing by tags
+"RTN","utcover",93,0)
+        ;       1=summary with listing by routine
+"RTN","utcover",94,0)
+        ; input - TEXTGLOB - closed global location in which text is returned
+"RTN","utcover",95,0)
+        ; input - GLOB - used for unit tests - specifies global to work with
+"RTN","utcover",96,0)
+        ;                so that coverage data is not impacted
+"RTN","utcover",97,0)
+        ;
+"RTN","utcover",98,0)
+        N CURRCOV,CURRLIN,LINCOV,LINE,LINTOT,ROULIST,ROUNAME,TAG,TOTCOV,TOTLIN,XVAL,LINNUM
+"RTN","utcover",99,0)
+        ;
+"RTN","utcover",100,0)
+        I '$D(GLOB) N GLOB S GLOB=$NA(^TMP("%utCOVREPORT",$J))
+"RTN","utcover",101,0)
+        D TRIMDATA(.XCLDROUS,GLOB) ; remove undesired routines from data
+"RTN","utcover",102,0)
+        ;
+"RTN","utcover",103,0)
+        N JOB,NAME,BASE
+"RTN","utcover",104,0)
+        S TOTCOV=0,TOTLIN=0,LINNUM=0
+"RTN","utcover",105,0)
+        ; F NAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
+"RTN","utcover",106,0)
+        I TYPE>1 S ROUNAME="" F  S ROUNAME=$O(@GLOB@(ROUNAME)) Q:ROUNAME=""  S XVAL=^(ROUNAME) D
+"RTN","utcover",107,0)
+        . S CURRCOV=$P(XVAL,"/"),CURRLIN=$P(XVAL,"/",2)
+"RTN","utcover",108,0)
+        . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="",LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=""
+"RTN","utcover",109,0)
+        . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="Routine "_ROUNAME_"   "_CURRCOV_" out of "_CURRLIN_" lines covered"_$S(CURRLIN>0:"  ("_$P((100*CURRCOV)/CURRLIN,".")_"%)",1:"")
+"RTN","utcover",110,0)
+        . I TYPE=2 S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="  - Summary"
+"RTN","utcover",111,0)
+        . S TAG="" F  S TAG=$O(@GLOB@(ROUNAME,TAG)) Q:TAG=""  S XVAL=^(TAG) D
+"RTN","utcover",112,0)
+        . . S LINCOV=$P(XVAL,"/"),LINTOT=$P(XVAL,"/",2)
+"RTN","utcover",113,0)
+        . . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=" Tag "_TAG_"^"_ROUNAME_"   "_LINCOV_" out of "_LINTOT_" lines covered"
+"RTN","utcover",114,0)
+        . . I TYPE=2 Q
+"RTN","utcover",115,0)
+        . . I LINCOV=LINTOT Q
+"RTN","utcover",116,0)
+        . . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="   the following is a list of lines NOT covered"
+"RTN","utcover",117,0)
+        . . S LINE="" F  S LINE=$O(@GLOB@(ROUNAME,TAG,LINE)) Q:LINE=""  D
+"RTN","utcover",118,0)
+        . . . I LINE=0 S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="   "_TAG_"  "_@GLOB@(ROUNAME,TAG,LINE) Q
+"RTN","utcover",119,0)
+        . . . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="   "_TAG_"+"_LINE_"  "_@GLOB@(ROUNAME,TAG,LINE)
+"RTN","utcover",120,0)
+        . . . Q
+"RTN","utcover",121,0)
+        . . Q
+"RTN","utcover",122,0)
+        . Q
+"RTN","utcover",123,0)
+        ; for type=3 generate a summary at bottom after detail
+"RTN","utcover",124,0)
+        I TYPE=3 N TYPE1 S TYPE1=2 D LIST(.XCLDROUS,2,TEXTGLOB,GLOB) K TYPE1
+"RTN","utcover",125,0)
+        I TYPE=2,$G(TYPE1) Q  ; CAME IN FROM ABOVE LINE
+"RTN","utcover",126,0)
+        ; summarize by just routine name
+"RTN","utcover",127,0)
+        S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="",LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=""
+"RTN","utcover",128,0)
+        S ROUNAME="" F  S ROUNAME=$O(@GLOB@(ROUNAME)) Q:ROUNAME=""  S XVAL=^(ROUNAME) D
+"RTN","utcover",129,0)
+        . S CURRCOV=$P(XVAL,"/"),CURRLIN=$P(XVAL,"/",2)
+"RTN","utcover",130,0)
+        . S TOTCOV=TOTCOV+CURRCOV,TOTLIN=TOTLIN+CURRLIN
+"RTN","utcover",131,0)
+        . S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="Routine "_ROUNAME_"   "_CURRCOV_" out of "_CURRLIN_" lines covered"_$S(CURRLIN>0:"  ("_$P((100*CURRCOV)/CURRLIN,".")_"%)",1:"")
+"RTN","utcover",132,0)
+        . Q
+"RTN","utcover",133,0)
+        S LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)="",LINNUM=LINNUM+1,@TEXTGLOB@(LINNUM)=""
+"RTN","utcover",134,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",135,0)
+        Q
+"RTN","utcover",136,0)
+        ;
+"RTN","utcover",137,0)
+TRIMDATA(ROULIST,GLOB)     ;
+"RTN","utcover",138,0)
+        N ROUNAME
+"RTN","utcover",139,0)
+        S ROUNAME="" F  S ROUNAME=$O(ROULIST(ROUNAME)) Q:ROUNAME=""  K @GLOB@(ROUNAME)
+"RTN","utcover",140,0)
+        Q
+"RTN","utcover",141,0)
+        ;
 "RTN","utt1")
-0^3^B25860592
+0^3^B26409996
 "RTN","utt1",1,0)
 %utt1 ; VEN/SMH - Testing routines for M-Unit;08/29/14  11:35
 "RTN","utt1",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","utt1",3,0)
 %utNITT ; VEN/SMH - Testing routines for M-Unit;2014-04-01  2:04 PM
 "RTN","utt1",4,0)
@@ -2527,12 +3027,14 @@ XTROU ; Routines containing additional tests
  ;;%utt5;
 "RTN","utt1",150,0)
  ;;%utt6;
+"RTN","utt1",151,0)
+ ;;%uttcovr;coverage related tests
 "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;
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","utt2",3,0)
 XTMUNITU ; VEN/SMH - Bad Ass Continuation of Unit Tests;2014-04-01  1:03 PM
 "RTN","utt2",4,0)
@@ -2558,7 +3060,7 @@ XTENT ;
 "RTN","utt3",1,0)
 %utt3 ; VEN/SMH - Unit Tests Coverage Tests;08/14/14  14:02
 "RTN","utt3",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","utt3",3,0)
 XTMUNITV ; VEN/SMH - Unit Tests Coverage Tests;2014-04-16  7:14 PM
 "RTN","utt3",4,0)
@@ -2646,7 +3148,7 @@ INTERNAL(A) ; Counts
 "RTN","utt4",1,0)
 %utt4 ; VEN/SMH - Coverage Test Runner;08/23/14  08:33
 "RTN","utt4",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","utt4",3,0)
 XTMUNITW ; VEN/SMH - Coverage Test Runner;2014-04-17  3:30 PM
 "RTN","utt4",4,0)
@@ -2690,7 +3192,7 @@ MAIN ; @TEST - Test coverage calculations
 "RTN","utt5",1,0)
 %utt5 ;JLI - test for aspects of MUnit functionality ;08/29/14  11:23
 "RTN","utt5",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","utt5",3,0)
  Q
 "RTN","utt5",4,0)
@@ -2958,11 +3460,11 @@ XTENT ;
 "RTN","utt5",135,0)
  ;;ISUTEST;check ISUTEST inside unit test
 "RTN","utt6")
-0^8^B29243478
+0^8^B30140551
 "RTN","utt6",1,0)
 %utt6 ;JLI - Unit tests for MUnit functionality ;08/29/14  11:43
 "RTN","utt6",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","utt6",3,0)
  ;
 "RTN","utt6",4,0)
@@ -3078,117 +3580,123 @@ VERBOSE ;
 "RTN","utt6",59,0)
  ;
 "RTN","utt6",60,0)
- ; now run the unit tests in this routine
+ W !!,"NOW RUNNING UNIT TESTS FOR %uttcovr",!!
 "RTN","utt6",61,0)
- W !!,"NOW RUNNING UNIT TESTS FOR %utt6",!!
+ D EN^%ut("%uttcovr",VERBOSE)
 "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)
+ ; now run the unit tests in this routine
 "RTN","utt6",64,0)
- ; clean up after GUI calls as well
+ W !!,"NOW RUNNING UNIT TESTS FOR %utt6",!!
 "RTN","utt6",65,0)
- K ^TMP("GUI-MUNIT",$J),^TMP("GUINEXT",$J),^TMP("MUNIT-%utRSLT",$J)
+ D EN^%ut("%utt6",VERBOSE)
 "RTN","utt6",66,0)
- Q
+ K ^TMP("%utt5",$J),^TMP("%utt5_C",$J),^TMP("%utt5_G",$J),^TMP("%utt6",$J),^TMP("%utt6_GUISET",$J)
 "RTN","utt6",67,0)
- ;
+ ; clean up after GUI calls as well
 "RTN","utt6",68,0)
- ;
+ K ^TMP("GUI-MUNIT",$J),^TMP("GUINEXT",$J),^TMP("MUNIT-%utRSLT",$J)
 "RTN","utt6",69,0)
- ;           WARNING     --      WARNING     --      WARNING
+ Q
 "RTN","utt6",70,0)
- ; If the number of NEW STYLE tests in %utt5 is increased (it is currently 1), then the following
+ ;
 "RTN","utt6",71,0)
- ; test will need to be updated to reflect the change(s)
+ ;
 "RTN","utt6",72,0)
- ;     END OF WARNING  --  END OF WARNING  --  END OF WARNING
+ ;           WARNING     --      WARNING     --      WARNING
 "RTN","utt6",73,0)
- ;
+ ; If the number of NEW STYLE tests in %utt5 is increased (it is currently 1), then the following
 "RTN","utt6",74,0)
-NEWSTYLE ; tests return of valid new style or @TEST indicators
+ ; test will need to be updated to reflect the change(s)
 "RTN","utt6",75,0)
- N LIST
+ ;     END OF WARNING  --  END OF WARNING  --  END OF WARNING
 "RTN","utt6",76,0)
- D NEWSTYLE^%ut1(.LIST,"%utt5")
+ ;
 "RTN","utt6",77,0)
- D CHKEQ^%ut(LIST,1,"Returned an incorrect number ("_LIST_") of New Style indicators - should be one")
+NEWSTYLE ; tests return of valid new style or @TEST indicators
 "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))
+ N LIST
 "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)")
+ D NEWSTYLE^%ut1(.LIST,"%utt5")
 "RTN","utt6",80,0)
- Q
+ D CHKEQ^%ut(LIST,1,"Returned an incorrect number ("_LIST_") of New Style indicators - should be one")
 "RTN","utt6",81,0)
- ;
+ I LIST>0 D CHKEQ^%ut(LIST(1),"NEWSTYLE^identify new style test indicator functionality","Returned incorrect TAG^reason "_LIST(1))
 "RTN","utt6",82,0)
-CKGUISET ;
+ 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",83,0)
- ; ZEXCEPT: %utt6var - if present, is NEWed and created in code following VERBOSE
+ Q
 "RTN","utt6",84,0)
- I '$D(%utt6var) Q
+ ;
 "RTN","utt6",85,0)
- N MAX
+CKGUISET ;
 "RTN","utt6",86,0)
- S MAX=$O(^TMP("%utt6_GUISET",$J,""),-1)
+ ; ZEXCEPT: %utt6var - if present, is NEWed and created in code following VERBOSE
 "RTN","utt6",87,0)
- D CHKTF^%ut(^TMP("%utt6_GUISET",$J,MAX)["%utt6^NEWSTYLE","GUISET returned incorrect list")
+ I '$D(%utt6var) Q
 "RTN","utt6",88,0)
- Q
+ N MAX
 "RTN","utt6",89,0)
- ;
+ S MAX=$O(^TMP("%utt6_GUISET",$J,""),-1)
 "RTN","utt6",90,0)
-CHKCMDLN ; check command line processing of %utt5
+ D CHKTF^%ut(^TMP("%utt6_GUISET",$J,MAX)["%utt6^NEWSTYLE","GUISET returned incorrect list")
 "RTN","utt6",91,0)
- ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+ Q
 "RTN","utt6",92,0)
- I '$D(%utt6var) Q
+ ;
 "RTN","utt6",93,0)
- D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+CHKCMDLN ; check command line processing of %utt5
 "RTN","utt6",94,0)
- D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
-"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'")
-"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'")
-"RTN","utt6",97,0)
- Q
-"RTN","utt6",98,0)
- ;
-"RTN","utt6",99,0)
-CHKGUI ; check GUI processing of %utt5
-"RTN","utt6",100,0)
  ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
-"RTN","utt6",101,0)
+"RTN","utt6",95,0)
  I '$D(%utt6var) Q
-"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)
+"RTN","utt6",96,0)
+ D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",97,0)
+ D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",98,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'")
+"RTN","utt6",99,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'")
+"RTN","utt6",100,0)
  Q
-"RTN","utt6",107,0)
+"RTN","utt6",101,0)
  ;
+"RTN","utt6",102,0)
+CHKGUI ; check GUI processing of %utt5
+"RTN","utt6",103,0)
+ ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+"RTN","utt6",104,0)
+ I '$D(%utt6var) Q
+"RTN","utt6",105,0)
+ D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",106,0)
+ D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
+"RTN","utt6",107,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",108,0)
-XTENT ;
+ 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",109,0)
- ;;CHKCMDLN;check command line processing of %utt5
+ Q
 "RTN","utt6",110,0)
- ;;CHKGUI;check GUI processing of %utt5
+ ;
 "RTN","utt6",111,0)
- ;;CKGUISET;check list of tests returned by GUISET
+XTENT ;
 "RTN","utt6",112,0)
+ ;;CHKCMDLN;check command line processing of %utt5
+"RTN","utt6",113,0)
+ ;;CHKGUI;check GUI processing of %utt5
+"RTN","utt6",114,0)
+ ;;CKGUISET;check list of tests returned by GUISET
+"RTN","utt6",115,0)
  ;;NEWSTYLE;test return of valid new style or @TEST indicators
 "RTN","uttcovr")
-0^9^B2835727
+0^9^B88235384
 "RTN","uttcovr",1,0)
-%uttcovr ;JLI/JIVEYSOFT - runs coverage tests on %ut and %ut1 routines via unit tests ;09/10/14  14:34
+uttcovr ;JLI/JIVEYSOFT - runs coverage tests on %ut and %ut1 routines via unit tests ; 7/3/15 12:39pm
 "RTN","uttcovr",2,0)
- ;;0.1;MASH UTILITIES;
+ ;;0.1;MASH UTILITIES;;;Build 5
 "RTN","uttcovr",3,0)
  ;
 "RTN","uttcovr",4,0)
@@ -3196,87 +3704,389 @@ XTENT ;
 "RTN","uttcovr",5,0)
  ;
 "RTN","uttcovr",6,0)
- ; if SHOWALL is true (1) all coverage globals data are listed
+ ; Have it run the following entry points or, if no ^, call EN^%ut with routine name
 "RTN","uttcovr",7,0)
- ; if SHOWALL is false (0), only the %utCOVREPORT global is listed
+ S RUNCODE(1)="^%utt1,%utt1,^%utt6,VERBOSE^%utt6,%uttcovr,^%ut,^%ut1,^%utcover"
 "RTN","uttcovr",8,0)
- I '$D(SHOWALL) N SHOWALL S SHOWALL=0
+ M ^TMP("%uttcovr",$J,"RUNCODE")=RUNCODE
 "RTN","uttcovr",9,0)
- ; set global node so %utt4 doesn't run its own analysis
+ ; need this one separate, or it runs into infinite loop
 "RTN","uttcovr",10,0)
- S ^TMP("%uttcovr",$J)=1
+ S RUNCODE("ENTRY^%uttcovr")=""
 "RTN","uttcovr",11,0)
- ; start analysis of %ut - it calls entry below
+ ; Have the analysis EXCLUDE the following routines from coverage - unit test routines
 "RTN","uttcovr",12,0)
- D COV^%ut1("%ut","D TESTCOVR^%ut",-1)
+ S XCLUDE(1)="%utt1,%utt2,%utt3,%utt4,%utt5,%utt6,%uttcovr"
 "RTN","uttcovr",13,0)
- D LIST("%ut") ; output results of analysis
+ M ^TMP("%uttcovr",$J,"XCLUDE")=XCLUDE
 "RTN","uttcovr",14,0)
- ; start analysis of %ut1
+ D COVERAGE^%utcover("%ut*",.RUNCODE,.XCLUDE,3)
 "RTN","uttcovr",15,0)
- D COV^%ut1("%ut1","D TESTCOVR^%ut1",3)
+ Q
 "RTN","uttcovr",16,0)
- D LIST("%ut1")
+ ;
 "RTN","uttcovr",17,0)
- K ^TMP("%uttcovr",$J)
-"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",27,0)
- D ^%utt1 ; verbose
-"RTN","uttcovr",28,0)
- D EN^%ut("%utt1") ; non-verbose
-"RTN","uttcovr",29,0)
+"RTN","uttcovr",18,0)
+ ; The following are now specified in the initial call to COVERAGE^%
+"RTN","uttcovr",19,0)
+ ;D ^%utt1 ; verbose
+"RTN","uttcovr",20,0)
+ ;D EN^%ut("%utt1") ; non-verbose
+"RTN","uttcovr",21,0)
  ; run tests from top of %utt6, runs both command line and gui analyses
-"RTN","uttcovr",30,0)
- D ^%utt6 ; non-verbose
-"RTN","uttcovr",31,0)
- D VERBOSE^%utt6 ; verbose
-"RTN","uttcovr",32,0)
- Q
-"RTN","uttcovr",33,0)
+"RTN","uttcovr",22,0)
+ ;D ^%utt6 ; non-verbose
+"RTN","uttcovr",23,0)
+ ;D VERBOSE^%utt6 ; verbose
+"RTN","uttcovr",24,0)
+ ; run tests from top of routines
+"RTN","uttcovr",25,0)
+ ;D ^%ut
+"RTN","uttcovr",26,0)
+ ;D ^%ut1
+"RTN","uttcovr",27,0)
  ;
+"RTN","uttcovr",28,0)
+ ; these tests run outside of unit tests to handle CHKLEAKS calls not in unit tests
+"RTN","uttcovr",29,0)
+ ; they need data set, so they are called in here
+"RTN","uttcovr",30,0)
+ ; LEAKSOK ;
+"RTN","uttcovr",31,0)
+ N CODE,LOCATN,MYVALS,X
+"RTN","uttcovr",32,0)
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSOK TEST",MYVALS("X")=""
+"RTN","uttcovr",33,0)
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find no leaks
 "RTN","uttcovr",34,0)
-LIST(ROU) ;
+ ; LEAKSBAD ;
 "RTN","uttcovr",35,0)
- ; ZEXCEPT: SHOWALL - NEWed and set in SHOWALL or entering at %uttcovr
+ N CODE,LOCATN,MYVALS,X
 "RTN","uttcovr",36,0)
- N JOB,NAME,BASE,GLOB
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSBAD TEST - X NOT SPECIFIED"
 "RTN","uttcovr",37,0)
- S JOB=$J
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find X since it isn't indicated
 "RTN","uttcovr",38,0)
- W !!!,ROU_" COVERAGE ANALYSIS"
+ ; try to run coverage
 "RTN","uttcovr",39,0)
- F NAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
+ D COV^%ut("%ut1","D EN^%ut(""%utt5"")",3)
 "RTN","uttcovr",40,0)
- . I 'SHOWALL,NAME'="%utCOVREPORT" Q
+ D COV^%ut("%ut1","D EN^%ut(""%utt5"")",-1)
 "RTN","uttcovr",41,0)
- . W !!!,NAME," GLOBAL DATA",!
+ N RUNCODE S RUNCODE(1)="^%utt4,^%ut" ; M RUNCODE=^TMP("%uttcovr",$J,"RUNCODE")
 "RTN","uttcovr",42,0)
- . S BASE="^TMP("""_NAME_""","_JOB,GLOB=BASE_")"
+ N XCLUDE M XCLUDE=^TMP("%uttcovr",$J,"XCLUDE")
 "RTN","uttcovr",43,0)
- . I $D(GLOB)#2 W !,GLOB,"=",$G(@GLOB)
+ D TESTONLY^%utcover(.RUNCODE)
 "RTN","uttcovr",44,0)
- . F  S GLOB=$Q(@GLOB) Q:GLOB'[BASE  I $D(GLOB)#2 W !,GLOB,"=",@GLOB
+ D COVERAGE^%utcover("%ut*",.RUNCODE,.XCLUDE,3)
 "RTN","uttcovr",45,0)
- . Q
+ N GLT S GLT=$NA(^TMP("%uttcovr-text",$J)) K @GLT
 "RTN","uttcovr",46,0)
+ D LIST^%utcover(.XCLUDE,3,GLT) ; get coverage for listing and trimdata in %utcover
+"RTN","uttcovr",47,0)
+ F I=1:1 Q:'$D(@GLT@(I))  W !,@GLT@(I)
+"RTN","uttcovr",48,0)
+ K @GLT
+"RTN","uttcovr",49,0)
  Q
+"RTN","uttcovr",50,0)
+ ;
+"RTN","uttcovr",51,0)
+RTNANAL ; @TEST - routine analysis
+"RTN","uttcovr",52,0)
+ N ROUS,GLB
+"RTN","uttcovr",53,0)
+ S ROUS("%utt4")=""
+"RTN","uttcovr",54,0)
+ S GLB=$NA(^TMP("%uttcovr-rtnanal",$J)) K @GLB
+"RTN","uttcovr",55,0)
+ D RTNANAL^%ut1(.ROUS,GLB)
+"RTN","uttcovr",56,0)
+ D CHKTF^%ut($D(@GLB@("%utt4","MAIN"))>1,"Not enough 'MAIN' nodes found")
+"RTN","uttcovr",57,0)
+ D CHKTF^%ut($G(@GLB@("%utt4","MAIN",2))["+$SY=47","Check for GT.M not found in expected line")
+"RTN","uttcovr",58,0)
+ D CHKTF^%ut($G(@GLB@("%utt4","MAIN",12))=" QUIT","Final QUIT not on expected line")
+"RTN","uttcovr",59,0)
+ K @GLB
+"RTN","uttcovr",60,0)
+ Q
+"RTN","uttcovr",61,0)
+ ;
+"RTN","uttcovr",62,0)
+COVRPTGL ; @TEST - coverage report returning global
+"RTN","uttcovr",63,0)
+ N GL1,GL2,GL3,GL4
+"RTN","uttcovr",64,0)
+ S GL1=$NA(^TMP("%utCOVCOHORTSAVx",$J)) K @GL1
+"RTN","uttcovr",65,0)
+ S GL2=$NA(^TMP("%utCOVCOHORTx",$J)) K @GL2
+"RTN","uttcovr",66,0)
+ S GL3=$NA(^TMP("%utCOVRESULTx",$J)) K @GL3
+"RTN","uttcovr",67,0)
+ S GL4=$NA(^TMP("%utCOVREPORTx",$J)) K @GL4
+"RTN","uttcovr",68,0)
+ D SETGLOBS(GL1,GL2)
+"RTN","uttcovr",69,0)
+ D COVRPTGL^%ut1(GL1,GL2,GL3,GL4)
+"RTN","uttcovr",70,0)
+ D CHKEQ^%ut($G(@GL4@("%ut1","ACTLINES")),"0/9","Wrong number of lines covered f>>or ACTLINES")
+"RTN","uttcovr",71,0)
+ D CHKEQ^%ut($G(@GL4@("%ut1","ACTLINES",9))," QUIT CNT","Wrong result for last l>>ine not covered for ACTLINES")
+"RTN","uttcovr",72,0)
+ D CHKEQ^%ut($G(@GL4@("%ut1","CHEKTEST")),"8/10","Wrong number of lines covered >>for CHEKTEST")
+"RTN","uttcovr",73,0)
+ D CHKEQ^%ut($G(@GL4@("%ut1","CHEKTEST",39))," . Q","Wrong result for last line >>not covered for CHEKTEST")
+"RTN","uttcovr",74,0)
+ K @GL1,@GL2,@GL3,@GL4
+"RTN","uttcovr",75,0)
+ Q
+"RTN","uttcovr",76,0)
+ ;
+"RTN","uttcovr",77,0)
+COVRPTLS ; @TEST - coverage report returning text in global
+"RTN","uttcovr",78,0)
+ N GL1,GL2,GL3,GL4,VRBOSITY
+"RTN","uttcovr",79,0)
+ S GL1=$NA(^TMP("%utCOVCOHORTSAVx",$J)) K @GL1
+"RTN","uttcovr",80,0)
+ S GL2=$NA(^TMP("%utCOVCOHORTx",$J)) K @GL2
+"RTN","uttcovr",81,0)
+ S GL3=$NA(^TMP("%utCOVRESULTx",$J)) K @GL3
+"RTN","uttcovr",82,0)
+ S GL4=$NA(^TMP("%utCOVREPORTx",$J)) K @GL4
+"RTN","uttcovr",83,0)
+ D SETGLOBS(GL1,GL2)
+"RTN","uttcovr",84,0)
+ S VRBOSITY=1
+"RTN","uttcovr",85,0)
+ D COVRPTLS^%ut1(GL1,GL2,GL3,VRBOSITY,GL4)
+"RTN","uttcovr",86,0)
+ D CHKEQ^%ut("COVERAGE PERCENTAGE: 42.11",$G(@GL4@(5)),"Verbosity 1 - not expected percentage value")
+"RTN","uttcovr",87,0)
+ D CHKEQ^%ut("42.11",$G(@GL4@(9)),"Verbosity 1 - not expected value for line 9")
+"RTN","uttcovr",88,0)
+ D CHKTF^%ut('$D(@GL4@(10)),"Verbosity 1 - unexpected data in 10th line")
+"RTN","uttcovr",89,0)
+ K @GL4
+"RTN","uttcovr",90,0)
+ ;
+"RTN","uttcovr",91,0)
+ S VRBOSITY=2
+"RTN","uttcovr",92,0)
+ D COVRPTLS^%ut1(GL1,GL2,GL3,VRBOSITY,GL4)
+"RTN","uttcovr",93,0)
+ D CHKEQ^%ut("    ACTLINES        0.00",$G(@GL4@(10)),"Verbosity 2 - not expected value for 10th line")
+"RTN","uttcovr",94,0)
+ D CHKEQ^%ut("    CHEKTEST        80.00",$G(@GL4@(11)),"Verbosity 2 - not expected value for 11th line")
+"RTN","uttcovr",95,0)
+ D CHKTF^%ut('$D(@GL4@(12)),"Verbosity 2 - unexpected data for 12th line")
+"RTN","uttcovr",96,0)
+ K @GL4
+"RTN","uttcovr",97,0)
+ ;
+"RTN","uttcovr",98,0)
+ S VRBOSITY=3
+"RTN","uttcovr",99,0)
+ D COVRPTLS^%ut1(GL1,GL2,GL3,VRBOSITY,GL4)
+"RTN","uttcovr",100,0)
+ D CHKEQ^%ut("    ACTLINES        0.00",$G(@GL4@(10)),"Verbosity 3 - unexpected value for line 10")
+"RTN","uttcovr",101,0)
+ D CHKEQ^%ut("ACTLINES+9:  QUIT CNT",$G(@GL4@(19)),"Verbosity 3 - unexpected value for line 19")
+"RTN","uttcovr",102,0)
+ D CHKEQ^%ut("    CHEKTEST        80.00",$G(@GL4@(20)),"Verbosity 3 - unexpected value for line 20")
+"RTN","uttcovr",103,0)
+ D CHKEQ^%ut("CHEKTEST+39:  . Q",$G(@GL4@(22)),"Verbosity 3 - unexpected value for line 22")
+"RTN","uttcovr",104,0)
+ D CHKTF^%ut('$D(@GL4@(23)),"Verbosity 3 - unexpected line 23")
+"RTN","uttcovr",105,0)
+ ;
+"RTN","uttcovr",106,0)
+ K @GL1,@GL2,@GL3,@GL4
+"RTN","uttcovr",107,0)
+ Q
+"RTN","uttcovr",108,0)
+ ;
+"RTN","uttcovr",109,0)
+TRIMDATA ; @TEST - TRIMDATA in %utcover
+"RTN","uttcovr",110,0)
+ N GL1,XCLUD
+"RTN","uttcovr",111,0)
+ S GL1=$NA(^TMP("%uttcovr-trimdata",$J)) K @GL1
+"RTN","uttcovr",112,0)
+ S @GL1@("GOOD",1)="1"
+"RTN","uttcovr",113,0)
+ S @GL1@("BAD",1)="1"
+"RTN","uttcovr",114,0)
+ S XCLUD("BAD")=""
+"RTN","uttcovr",115,0)
+ D TRIMDATA^%utcover(.XCLUD,GL1)
+"RTN","uttcovr",116,0)
+ D CHKTF^%ut($D(@GL1@("GOOD")),"GOOD ENTRY WAS REMOVED")
+"RTN","uttcovr",117,0)
+ D CHKTF^%ut('$D(@GL1@("BAD")),"ENTRY WAS NOT TRIMMED")
+"RTN","uttcovr",118,0)
+ K @GL1,XCLUD
+"RTN","uttcovr",119,0)
+ Q
+"RTN","uttcovr",120,0)
+ ;
+"RTN","uttcovr",121,0)
+LIST ; @TEST - LIST in %utcover
+"RTN","uttcovr",122,0)
+ N GL1,GLT S GL1=$NA(^TMP("%uttcovr-list",$J)),GLT=$NA(^TMP("%uttcovr-text",$J))
+"RTN","uttcovr",123,0)
+ S @GL1@("%ut1")="89/160"
+"RTN","uttcovr",124,0)
+ S @GL1@("%ut1","%ut1")="2/2"
+"RTN","uttcovr",125,0)
+ S @GL1@("%ut1","ACTLINES")="0/9"
+"RTN","uttcovr",126,0)
+ S @GL1@("%ut1","ACTLINES",0)="ACTLINES(GL) ; [Private] $$ ; Count active lines"
+"RTN","uttcovr",127,0)
+ S @GL1@("%ut1","ACTLINES",2)=" N CNT S CNT=0"
+"RTN","uttcovr",128,0)
+ S @GL1@("%ut1","ACTLINES",3)=" N REF S REF=GL"
+"RTN","uttcovr",129,0)
+ S @GL1@("%ut1","ACTLINES",4)=" N GLQL S GLQL=$QL(GL)"
+"RTN","uttcovr",130,0)
+ S @GL1@("%ut1","ACTLINES",5)=" F  S REF=$Q(@REF) Q:REF=""""  Q:(GL'=$NA(@REF,GLQL))  D"
+"RTN","uttcovr",131,0)
+ S @GL1@("%ut1","ACTLINES",6)=" . N REFQL S REFQL=$QL(REF)"
+"RTN","uttcovr",132,0)
+ S @GL1@("%ut1","ACTLINES",7)=" . N LASTSUB S LASTSUB=$QS(REF,REFQL)"
+"RTN","uttcovr",133,0)
+ S @GL1@("%ut1","ACTLINES",8)=" . I LASTSUB?1.N S CNT=CNT+1"
+"RTN","uttcovr",134,0)
+ S @GL1@("%ut1","ACTLINES",9)=" QUIT CNT"
+"RTN","uttcovr",135,0)
+ S @GL1@("%ut1","CHECKTAG")="11/11"
+"RTN","uttcovr",136,0)
+ S @GL1@("%ut1","CHEKTEST")="10/10"
+"RTN","uttcovr",137,0)
+ N XCLUD S XCLUD("%utt1")=""
+"RTN","uttcovr",138,0)
+ D LIST^%utcover(.XCLUD,1,GLT,GL1)
+"RTN","uttcovr",139,0)
+ D CHKEQ^%ut("Routine %ut1   89 out of 160 lines covered  (55%)",$G(@GLT@(3)),"Verbosity 1 - Unexpected text for line 3")
+"RTN","uttcovr",140,0)
+ D CHKEQ^%ut("Overall Analysis 89 out of 160 lines covered (55% coverage)",$G(@GLT@(6)),"Verbosity 1 - unexpected text for line 6")
+"RTN","uttcovr",141,0)
+ D CHKTF^%ut('$D(@GLT@(7)),"Verbosity 1 - Unexpected line 7 present")
+"RTN","uttcovr",142,0)
+ K @GLT
+"RTN","uttcovr",143,0)
+ ;
+"RTN","uttcovr",144,0)
+ D LIST^%utcover(.XCLUD,2,GLT,GL1)
+"RTN","uttcovr",145,0)
+ D CHKEQ^%ut("  - Summary",$G(@GLT@(4)),"Verbosity 2 - unexpected text at line 4")
+"RTN","uttcovr",146,0)
+ D CHKEQ^%ut(" Tag ACTLINES^%ut1   0 out of 9 lines covered",$G(@GLT@(6)),"Verbosity 2 - unexpected text at line 6")
+"RTN","uttcovr",147,0)
+ D CHKEQ^%ut(" Tag CHEKTEST^%ut1   10 out of 10 lines covered",$G(@GLT@(8)),"Verbosity 2 - unexpected text at line 8")
+"RTN","uttcovr",148,0)
+ D CHKTF^%ut($D(@GLT@(14)),"Verbosity 2 - expected line at line 14")
+"RTN","uttcovr",149,0)
+ D CHKTF^%ut('$D(@GLT@(15)),"Verbosity 2 - unexpected line at line 15")
+"RTN","uttcovr",150,0)
+ K @GLT
+"RTN","uttcovr",151,0)
+ ;
+"RTN","uttcovr",152,0)
+ D LIST^%utcover(.XCLUD,3,GLT,GL1)
+"RTN","uttcovr",153,0)
+ D CHKEQ^%ut(" Tag %ut1^%ut1   2 out of 2 lines covered",$G(@GLT@(5)),"Verbosity 3 - Incorrect text at line 5")
+"RTN","uttcovr",154,0)
+ D CHKEQ^%ut("   ACTLINES+9   QUIT CNT",$G(@GLT@(15)),"Verbosity 3 - incorrect line 15")
+"RTN","uttcovr",155,0)
+ D CHKTF^%ut($D(@GLT@(23)),"Verbosity 3 - expected data in line 23")
+"RTN","uttcovr",156,0)
+ D CHKTF^%ut('$D(@GLT@(24)),"Verbosity 3 - did not expect a line 24")
+"RTN","uttcovr",157,0)
+ ;
+"RTN","uttcovr",158,0)
+ K @GL1,@GLT
+"RTN","uttcovr",159,0)
+ Q
+"RTN","uttcovr",160,0)
+ ;
+"RTN","uttcovr",161,0)
+SETGLOBS(GL1,GL2) ; 
+"RTN","uttcovr",162,0)
+ S @GL1@("%ut1","ACTLINES")="ACTLINES"
+"RTN","uttcovr",163,0)
+ S @GL1@("%ut1","ACTLINES",0)="ACTLINES(GL) ; [Private] $$ ; Count active lines"
+"RTN","uttcovr",164,0)
+ S @GL1@("%ut1","ACTLINES",2)=" N CNT S CNT=0"
+"RTN","uttcovr",165,0)
+ S @GL1@("%ut1","ACTLINES",3)=" N REF S REF=GL"
+"RTN","uttcovr",166,0)
+ S @GL1@("%ut1","ACTLINES",4)=" N GLQL S GLQL=$QL(GL)"
+"RTN","uttcovr",167,0)
+ S @GL1@("%ut1","ACTLINES",5)=" F  S REF=$Q(@REF) Q:REF=""""  Q:(GL'=$NA(@REF,GLQL))  D"
+"RTN","uttcovr",168,0)
+ S @GL1@("%ut1","ACTLINES",6)=" . N REFQL S REFQL=$QL(REF)"
+"RTN","uttcovr",169,0)
+ S @GL1@("%ut1","ACTLINES",7)=" . N LASTSUB S LASTSUB=$QS(REF,REFQL)"
+"RTN","uttcovr",170,0)
+ S @GL1@("%ut1","ACTLINES",8)=" . I LASTSUB?1.N S CNT=CNT+1"
+"RTN","uttcovr",171,0)
+ S @GL1@("%ut1","ACTLINES",9)=" QUIT CNT"
+"RTN","uttcovr",172,0)
+ S @GL1@("%ut1","CHEKTEST")="CHEKTEST"
+"RTN","uttcovr",173,0)
+ S @GL1@("%ut1","CHEKTEST",0)="CHEKTEST(%utROU,%ut,%utUETRY) ; Collect Test list."
+"RTN","uttcovr",174,0)
+ S @GL1@("%ut1","CHEKTEST",13)=" N I,LIST"
+"RTN","uttcovr",175,0)
+ S @GL1@("%ut1","CHEKTEST",14)=" S I=$L($T(@(U_%utROU))) I I<0 Q ""-1^Invalid Routine Name"""
+"RTN","uttcovr",176,0)
+ S @GL1@("%ut1","CHEKTEST",31)=" D NEWSTYLE(.LIST,%utROU)"
+"RTN","uttcovr",177,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",178,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",179,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",180,0)
+ S @GL1@("%ut1","CHEKTEST",39)=" . Q"
+"RTN","uttcovr",181,0)
+ S @GL1@("%ut1","CHEKTEST",41)=" QUIT"
+"RTN","uttcovr",182,0)
+ S @GL1@("%ut1","CHEKTEST",9)=" S %ut(""ENTN"")=0 ; Number of test, sub to %utUETRY."
+"RTN","uttcovr",183,0)
+ S @GL2@("%ut1","ACTLINES")="ACTLINES"
+"RTN","uttcovr",184,0)
+ S @GL2@("%ut1","ACTLINES",0)="ACTLINES(GL) ; [Private] $$ ; Count active lines"
+"RTN","uttcovr",185,0)
+ S @GL2@("%ut1","ACTLINES",2)=" N CNT S CNT=0"
+"RTN","uttcovr",186,0)
+ S @GL2@("%ut1","ACTLINES",3)=" N REF S REF=GL"
+"RTN","uttcovr",187,0)
+ S @GL2@("%ut1","ACTLINES",4)=" N GLQL S GLQL=$QL(GL)"
+"RTN","uttcovr",188,0)
+ S @GL2@("%ut1","ACTLINES",5)=" F  S REF=$Q(@REF) Q:REF=""""  Q:(GL'=$NA(@REF,GLQL))  D"
+"RTN","uttcovr",189,0)
+ S @GL2@("%ut1","ACTLINES",6)=" . N REFQL S REFQL=$QL(REF)"
+"RTN","uttcovr",190,0)
+ S @GL2@("%ut1","ACTLINES",7)=" . N LASTSUB S LASTSUB=$QS(REF,REFQL)"
+"RTN","uttcovr",191,0)
+ S @GL2@("%ut1","ACTLINES",8)=" . I LASTSUB?1.N S CNT=CNT+1"
+"RTN","uttcovr",192,0)
+ S @GL2@("%ut1","ACTLINES",9)=" QUIT CNT"
+"RTN","uttcovr",193,0)
+ S @GL2@("%ut1","CHEKTEST")="CHEKTEST"
+"RTN","uttcovr",194,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",195,0)
+ S @GL2@("%ut1","CHEKTEST",39)=" . Q"
+"RTN","uttcovr",196,0)
+ Q
+"RTN","uttcovr",197,0)
+ ;
 "SEC","^DIC",17.9001,17.9001,0,"AUDIT")
 @
 "SEC","^DIC",17.9001,17.9001,0,"DD")
@@ -3296,6 +4106,7 @@ FIELD^^2^3
 "^DD",17.9001,17.9001,0,"DT")
 3140812
 "^DD",17.9001,17.9001,0,"IX","B",17.9001,.01)
+
 "^DD",17.9001,17.9001,0,"NM","MUNIT TEST GROUP")
  
 "^DD",17.9001,17.9001,0,"VRPK")
@@ -3339,6 +4150,7 @@ TEST ROUTINE SUB-FIELD^^.01^1
 "^DD",17.9001,17.90011,0,"DT")
 3140731
 "^DD",17.9001,17.90011,0,"IX","B",17.90011,.01)
+
 "^DD",17.9001,17.90011,0,"NM","TEST ROUTINE")
  
 "^DD",17.9001,17.90011,0,"UP")
@@ -3362,6 +4174,7 @@ DESCRIPTION FOR GROUP SUB-FIELD^^.01^1
 "^DD",17.9001,17.90012,0,"DT")
 3140812
 "^DD",17.9001,17.90012,0,"NM","DESCRIPTION FOR GROUP")
+
 "^DD",17.9001,17.90012,0,"UP")
 17.9001
 "^DD",17.9001,17.90012,.01,0)
@@ -3391,4 +4204,5 @@ M-UNIT TEST GROUP^17.9001
 "^DIC",17.9001,17.9001,0,"GL")
 ^%ut(17.9001,
 "^DIC",17.9001,"B","M-UNIT TEST GROUP",17.9001)
-$END KID MASH*0.1*0
+
+$END KID MASH*0.2*0
diff --git a/Routines/%ut.m b/Routines/%ut.m
index e659cfe..e12747e 100644
--- a/Routines/%ut.m
+++ b/Routines/%ut.m
@@ -1,485 +1,487 @@
-%ut	;VEN-SMH/JLI - PRIMARY PROGRAM FOR M-UNIT TESTING ;08/24/14  21:45
-	;;0.1;MASH UTILITIES;
-	;
-	; This routine and its companion, %ut1, provide the basic functionality for
-	; running unit tests on parts of M programs either at the command line level
-	; or via the M-Unit GUI application for windows operating systems.
-	;
-	; Original by Dr. Joel Ivey
-	; Contributions by Dr. Sam Habiel
-	;
-	; 100622 JLI - corrected typo in comments where %utINPT was listed as %utINP
-	; 100622 JLI - removed a comment which indicated data could potentially be returned from the called routine
-	;              in the %utINPT array.
-	; 100622 JLI - added code to handle STARTUP and SHUTDOWN from GUI app
-	; 110719 JLI - modified separators in GUI handling from ^ to ~~^~~
-	;              in the variable XTGUISEP if using a newer version of the
-	;              GUI app (otherwise, it is simply set to ^) since results
-	;              with a series of ^ embedded disturbed the output reported
-	; 130726 SMH - Fixed SETUP and TEARDOWN so that they run before/after each
-	;              test rather than once. General refactoring.
-	; 130726 SMH - SETUT initialized IO in case it's not there to $P. Inits vars
-	;              using DT^DICRW.
-	; 131217 SMH - Change call in SETUP to S U="^" instead of DT^DICRW
-	; 131218 SMH - Any checks to $ZE will also check $ZS for GT.M.
-	; 131218 SMH - Remove calls to %ZISUTL to manage devices to prevent dependence on VISTA.
-	;              Use %utNIT("DEV","OLD") for old devices
-	; 140109 SMH - Add parameter %utBREAK - Break upon error
-	; 1402   SMH - Break will cause the break to happen even on failed tests.
-	; 140401 SMH - Added Succeed entry point for take it into your hands tester.
-	; 140401 SMH - Reformatted the output of M-Unit so that the test's name
-	;              will print BEFORE the execution of the test. This has been
-	;              really confusing for beginning users of M-Unit, so this was
-	;              necessary.
-	; 140401 SMH - OK message gets printed at the end of --- as [OK].
-	; 140401 SMH - FAIL message now prints. Previously, OK failed to be printed.
-	;              Unfortunately, that's rather passive aggressive. Now it
-	;              explicitly says that a test failed.
-	; 140503 SMH - Fixed IO issues all over the routine. Much simpler now.
-	; 140731 JLI - Combined routine changes between JLI and SMH
-	;              Moved routines from %utNIT and %utNIT1 to %ut and %ut1
-	;              Updated unit test routines (%utt1 to %utt6)
-	;              Created M-UNIT TEST GROUP file at 17.9001 based on the 17.9001 file
-	Q
-	;
-EN(%utRNAM,%utVERB,%utBREAK)	; .SR Entry point with primary test routine name, optional 1 for verbose output
-	N %utLIST,%utROU,%ut
-	I '+$G(%utVERB) S %utVERB=0
-	S %utLIST=1,%utROU(%utLIST)=%utRNAM
-	D SETUT
-	D EN1(.%utROU,%utLIST)
-	Q
-	;
-SETUT	;
-	; VEN/SMH 26JUL2013
-	I '($D(IO)#2) S IO=$P
-	S U="^"
-	; VEN/SMH 26JUL2013 END
-	;
-	; ZEXCEPT: %ut  -- NEWED ON ENTRY
-	S %ut("IO")=IO
-	S %ut=1 ; set to identify unit test being run check with $$ISUTEST^%ut()
-	;
-	; ZEXCEPT: %utBREAK
-	I $G(%utBREAK) S %ut("BREAK")=1
-	Q
-	;
-EN1(%utROU,%utLIST)	;
-	; VEN/SMH 26JUL2013 - This block is refactored to fix problems with
-	; SETUP and TEARDOWN not happening at the right time
-	N %utERRL,%utK,%utI,%utJ,%utSTRT
-	; ZEXCEPT: %utVERB   -- ARGUMENT TO EN
-	; ZEXCEPT: %utGUI      -- CONDITIONALLY DEFINED BY GUINEXT
-	; ZEXCEPT: %ut  -- NEWED IN EN
-	;
-	; Structure map for %ut
-	; -- CURR = Counter for routine number. Used as sub in %utROU
-	; -- ECNT = Entry point count in loop (cf. NERT); VEN/SMH - Needed?
-	; -- FAIL = Number of failures
-	; -- CHK  = Number of checks ran (TF/EQ/FAIL)
-	; -- NENT = Number of entry points ran
-	; -- ERRN = Number of errors
-	S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
-	;
-	; -- GET LIST OF ROUTINES --
-	; first get any tree of routines from this one
-	D GETTREE^%ut1(.%utROU,.%utLIST)
-	;
-	; -- STARTUP --
-	; 070224 - following code added to allow one overall STARTUP code JLI
-	F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D  I $G(%utSTRT)'="" D @%utSTRT Q
-	. I $T(@("STARTUP^"_%utROU(%ut("CURR"))))'="" S %utSTRT="STARTUP^"_%utROU(%ut("CURR"))
-	. Q
-	; 070224 - end of addition JLI
-	;
-	;
-	; Now process each routine that has been referenced
-	S %ut("CURR")=0
-	F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D
-	. N %utETRY ; Test list to run
-	. ;
-	. ; Collect Test list.
-	. D CHEKTEST^%ut1(%utROU(%ut("CURR")),.%ut,.%utETRY)
-	. ;
-	. ; if a SETUP entry point exists, save it off in %ut
-	. N %utSETUP S %utSETUP="SETUP^"_%utROU(%ut("CURR"))
-	. S %ut("LINE")=$T(@%utSETUP) I %ut("LINE")'="" S %ut("SETUP")=%utSETUP
-	. K %utSETUP ; we're done!
-	. ;
-	. ; if a TEARDOWN entry point exists, ditto
-	. N %utTEARDOWN S %utTEARDOWN="TEARDOWN^"_%utROU(%ut("CURR"))
-	. S %ut("LINE")=$T(@%utTEARDOWN) I %ut("LINE")'="" S %ut("TEARDOWN")=%utTEARDOWN
-	. K %utTEARDOWN ; done here.
-	. ;
-	. ; VEN/SMH 26JUL2013 - this block changed to correct running of setup and teardown
-	. ; run each of the specified entry points
-	. ;
-	. ; == THIS FOR/DO BLOCK IS THE CENTRAL TEST RUNNER ==
-	. S %utI=0
-	. F  S %utI=$O(%utETRY(%utI)) Q:%utI'>0  S %ut("ENUM")=%ut("ERRN")+%ut("FAIL") D
-	. . N $ETRAP S $ETRAP="D ERROR^%ut"
-	. . ;
-	. . ; Run Set-up Code (only if present)
-	. . S %ut("ENT")=$G(%ut("SETUP")) ; Current entry
-	. . S %ut("NAME")="Set-up Code"
-	. . D:%ut("ENT")]"" @%ut("ENT")
-	. . ;
-	. . ; Run actual test
-	. . S %ut("ECNT")=%ut("ECNT")+1
-	. . S %ut("NAME")=%utETRY(%utI,"NAME")
-	. . S %ut("ENT")=%utETRY(%utI)_"^"_%utROU(%ut("CURR"))
-	. . I %utVERB,'$D(%utGUI) D VERBOSE1(.%utETRY,%utI) ; Say what we executed.
-	. . D @%ut("ENT")
-	. . ;
-	. . ; Run Teardown Code (only if present)
-	. . S %ut("ENT")=$G(%ut("TEARDOWN"))
-	. . S %ut("NAME")="Teardown Code"
-	. . D:%ut("ENT")]"" @%ut("ENT")
-	. . ;
-	. . ; ENUM = Number of errors + failures
-	. . ; Only print out the success message [OK] If our error number remains
-	. . ; the same as when we started the loop.
-	. . I %utVERB,'$D(%utGUI) D
-	. . . I %ut("ENUM")=(%ut("ERRN")+%ut("FAIL")) D VERBOSE(.%utETRY,%utI,1) I 1
-	. . . E  D VERBOSE(.%utETRY,%utI,0)
-	. ;
-	. ;
-	. ; keep a %utCNT of number of entry points executed across all routines
-	. S %ut("NENT")=%ut("NENT")+%ut("ENTN")
-	. Q
-	;
-	; -- SHUTDOWN --
-	; 070224 - following code added to allow one overall SHUTDOWN code JLI
-	N XTFINISH
-	S %ut("CURR")=0
-	F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D  I $G(XTFINISH)'="" D @XTFINISH Q
-	. I $T(@("SHUTDOWN^"_%utROU(%ut("CURR"))))'="" S XTFINISH="SHUTDOWN^"_%utROU(%ut("CURR"))
-	. Q
-	; 070224 - End of addition JLI
-	; and output the results
-	D SETIO
-	W !!,"Ran ",%utLIST," Routine",$S(%utLIST>1:"s",1:""),", ",%ut("NENT")," Entry Tag",$S(%ut("NENT")>1:"s",1:"")
-	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:""),"."
-	D RESETIO
-	Q
-	; -- end EN1
-VERBOSE(%utETRY,%utI,SUCCESS)	; Say whether we succeeded or failed.
-	; ZEXCEPT: %ut - NEWED IN EN
-	D SETIO
-	N I F I=$X+3:1:73 W "-"
-	W ?73
-	I $G(SUCCESS) W "[OK]"
-	E  W "[FAIL]"
-	D RESETIO
-	Q
-	;
-VERBOSE1(%utETRY,%utI)	; Print out the entry point info
-	; ZEXCEPT: %ut - NEWED IN EN
-	D SETIO
-	W !,%utETRY(%utI) I $G(%utETRY(%utI,"NAME"))'="" W " - ",%utETRY(%utI,"NAME")
-	D RESETIO
-	Q
-CHKTF(XTSTVAL,XTERMSG)	; Entry point for checking True or False values
-	; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
-	; ZEXCEPT: %ut - NEWED IN EN
-	; ZEXCEPT: XTGUISEP - newed in GUINEXT
-	I '$D(XTSTVAL) D NVLDARG Q
-	I $G(XTERMSG)="" S XTERMSG="no failure message provided"
-	S %ut("CHK")=$G(%ut("CHK"))+1
-	I '$D(%utGUI) D
-	. D SETIO
-	. I 'XTSTVAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " D
-	. . W XTERMSG,! S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
-	. . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-	. . Q
-	. I XTSTVAL W "."
-	. D RESETIO
-	. Q
-	I $D(%utGUI),'XTSTVAL S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG
-	Q
-	;
-CHKEQ(XTEXPECT,XTACTUAL,XTERMSG)	; Entry point for checking values to see if they are EQUAL
-	N FAILMSG
-	; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
-	; ZEXCEPT: %ut  -- NEWED IN EN
-	; ZEXCEPT: XTGUISEP - newed in GUINEXT
-	I '$D(XTEXPECT)!'$D(XTACTUAL) D NVLDARG Q  ; JLI 140824 changed from AND to OR, since both necessary, but only one might be entered
-	S XTACTUAL=$G(XTACTUAL),XTEXPECT=$G(XTEXPECT)
-	I $G(XTERMSG)="" S XTERMSG="no failure message provided"
-	S %ut("CHK")=%ut("CHK")+1
-	I XTEXPECT'=XTACTUAL S FAILMSG="<"_XTEXPECT_"> vs <"_XTACTUAL_"> - "
-	I '$D(%utGUI) D
-	. D SETIO
-	. I XTEXPECT'=XTACTUAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W FAILMSG,XTERMSG,! D
-	. . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
-	    . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-	. . Q
-	. E  W "."
-	. D RESETIO
-	. Q
-	I $D(%utGUI),XTEXPECT'=XTACTUAL S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_FAILMSG_XTERMSG
-	Q
-	;
-FAIL(XTERMSG)	; Entry point for generating a failure message
-	; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
-	; ZEXCEPT: %ut  -- NEWED ON ENTRY
-	; ZEXCEPT: XTGUISEP - newed in GUINEXT
-	I $G(XTERMSG)="" S XTERMSG="no failure message provided"
-	S %ut("CHK")=%ut("CHK")+1
-	I '$D(%utGUI) D
-	. D SETIO
-	. W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
-	. . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
-	. . I $D(%ut("BREAK")) BREAK  ; Break upon failure
-	. . Q
-	. D RESETIO
-	. Q
-	I $D(%utGUI) S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG
-	Q
-SUCCEED	; Entry point for forcing a success (Thx David Whitten)
-	; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
-	; ZEXCEPT: %ut - NEWED IN EN
-	; Switch IO and write out the dot for activity
-	I '$D(%utGUI) D
-	. D SETIO
-	. W "."
-	. D RESETIO
-	;
-	; Increment test counter
-	S %ut("CHK")=%ut("CHK")+1
-	QUIT
-	;
-CHKLEAKS(%utCODE,%utLOC,%utINPT)	; functionality to check for variable leaks on executing a section of code
-	; %utCODE - A string that specifies the code that is to be XECUTED and checked for leaks.
-	;            this should be a complete piece of code (e.g., "S X=$$NOW^XLFDT()" or "D EN^%ut(""ROUNAME"")")
-	; %utLOC  - A string that is used to indicate the code tested for variable leaks
-	; %utINPT - An optional variable which may be passed by reference.  This may
-	;           be used to pass any variable values, etc. into the code to be
-	;           XECUTED.  In this case, set the subscript to the variable name and the
-	;           value of the subscripted variable to the desired value of the subscript.
-	;              e.g., (using NAME as my current namespace)
-	;                   S CODE="S %utINPT=$$ENTRY^ROUTINE(ZZVALUE1,ZZVALUE2)"
-	;                   S NAMELOC="ENTRY^ROUTINE leak test"   (or simply "ENTRY^ROUTINE")
-	;                   S NAMEINPT("ZZVALUE1")=ZZVALUE1
-	;                   S NAMEINPT("ZZVALUE2")=ZZVALUE2
-	;                   D CHKLEAKS^%ut(CODE,NAMELOC,.NAMEINPT)
-	;
-	;           If part of a unit test, any leaked variables in ENTRY^ROUTINE which result
-	;           from running the code with the variables indicated will be shown as FAILUREs.
-	;
-	;           If called outside of a unit test, any leaked variables will be printed to the
-	;           current device.
-	;
-	N (%utCODE,%utLOC,%utINPT,DUZ,IO,U,%utERRL,%ut,%utGUI,%utI,%utJ,%utK,%utLIST,%utROU,%utSTRT)
-	; ZEXCEPT: %ut - part of exclusive NEW TESTS FOR EXISTENCE ONLY
-	; ZEXCEPT: %utVAR - handled by exclusive NEW
-	;
-	; ACTIVATE ANY VARIABLES PASSED AS SUBSCRIPTS TO %utINPT TO THEIR VALUES
-	S %utVAR=" " F  S %utVAR=$O(%utINPT(%utVAR)) Q:%utVAR=""  S (@%utVAR)=%utINPT(%utVAR)
-	X %utCODE
-	N ZZUTVAR S ZZUTVAR="%"
-	I $G(%ut)=1 D
-	. I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) D FAIL^%ut(%utLOC_" VARIABLE LEAK: "_ZZUTVAR)
-	. F  S ZZUTVAR=$O(@ZZUTVAR) Q:ZZUTVAR=""  I $E(ZZUTVAR,1,3)'="%ut",'$D(%utINPT(ZZUTVAR)),",DUZ,IO,U,DTIME,ZZUTVAR,DT,%ut,"'[(","_ZZUTVAR_",") D FAIL^%ut(%utLOC_" VARIABLE LEAK: "_ZZUTVAR)
-	. Q
-	I '($G(%ut)=1) D
-	. I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) W !,%utLOC_" VARIABLE LEAK: "_ZZUTVAR
-	. F  S ZZUTVAR=$O(@ZZUTVAR) Q:ZZUTVAR=""  I $E(ZZUTVAR,1,3)'="%ut",'$D(%utINPT(ZZUTVAR)),",DUZ,IO,U,DTIME,ZZUTVAR,DT,%ut,"'[(","_ZZUTVAR_",") W !,%utLOC_" VARIABLE LEAK: "_ZZUTVAR
-	. Q
-	Q
-	;
-NVLDARG	; generate message for invalid arguments to test
-	N XTERMSG
-	; ZEXCEPT: %ut  -- NEWED ON ENTRY
-	; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
-	; ZEXCEPT: XTGUISEP - newed in GUINEXT
-	S XTERMSG="NO VALUES INPUT TO CHKEQ^%ut - no evaluation possible"
-	I '$D(%utGUI) D
-	. D SETIO
-	. W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
-	. . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
-	. . Q
-	. D RESETIO
-	. Q
-	I $D(%utGUI) S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG
-	Q
-	;
-ERROR	; record errors
-	; ZEXCEPT: %utERRL,%utGUI,%utERR -CREATED IN SETUP, KILLED IN END
-	; ZEXCEPT: %ut  -- NEWED ON ENTRY
-	; ZEXCEPT: XTGUISEP - newed in GUINEXT
-	S %ut("CHK")=%ut("CHK")+1
-	I '$D(%utGUI) D ERROR1
-	I $D(%utGUI) D
-	. S %ut("CNT")=%ut("CNT")+1
-	. S %utERR=%utERR+1
-	. S @%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"ERROR"_XTGUISEP_$S(+$SY=47:$ZS,1:$ZE)
-	. Q
-	S @($S(+$SY=47:"$ZS",1:"$ZE")_"="_""""""),$EC=""
-	Q
-	;
-ERROR1	;
-	I $G(%ut("BREAK")) BREAK  ; if we are asked to break upon error, please do so!
-	; ZEXCEPT: %utERRL -CREATED IN SETUP, KILLED IN END
-	; ZEXCEPT: %ut  -- NEWED ON ENTRY
-	D SETIO
-	W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - Error: " W $S(+$SY=47:$ZS,1:$ZE),! D
-	. 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
-	D RESETIO
-	Q
-SETIO	; Set M-Unit Device to write the results to...
-	; ZEXCEPT: %ut  -- NEWED ON ENTRY
-	I $IO'=%ut("IO") S (IO(0),%ut("DEV","OLD"))=$IO USE %ut("IO") SET IO=$IO
-	QUIT
-	;
-RESETIO	; Reset $IO back to the original device if we changed it.
-	; ZEXCEPT: %ut  -- NEWED ON ENTRY
-	I $D(%ut("DEV","OLD")) S IO(0)=%ut("IO") U %ut("DEV","OLD") S IO=$IO K %ut("DEV","OLD")
-	QUIT
-	;
-ISUTEST()	; .SUPPORTED API TO DETERMINE IF CURRENTLY IN UNIT TEST
-	; ZEXCEPT: %ut  -- NEWED ON ENTRY
-	Q $G(%ut)=1
-	;
-PICKSET	; .OPT Interactive selection of MUnit Test Group
-	N DIC,Y,%utROU,%utLIST,DIR
-	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
-	Q
-	;
-RUNSET(SETNAME,VERBOSE)	; .SR Run with Specified Selection of MUnit Test Group
-	N Y,%utROU,%utLIST,%utVERB
-	Q:$G(SETNAME)=""
-	S %utVERB=$G(VERBOSE,0)
-	S Y=+$$FIND1^DIC(17.9001,"","X",SETNAME) Q:Y'>0
-	D GETSET(Y,.%utROU,.%utLIST)
-	N Y,SETNAME,%ut
-	D SETUT
-	D EN1(.%utROU,%utLIST)
-	Q
-	;
-	; DOSET CAN BE USED TO RUN A SET OF TESTS BASED ON THE IEN IN THE MUNIT TEST GROUP file (#17.9001)
-DOSET(IEN,%utVERB)	; 140731 JLI added %utVERB as a second argument
-	; IEN - Internal entry number for selected set of tests in the MUNIT TEST GROUP file (#17.9001)
-	; %utVERB - optional input that indicates verbose output is permitted
-	;
-	N %utROU,%utLIST
-	I '$D(%utVERB) S %utVERB=0
-	S %utLIST=0
-	D GETSET($G(IEN),.%utROU,.%utLIST)
-	I %utLIST>0  N IEN,%ut D SETUT,EN1(.%utROU,%utLIST)
-	Q
-	;
-GETSET(IEN,%utROU,%utLIST)	;  JLI 140731 - called from PICKSET, RUNSET, DOSET, GUISET
-	N IENS,%utROOT
-	S IENS=IEN_"," D GETS^DIQ(17.9001,IENS,"1*","","%utROOT")
-	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)
-	Q
-	;
-GUISET(%utRSLT,XTSET)	; Entry point for GUI start with selected Test Set IEN - called by %ut-TEST GROUP LOAD rpc
-	N %utROU,%utLIST,%ut
-	D SETUT
-	S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
-	D GETSET(XTSET,.%utROU,.%utLIST)
-	D GETLIST(.%utROU,%utLIST,%ut("RSLT"))
-	S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
-	S %utRSLT=%ut("RSLT")
-	Q
-	;
-GUILOAD(%utRSLT,%utROUN)	; Entry point for GUI start with %utROUN containing primary routine name - called by %ut-TEST LOAD rpc
-	N %utROU,%ut
-	D SETUT
-	S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
-	S %utROU(1)=%utROUN
-	D GETLIST(.%utROU,1,%ut("RSLT"))
-	S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
-	S %utRSLT=%ut("RSLT")
-	Q
-	;
-GETLIST(%utROU,%utLIST,%utRSLT)	; called from GUISET, GUILOAD
-	N I,%utROUL,%utROUN,%ut,XTCOMNT,XTVALUE,%utCNT
-	S XTVALUE=$NA(^TMP("GUI-MUNIT",$J)) K @XTVALUE
-	S %utCNT=0,XTCOMNT=""
-	D GETTREE^%ut1(.%utROU,%utLIST)
-	F I=1:1 Q:'$D(%utROU(I))  S %utROUL(%utROU(I))=""
-	S %utROUN="" F  S %utROUN=$O(%utROUL(%utROUN)) Q:%utROUN=""  D LOAD(%utROUN,.%utCNT,XTVALUE,XTCOMNT,.%utROUL)
-	M @%utRSLT=@XTVALUE
-	K @%utRSLT@("SHUTDOWN")
-	K @%utRSLT@("STARTUP")
-	S @XTVALUE@("LASTROU")="" ; Use this to keep track of place in routines
-	Q
-	;
-	; generate list of unit test routines, entry points and comments on test for entry point
-LOAD(%utROUN,%utNCNT,XTVALUE,XTCOMNT,%utROUL)	; called from GETLIST, and recursively from LOAD
-	I $T(@("^"_%utROUN))="" S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_"^^*** ERROR - ROUTINE NAME NOT FOUND" Q
-	S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_U_XTCOMNT
-	;N %utI,XTX1,XTX2,LINE
-	N %utI,XTX1,XTX2,LINE,LIST,I
-	; 100622 JLI added code to identify STARTUP and TEARDOWN
-	I $T(@("STARTUP^"_%utROUN))'="",'$D(@XTVALUE@("STARTUP")) S @XTVALUE@("STARTUP")="STARTUP^"_%utROUN
-	I $T(@("SHUTDOWN^"_%utROUN))'="",'$D(@XTVALUE@("SHUTDOWN")) S @XTVALUE@("SHUTDOWN")="SHUTDOWN^"_%utROUN
-	; JLI 140731 handle @TEST identified test tags
-	D NEWSTYLE^%ut1(.LIST,%utROUN)
-	F I=1:1:LIST S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_LIST(I)
-	; JLI 140731 end of @TEST addition
-	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
-	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)
-	Q
-	;
-GUINEXT(%utRSLT,%utLOC,XTGUISEP)	; Entry point for GUI execute next test - called by %ut-TEST NEXT rpc
-	; XTGUISEP - added 110719 to provide for changing separator for GUI
-	;            return from ^ to another value ~~^~~  so that data returned
-	;            is not affected by ^ values in the data - if not present
-	;            sets value to default ^
-	N %utETRY,%utROUT,XTOLROU,XTVALUE,%utERR,%utGUI
-	N %ut
-	I $G(XTGUISEP)="" S XTGUISEP="^"
-	D SETUT
-	S %ut("LOC")=%utLOC
-	S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
-	S XTVALUE=$NA(^TMP("GUI-MUNIT",$J))
-	S %ut("RSLT")=$NA(^TMP("GUINEXT",$J)) K @%ut("RSLT")
-	S %utRSLT=%ut("RSLT")
-	S %utETRY=$P(%utLOC,U),%utROUT=$P(%utLOC,U,2),XTOLROU=$G(@XTVALUE@("LASTROU"))
-	S %utGUI=1
-	; I %utROUT'=XTOLROU D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ;140731 JLI - commented out
-	D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ; 140731 JLI - replaced previous line - moves check for SHUTDOWN at end of processing
-	. I XTOLROU="",$D(@XTVALUE@("STARTUP")) D
-	. . S %ut("LOC")=@XTVALUE@("STARTUP")
-	. . N $ETRAP S $ETRAP="D ERROR^%ut"
-	. . D @(@XTVALUE@("STARTUP"))
-	. . Q
-	. S @XTVALUE@("LASTROU")=%utROUT I %utROUT'="",$T(@("SETUP^"_%utROUT))'="" D
-	. . S %ut("LOC")="SETUP^"_%utROUT
-	. . N $ETRAP S $ETRAP="D ERROR^%ut"
-	. . D @("SETUP^"_%utROUT)
-	. . Q
-	. I %utROUT="",$D(@XTVALUE@("SHUTDOWN")) D
-	. . S %ut("LOC")=@XTVALUE@("SHUTDOWN")
-	. . N $ETRAP S $ETRAP="D ERROR^%ut"
-	. . D @(@XTVALUE@("SHUTDOWN"))
-	. . Q
-	. Q
-	S %ut("LOC")=%utLOC
-	S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
-	D  ; to limit range of error trap so we continue through other tests
-	. N $ETRAP S $ETRAP="D ERROR^%ut"
-	. D @%ut("LOC")
-	. Q
-	I $T(@("TEARDOWN^"_%utROUT))'="" D
-	. S %ut("LOC")="TEARDOWN^"_%utROUT
-	. N $ETRAP S $ETRAP="D ERROR^%ut"
-	. D @("TEARDOWN^"_%utROUT)
-	. Q
-	S @%ut("RSLT")@(1)=%ut("CHK")_XTGUISEP_(%ut("CNT")-1-%utERR)_XTGUISEP_%utERR
-	Q
-	;
-TESTCOVR	; entry under coverage analysis
-	D ENTRY^%uttcovr ; does analysis while running various unit tests
-	Q
-	;
+%ut ;VEN-SMH/JLI - PRIMARY PROGRAM FOR M-UNIT TESTING ;08/29/14  09:31
+ ;;0.1;MASH UTILITIES;;
+ ;
+ ; This routine and its companion, %ut1, provide the basic functionality for
+ ; running unit tests on parts of M programs either at the command line level
+ ; or via the M-Unit GUI application for windows operating systems.
+ ;
+ ; Original by Dr. Joel Ivey
+ ; Contributions by Dr. Sam Habiel
+ ;
+ ; 100622 JLI - corrected typo in comments where %utINPT was listed as %utINP
+ ; 100622 JLI - removed a comment which indicated data could potentially be returned from the called routine
+ ;              in the %utINPT array.
+ ; 100622 JLI - added code to handle STARTUP and SHUTDOWN from GUI app
+ ; 110719 JLI - modified separators in GUI handling from ^ to ~~^~~
+ ;              in the variable XTGUISEP if using a newer version of the
+ ;              GUI app (otherwise, it is simply set to ^) since results
+ ;              with a series of ^ embedded disturbed the output reported
+ ; 130726 SMH - Fixed SETUP and TEARDOWN so that they run before/after each
+ ;              test rather than once. General refactoring.
+ ; 130726 SMH - SETUT initialized IO in case it's not there to $P. Inits vars
+ ;              using DT^DICRW.
+ ; 131217 SMH - Change call in SETUP to S U="^" instead of DT^DICRW
+ ; 131218 SMH - Any checks to $ZE will also check $ZS for GT.M.
+ ; 131218 SMH - Remove calls to %ZISUTL to manage devices to prevent dependence on VISTA.
+ ;              Use %utNIT("DEV","OLD") for old devices
+ ; 140109 SMH - Add parameter %utBREAK - Break upon error
+ ; 1402   SMH - Break will cause the break to happen even on failed tests.
+ ; 140401 SMH - Added Succeed entry point for take it into your hands tester.
+ ; 140401 SMH - Reformatted the output of M-Unit so that the test's name
+ ;              will print BEFORE the execution of the test. This has been
+ ;              really confusing for beginning users of M-Unit, so this was
+ ;              necessary.
+ ; 140401 SMH - OK message gets printed at the end of --- as [OK].
+ ; 140401 SMH - FAIL message now prints. Previously, OK failed to be printed.
+ ;              Unfortunately, that's rather passive aggressive. Now it
+ ;              explicitly says that a test failed.
+ ; 140503 SMH - Fixed IO issues all over the routine. Much simpler now.
+ ; 140731 JLI - Combined routine changes between JLI and SMH
+ ;              Moved routines from %utNIT and %utNIT1 to %ut and %ut1
+ ;              Updated unit test routines (%utt1 to %utt6)
+ ;              Created M-UNIT TEST GROUP file at 17.9001 based on the 17.9001 file
+ Q
+ ;
+EN(%utRNAM,%utVERB,%utBREAK) ; .SR Entry point with primary test routine name, optional 1 for verbose output
+ N %utLIST,%utROU,%ut
+ I '+$G(%utVERB) S %utVERB=0
+ S %utLIST=1,%utROU(%utLIST)=%utRNAM
+ D SETUT
+ D EN1(.%utROU,%utLIST)
+ Q
+ ;
+SETUT ;
+ ; VEN/SMH 26JUL2013
+ I '($D(IO)#2) S IO=$P
+ S U="^"
+ ; VEN/SMH 26JUL2013 END
+ ;
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ S %ut("IO")=IO
+ S %ut=1 ; set to identify unit test being run check with $$ISUTEST^%ut()
+ ;
+ ; ZEXCEPT: %utBREAK
+ I $G(%utBREAK) S %ut("BREAK")=1
+ Q
+ ;
+EN1(%utROU,%utLIST) ;
+ ; VEN/SMH 26JUL2013 - This block is refactored to fix problems with
+ ; SETUP and TEARDOWN not happening at the right time
+ N %utERRL,%utK,%utI,%utJ,%utSTRT
+ ; ZEXCEPT: %utVERB   -- ARGUMENT TO EN
+ ; ZEXCEPT: %utGUI      -- CONDITIONALLY DEFINED BY GUINEXT
+ ; ZEXCEPT: %ut  -- NEWED IN EN
+ ;
+ ; Structure map for %ut
+ ; -- CURR = Counter for routine number. Used as sub in %utROU
+ ; -- ECNT = Entry point count in loop (cf. NERT); VEN/SMH - Needed?
+ ; -- FAIL = Number of failures
+ ; -- CHK  = Number of checks ran (TF/EQ/FAIL)
+ ; -- NENT = Number of entry points ran
+ ; -- ERRN = Number of errors
+ S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
+ ;
+ ; -- GET LIST OF ROUTINES --
+ ; first get any tree of routines from this one
+ D GETTREE^%ut1(.%utROU,.%utLIST)
+ ;
+ ; -- STARTUP --
+ ; 070224 - following code added to allow one overall STARTUP code JLI
+ F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D  I $G(%utSTRT)'="" D @%utSTRT Q
+ . I $T(@("STARTUP^"_%utROU(%ut("CURR"))))'="" S %utSTRT="STARTUP^"_%utROU(%ut("CURR"))
+ . Q
+ ; 070224 - end of addition JLI
+ ;
+ ;
+ ; Now process each routine that has been referenced
+ S %ut("CURR")=0
+ F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D
+ . N %utETRY ; Test list to run
+ . ;
+ . ; Collect Test list.
+ . D CHEKTEST^%ut1(%utROU(%ut("CURR")),.%ut,.%utETRY)
+ . ;
+ . ; if a SETUP entry point exists, save it off in %ut
+ . N %utSETUP S %utSETUP="SETUP^"_%utROU(%ut("CURR"))
+ . S %ut("LINE")=$T(@%utSETUP) I %ut("LINE")'="" S %ut("SETUP")=%utSETUP
+ . K %utSETUP ; we're done!
+ . ;
+ . ; if a TEARDOWN entry point exists, ditto
+ . N %utTEARDOWN S %utTEARDOWN="TEARDOWN^"_%utROU(%ut("CURR"))
+ . S %ut("LINE")=$T(@%utTEARDOWN) I %ut("LINE")'="" S %ut("TEARDOWN")=%utTEARDOWN
+ . K %utTEARDOWN ; done here.
+ . ;
+ . ; VEN/SMH 26JUL2013 - this block changed to correct running of setup and teardown
+ . ; run each of the specified entry points
+ . ;
+ . ; == THIS FOR/DO BLOCK IS THE CENTRAL TEST RUNNER ==
+ . S %utI=0
+ . F  S %utI=$O(%utETRY(%utI)) Q:%utI'>0  S %ut("ENUM")=%ut("ERRN")+%ut("FAIL") D
+ . . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . . ;
+ . . ; Run Set-up Code (only if present)
+ . . S %ut("ENT")=$G(%ut("SETUP")) ; Current entry
+ . . S %ut("NAME")="Set-up Code"
+ . . D:%ut("ENT")]"" @%ut("ENT")
+ . . ;
+ . . ; Run actual test
+ . . S %ut("ECNT")=%ut("ECNT")+1
+ . . S %ut("NAME")=%utETRY(%utI,"NAME")
+ . . S %ut("ENT")=%utETRY(%utI)_"^"_%utROU(%ut("CURR"))
+ . . I %utVERB,'$D(%utGUI) D VERBOSE1(.%utETRY,%utI) ; Say what we executed.
+ . . D @%ut("ENT")
+ . . ;
+ . . ; Run Teardown Code (only if present)
+ . . S %ut("ENT")=$G(%ut("TEARDOWN"))
+ . . S %ut("NAME")="Teardown Code"
+ . . D:%ut("ENT")]"" @%ut("ENT")
+ . . ;
+ . . ; ENUM = Number of errors + failures
+ . . ; Only print out the success message [OK] If our error number remains
+ . . ; the same as when we started the loop.
+ . . I %utVERB,'$D(%utGUI) D
+ . . . I %ut("ENUM")=(%ut("ERRN")+%ut("FAIL")) D VERBOSE(.%utETRY,%utI,1) I 1
+ . . . E  D VERBOSE(.%utETRY,%utI,0)
+ . ;
+ . ;
+ . ; keep a %utCNT of number of entry points executed across all routines
+ . S %ut("NENT")=%ut("NENT")+%ut("ENTN")
+ . Q
+ ;
+ ; -- SHUTDOWN --
+ ; 070224 - following code added to allow one overall SHUTDOWN code JLI
+ N XTFINISH
+ S %ut("CURR")=0
+ F  S %ut("CURR")=%ut("CURR")+1 Q:'$D(%utROU(%ut("CURR")))  D  I $G(XTFINISH)'="" D @XTFINISH Q
+ . I $T(@("SHUTDOWN^"_%utROU(%ut("CURR"))))'="" S XTFINISH="SHUTDOWN^"_%utROU(%ut("CURR"))
+ . Q
+ ; 070224 - End of addition JLI
+ ; and output the results
+ D SETIO
+ W !!,"Ran ",%utLIST," Routine",$S(%utLIST>1:"s",1:""),", ",%ut("NENT")," Entry Tag",$S(%ut("NENT")>1:"s",1:"")
+ 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:""),"."
+ D RESETIO
+ Q
+ ; -- end EN1
+VERBOSE(%utETRY,%utI,SUCCESS) ; Say whether we succeeded or failed.
+ ; ZEXCEPT: %ut - NEWED IN EN
+ D SETIO
+ N I F I=$X+3:1:73 W "-"
+ W ?73
+ I $G(SUCCESS) W "[OK]"
+ E  W "[FAIL]"
+ D RESETIO
+ Q
+ ;
+VERBOSE1(%utETRY,%utI) ; Print out the entry point info
+ ; ZEXCEPT: %ut - NEWED IN EN
+ D SETIO
+ W !,%utETRY(%utI) I $G(%utETRY(%utI,"NAME"))'="" W " - ",%utETRY(%utI,"NAME")
+ D RESETIO
+ Q
+CHKTF(XTSTVAL,XTERMSG) ; Entry point for checking True or False values
+ ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
+ ; ZEXCEPT: %ut - NEWED IN EN
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ I '$D(XTSTVAL) D NVLDARG Q
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+ S %ut("CHK")=$G(%ut("CHK"))+1
+ I '$D(%utGUI) D
+ . D SETIO
+ . I 'XTSTVAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " D
+ . . W XTERMSG,! S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
+ . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+ . . Q
+ . I XTSTVAL W "."
+ . D RESETIO
+ . Q
+ 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
+ Q
+ ;
+CHKEQ(XTEXPECT,XTACTUAL,XTERMSG) ; Entry point for checking values to see if they are EQUAL
+ N FAILMSG
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+ ; ZEXCEPT: %ut  -- NEWED IN EN
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ I '$D(XTEXPECT)!'$D(XTACTUAL) D NVLDARG Q  ; JLI 140824 changed from AND to OR, since both necessary, but only one might be entered
+ S XTACTUAL=$G(XTACTUAL),XTEXPECT=$G(XTEXPECT)
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+ S %ut("CHK")=%ut("CHK")+1
+ I XTEXPECT'=XTACTUAL S FAILMSG="<"_XTEXPECT_"> vs <"_XTACTUAL_"> - "
+ I '$D(%utGUI) D
+ . D SETIO
+ . I XTEXPECT'=XTACTUAL W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W FAILMSG,XTERMSG,! D
+ . . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
+     . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+ . . Q
+ . E  W "."
+ . D RESETIO
+ . Q
+ 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
+ Q
+ ;
+FAIL(XTERMSG) ; Entry point for generating a failure message
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ I $G(XTERMSG)="" S XTERMSG="no failure message provided"
+ S %ut("CHK")=%ut("CHK")+1
+ I '$D(%utGUI) D
+ . D SETIO
+ . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+ . . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
+ . . I $D(%ut("BREAK")) BREAK  ; Break upon failure
+ . . Q
+ . D RESETIO
+ . Q
+ I $D(%utGUI) S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG,%ut("FAIL")=%ut("FAIL")+1
+ Q
+SUCCEED ; Entry point for forcing a success (Thx David Whitten)
+ ; ZEXCEPT: %utERRL,%utGUI - CREATED IN SETUP, KILLED IN END
+ ; ZEXCEPT: %ut - NEWED IN EN
+ ; Switch IO and write out the dot for activity
+ I '$D(%utGUI) D
+ . D SETIO
+ . W "."
+ . D RESETIO
+ ;
+ ; Increment test counter
+ S %ut("CHK")=%ut("CHK")+1
+ QUIT
+ ;
+CHKLEAKS(%utCODE,%utLOC,%utINPT) ; functionality to check for variable leaks on executing a section of code
+ ; %utCODE - A string that specifies the code that is to be XECUTED and checked for leaks.
+ ;            this should be a complete piece of code (e.g., "S X=$$NOW^XLFDT()" or "D EN^%ut(""ROUNAME"")")
+ ; %utLOC  - A string that is used to indicate the code tested for variable leaks
+ ; %utINPT - An optional variable which may be passed by reference.  This may
+ ;           be used to pass any variable values, etc. into the code to be
+ ;           XECUTED.  In this case, set the subscript to the variable name and the
+ ;           value of the subscripted variable to the desired value of the subscript.
+ ;              e.g., (using NAME as my current namespace)
+ ;                   S CODE="S %utINPT=$$ENTRY^ROUTINE(ZZVALUE1,ZZVALUE2)"
+ ;                   S NAMELOC="ENTRY^ROUTINE leak test"   (or simply "ENTRY^ROUTINE")
+ ;                   S NAMEINPT("ZZVALUE1")=ZZVALUE1
+ ;                   S NAMEINPT("ZZVALUE2")=ZZVALUE2
+ ;                   D CHKLEAKS^%ut(CODE,NAMELOC,.NAMEINPT)
+ ;
+ ;           If part of a unit test, any leaked variables in ENTRY^ROUTINE which result
+ ;           from running the code with the variables indicated will be shown as FAILUREs.
+ ;
+ ;           If called outside of a unit test, any leaked variables will be printed to the
+ ;           current device.
+ ;
+ N (%utCODE,%utLOC,%utINPT,DUZ,IO,U,%utERRL,%ut,%utGUI,%utERR,%utI,%utJ,%utK,%utLIST,%utROU,%utSTRT,XTGUISEP)
+ ; ZEXCEPT: %ut - part of exclusive NEW TESTS FOR EXISTENCE ONLY
+ ; ZEXCEPT: %utVAR - handled by exclusive NEW
+ ;
+ ; ACTIVATE ANY VARIABLES PASSED AS SUBSCRIPTS TO %utINPT TO THEIR VALUES
+ S %utVAR=" " F  S %utVAR=$O(%utINPT(%utVAR)) Q:%utVAR=""  S (@%utVAR)=%utINPT(%utVAR)
+ X %utCODE
+ N ZZUTVAR S ZZUTVAR="%"
+ I $G(%ut)=1 D
+ . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) D FAIL^%ut(%utLOC_" VARIABLE LEAK: "_ZZUTVAR)
+ . 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)
+ . Q
+ I '($G(%ut)=1) D
+ . I $D(@ZZUTVAR),'$D(%utINPT(ZZUTVAR)) W !,%utLOC_" VARIABLE LEAK: "_ZZUTVAR
+ . 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
+ . Q
+ Q
+ ;
+NVLDARG ; generate message for invalid arguments to test
+ N XTERMSG
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ ; ZEXCEPT: %utERRL,%utGUI -CREATED IN SETUP, KILLED IN END
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ S XTERMSG="NO VALUES INPUT TO CHKEQ^%ut - no evaluation possible"
+ I '$D(%utGUI) D
+ . D SETIO
+ . W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - " W XTERMSG,! D
+ . . S %ut("FAIL")=%ut("FAIL")+1,%utERRL(%ut("FAIL"))=%ut("NAME"),%utERRL(%ut("FAIL"),"MSG")=XTERMSG,%utERRL(%ut("FAIL"),"ENTRY")=%ut("ENT")
+ . . Q
+ . D RESETIO
+ . Q
+ I $D(%utGUI) S %ut("CNT")=%ut("CNT")+1,@%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"FAILURE"_XTGUISEP_XTERMSG,%ut("FAIL")=%ut("FAIL")+1
+ Q
+ ;
+ERROR ; record errors
+ ; ZEXCEPT: %utERRL,%utGUI,%utERR -CREATED IN SETUP, KILLED IN END
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ ; ZEXCEPT: XTGUISEP - newed in GUINEXT
+ S %ut("CHK")=%ut("CHK")+1
+ I '$D(%utGUI) D ERROR1
+ I $D(%utGUI) D
+ . S %ut("CNT")=%ut("CNT")+1
+ . S %utERR=%utERR+1
+ . S @%ut("RSLT")@(%ut("CNT"))=%ut("LOC")_XTGUISEP_"ERROR"_XTGUISEP_$S(+$SY=47:$ZS,1:$ZE)
+ . Q
+ S @($S(+$SY=47:"$ZS",1:"$ZE")_"="_""""""),$EC=""
+ Q
+ ;
+ERROR1 ;
+ I $G(%ut("BREAK")) BREAK  ; if we are asked to break upon error, please do so!
+ ; ZEXCEPT: %utERRL -CREATED IN SETUP, KILLED IN END
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ D SETIO
+ W !,%ut("ENT")," - " W:%ut("NAME")'="" %ut("NAME")," - Error: " W $S(+$SY=47:$ZS,1:$ZE),! D
+ . 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
+ D RESETIO
+ Q
+SETIO ; Set M-Unit Device to write the results to...
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ I $IO'=%ut("IO") S (IO(0),%ut("DEV","OLD"))=$IO USE %ut("IO") SET IO=$IO
+ QUIT
+ ;
+RESETIO ; Reset $IO back to the original device if we changed it.
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ I $D(%ut("DEV","OLD")) S IO(0)=%ut("IO") U %ut("DEV","OLD") S IO=$IO K %ut("DEV","OLD")
+ QUIT
+ ;
+ISUTEST() ; .SUPPORTED API TO DETERMINE IF CURRENTLY IN UNIT TEST
+ ; ZEXCEPT: %ut  -- NEWED ON ENTRY
+ Q $G(%ut)=1
+ ;
+PICKSET ; .OPT Interactive selection of MUnit Test Group
+ N DIC,Y,%utROU,%utLIST,DIR
+ 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
+ Q
+ ;
+RUNSET(SETNAME,VERBOSE) ; .SR Run with Specified Selection of MUnit Test Group
+ N Y,%utROU,%utLIST,%utVERB
+ Q:$G(SETNAME)=""
+ S %utVERB=$G(VERBOSE,0)
+ S Y=+$$FIND1^DIC(17.9001,"","X",SETNAME) Q:Y'>0
+ D GETSET(Y,.%utROU,.%utLIST)
+ N Y,SETNAME,%ut
+ D SETUT
+ D EN1(.%utROU,%utLIST)
+ Q
+ ;
+ ; DOSET CAN BE USED TO RUN A SET OF TESTS BASED ON THE IEN IN THE MUNIT TEST GROUP file (#17.9001)
+DOSET(IEN,%utVERB) ; 140731 JLI added %utVERB as a second argument
+ ; IEN - Internal entry number for selected set of tests in the MUNIT TEST GROUP file (#17.9001)
+ ; %utVERB - optional input that indicates verbose output is permitted
+ ;
+ N %utROU,%utLIST
+ I '$D(%utVERB) S %utVERB=0
+ S %utLIST=0
+ D GETSET($G(IEN),.%utROU,.%utLIST)
+ I %utLIST>0  N IEN,%ut D SETUT,EN1(.%utROU,%utLIST)
+ Q
+ ;
+GETSET(IEN,%utROU,%utLIST) ;  JLI 140731 - called from PICKSET, RUNSET, DOSET, GUISET
+ N IENS,%utROOT
+ S IENS=IEN_"," D GETS^DIQ(17.9001,IENS,"1*","","%utROOT")
+ 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)
+ Q
+ ;
+GUISET(%utRSLT,XTSET) ; Entry point for GUI start with selected Test Set IEN - called by %ut-TEST GROUP LOAD rpc
+ N %utROU,%utLIST,%ut
+ D SETUT
+ S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
+ D GETSET(XTSET,.%utROU,.%utLIST)
+ D GETLIST(.%utROU,%utLIST,%ut("RSLT"))
+ S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
+ S %utRSLT=%ut("RSLT")
+ Q
+ ;
+GUILOAD(%utRSLT,%utROUN) ; Entry point for GUI start with %utROUN containing primary routine name - called by %ut-TEST LOAD rpc
+ N %utROU,%ut
+ D SETUT
+ S %ut("RSLT")=$NA(^TMP("MUNIT-%utRSLT",$J)) K @%ut("RSLT")
+ S %utROU(1)=%utROUN
+ D GETLIST(.%utROU,1,%ut("RSLT"))
+ S @%ut("RSLT")@(1)=(@%ut("RSLT")@(1))_"^1" ; 110719 mark as new version
+ S %utRSLT=%ut("RSLT")
+ Q
+ ;
+GETLIST(%utROU,%utLIST,%utRSLT) ; called from GUISET, GUILOAD
+ N I,%utROUL,%utROUN,%ut,XTCOMNT,XTVALUE,%utCNT
+ S XTVALUE=$NA(^TMP("GUI-MUNIT",$J)) K @XTVALUE
+ S %utCNT=0,XTCOMNT=""
+ D GETTREE^%ut1(.%utROU,%utLIST)
+ F I=1:1 Q:'$D(%utROU(I))  S %utROUL(%utROU(I))=""
+ S %utROUN="" F  S %utROUN=$O(%utROUL(%utROUN)) Q:%utROUN=""  D LOAD(%utROUN,.%utCNT,XTVALUE,XTCOMNT,.%utROUL)
+ M @%utRSLT=@XTVALUE
+ K @%utRSLT@("SHUTDOWN")
+ K @%utRSLT@("STARTUP")
+ S @XTVALUE@("LASTROU")="" ; Use this to keep track of place in routines
+ Q
+ ;
+ ; generate list of unit test routines, entry points and comments on test for entry point
+LOAD(%utROUN,%utNCNT,XTVALUE,XTCOMNT,%utROUL) ; called from GETLIST, and recursively from LOAD
+ I $T(@("^"_%utROUN))="" S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_"^^*** ERROR - ROUTINE NAME NOT FOUND" Q
+ S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_U_XTCOMNT
+ ;N %utI,XTX1,XTX2,LINE
+ N %utI,XTX1,XTX2,LINE,LIST,I
+ ; 100622 JLI added code to identify STARTUP and TEARDOWN
+ I $T(@("STARTUP^"_%utROUN))'="",'$D(@XTVALUE@("STARTUP")) S @XTVALUE@("STARTUP")="STARTUP^"_%utROUN
+ I $T(@("SHUTDOWN^"_%utROUN))'="",'$D(@XTVALUE@("SHUTDOWN")) S @XTVALUE@("SHUTDOWN")="SHUTDOWN^"_%utROUN
+ ; JLI 140731 handle @TEST identified test tags
+ D NEWSTYLE^%ut1(.LIST,%utROUN)
+ F I=1:1:LIST S %utNCNT=%utNCNT+1,@XTVALUE@(%utNCNT)=%utROUN_U_LIST(I)
+ ; JLI 140731 end of @TEST addition
+ 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
+ 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)
+ Q
+ ;
+GUINEXT(%utRSLT,%utLOC,XTGUISEP) ; Entry point for GUI execute next test - called by %ut-TEST NEXT rpc
+ ; XTGUISEP - added 110719 to provide for changing separator for GUI
+ ;            return from ^ to another value ~~^~~  so that data returned
+ ;            is not affected by ^ values in the data - if not present
+ ;            sets value to default ^
+ N %utETRY,%utROUT,XTOLROU,XTVALUE,%utERR,%utGUI
+ N %ut
+ I $G(XTGUISEP)="" S XTGUISEP="^"
+ D SETUT
+ S %ut("LOC")=%utLOC
+ S %ut("CURR")=0,%ut("ECNT")=0,%ut("FAIL")=0,%ut("CHK")=0,%ut("NENT")=0,%ut("ERRN")=0
+ S XTVALUE=$NA(^TMP("GUI-MUNIT",$J))
+ S %ut("RSLT")=$NA(^TMP("GUINEXT",$J)) K @%ut("RSLT")
+ S %utRSLT=%ut("RSLT")
+ S %utETRY=$P(%utLOC,U),%utROUT=$P(%utLOC,U,2),XTOLROU=$G(@XTVALUE@("LASTROU"))
+ S %utGUI=1
+ S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
+ ; I %utROUT'=XTOLROU D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ;140731 JLI - commented out
+ ;D  I %utROUT="" S @%utRSLT@(1)="" K @XTVALUE Q  ; 140731 JLI - replaced previous line - moves check for SHUTDOWN at end of processing
+ D  I %utROUT="" S @%utRSLT@(1)="" Q  ; 140829 JLI - Have to leave XTVALUE intact, in case they simply run again for STARTUP, etc.
+ . I XTOLROU="",$D(@XTVALUE@("STARTUP")) D
+ . . S %ut("LOC")=@XTVALUE@("STARTUP")
+ . . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . . D @(@XTVALUE@("STARTUP"))
+ . . Q
+ . S @XTVALUE@("LASTROU")=%utROUT I %utROUT'="",$T(@("SETUP^"_%utROUT))'="" D
+ . . S %ut("LOC")="SETUP^"_%utROUT
+ . . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . . D @("SETUP^"_%utROUT)
+ . . Q
+ . I %utROUT="",$D(@XTVALUE@("SHUTDOWN")) D
+ . . S %ut("LOC")=@XTVALUE@("SHUTDOWN")
+ . . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . . D @(@XTVALUE@("SHUTDOWN"))
+ . . Q
+ . Q
+ S %ut("LOC")=%utLOC
+ S %ut("CHK")=0,%ut("CNT")=1,%utERR=0
+ D  ; to limit range of error trap so we continue through other tests
+ . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . D @%ut("LOC")
+ . Q
+ I $T(@("TEARDOWN^"_%utROUT))'="" D
+ . S %ut("LOC")="TEARDOWN^"_%utROUT
+ . N $ETRAP S $ETRAP="D ERROR^%ut"
+ . D @("TEARDOWN^"_%utROUT)
+ . Q
+ S @%ut("RSLT")@(1)=%ut("CHK")_XTGUISEP_(%ut("CNT")-1-%utERR)_XTGUISEP_%utERR
+ Q
+ ;
+TESTCOVR ; entry under coverage analysis
+ D ENTRY^%uttcovr ; does analysis while running various unit tests
+ Q
+ ;
diff --git a/Routines/%ut1.m b/Routines/%ut1.m
index 6559fb1..f076a76 100644
--- a/Routines/%ut1.m
+++ b/Routines/%ut1.m
@@ -1,277 +1,267 @@
-%ut1	;VEN/SMH/JLI - CONTINUATION OF M-UNIT PROCESSING ;2014-09-10  7:41 PM
-	;;0.1;MASH UTILITIES;
-	;
-	;following is original header from XTMUNIT1 in unreleased patch XT*7.3*81 VA code
-	;XTMUNIT1    ;JLI/FO-OAK-CONTINUATION OF UNIT TEST ROUTINE ;2014-04-17  5:26 PM
-	;;7.3;TOOLKIT;**81**;APR 25 1995;Build 24
-	;
-	;
-	; Original by Dr. Joel Ivey
-	; Major contributions by Dr. Sam Habiel
-	;
-	; Changes:
-	; 130726 SMH - Moved test collection logic from %utUNIT to here (multiple places)
-	; 131218 SMH - dependence on XLFSTR removed
-	; 131218 SMH - CHEKTEST refactored to use $TEXT instead of ^%ZOSF("LOAD")
-	; 131218 SMH - CATCHERR now nulls out $ZS if on GT.M
-	;
-	; TODO: find this routine and add to repo.
-	D EN^%ut("%utt3")
-	Q
-	;
-CHEKTEST(%utROU,%ut,%utUETRY)	; Collect Test list.
-	; %utROU - input - Name of routine to check for tags with @TEST attribute
-	; %ut - input/output - passed by reference
-	; %utUETRY - input/output - passed by reference
-	;
-	; Test list collected in two ways:
-	; - @TEST on labellines
-	; - Offsets of XTENT
-	;
-	S %ut("ENTN")=0 ; Number of test, sub to %utUETRY.
-	;
-	; This stanza and everything below is for collecting @TEST.
-	; VEN/SMH - block refactored to use $TEXT instead of ^%ZOSF("LOAD")
-	N I,LIST
-	S I=$L($T(@(U_%utROU))) I I<0 Q "-1^Invalid Routine Name"
-	N $ETRAP S $ETRAP="D CATCHERR^%ut1"
-	; 140731 JLI - the following SMH code is replaced by the code below
-	; Complexity galore: $TEXT loops through routine
-	; IF tab or space isn't the first character ($C(9,32)) and line contains @TEST
-	; Load that line as a testing entry point
-	; F I=1:1 S LINE=$T(@("+"_I_U_%utROU)) Q:LINE=""  I $C(9,32)'[$E(LINE),$$UP(LINE)["@TEST" D
-	; . N TAGNAME,CHAR,NPAREN S TAGNAME="",NPAREN=0
-	; . F  Q:LINE=""  S CHAR=$E(LINE),LINE=$E(LINE,2,999) Q:CHAR=""  Q:" ("[CHAR  S TAGNAME=TAGNAME_CHAR
-	; . ; should be no paren or arguments
-	; . I CHAR="(" Q
-	; . F  Q:LINE=""  S CHAR=$E(LINE) Q:" ;"'[CHAR  S LINE=$E(LINE,2,999)
-	; . I $$UP($E(LINE,1,5))="@TEST" S LINE=$E(LINE,6,999) D
-	; . . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=TAGNAME
-	; . . F  Q:LINE=""  S CHAR=$E(LINE) Q:CHAR?1AN  S LINE=$E(LINE,2,999)
-	; . . S %utUETRY(%ut("ENTN"),"NAME")=LINE
-	; JLI 140731 - end of code replaced by following code
-	; JLI 140731 - the following code replaces the code above
-	D NEWSTYLE(.LIST,%utROU)
-	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)
-	; JLI 140731 - end of replacement code
-	;
-	;
-	; This Stanza is to collect XTENT offsets
-	N %utUI F %utUI=1:1 S %ut("ELIN")=$T(@("XTENT+"_%utUI_"^"_%utROU)) Q:$P(%ut("ELIN"),";",3)=""  D
-	. S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=$P(%ut("ELIN"),";",3),%utUETRY(%ut("ENTN"),"NAME")=$P(%ut("ELIN"),";",4)
-	. Q
-	;
-	QUIT
-	;
-	; VEN/SMH - Is this catch needed anymore?
-CATCHERR	; catch error on trying to load file if it doesn't exist ; JLI 120806
-	W !,"In CATCHERR",! ; JLI 140910 DEBUG
-        S $ZE="",$EC=""
-	I +$SY=47 S $ZS="" ; VEN/SMH fur GT.M.
-	QUIT
-	;
-	; VEN/SMH 26JUL2013 - Moved GETTREE here.
-GETTREE(%utROU,%utULIST)	;
-	; first get any other routines this one references for running subsequently
-	; then any that they refer to as well
-	; this builds a tree of all routines referred to by any routine including each only once
-	N %utUK,%utUI,%utUJ,%utURNAM,%utURLIN
-	F %utUK=1:1 Q:'$D(%utROU(%utUK))  D
-	. F %utUI=1:1 S %utURLIN=$T(@("XTROU+"_%utUI_"^"_%utROU(%utUK))) S %utURNAM=$P(%utURLIN,";",3) Q:%utURNAM=""  D
-	. . F %utUJ=1:1:%utULIST I %utROU(%utUJ)=%utURNAM S %utURNAM="" Q
-	. . I %utURNAM'="",$T(@("+1^"_%utURNAM))="" W:'$D(XWBOS) "Referenced routine ",%utURNAM," not found.",! Q
-	. . S:%utURNAM'="" %utULIST=%utULIST+1,%utROU(%utULIST)=%utURNAM
-	QUIT
-	;
-NEWSTYLE(LIST,ROUNAME)	; JLI 140726 identify and return list of newstyle tags or entries for this routine
-	; LIST - input, passed by reference - returns containing array with list of tags identified as tests
-	;                   LIST indicates number of tags identified, LIST(n)=tag^test_info where tag is entry point for test
-	; ROUNAME - input - routine name in which tests should be identified
-	;
-	N I,VALUE,LINE
-	K LIST S LIST=0
-	; search routine by line for a tag and @TEST declaration
-	F I=1:1 S LINE=$T(@("+"_I_"^"_ROUNAME)) Q:LINE=""  S VALUE=$$CHECKTAG(LINE) I VALUE'="" S LIST=LIST+1,LIST(LIST)=VALUE
-	Q
-	;
-CHECKTAG(LINE)	; JLI 140726 check line to determine @test TAG
-	; LINE - input - Line of code to be checked
-	; returns null line if not @TEST line, otherwise TAG^NOTE
-	N TAG,NOTE,CHAR
-	I $E(LINE)=" " Q "" ; test entry must have a tag
-	I $$UP(LINE)'["@TEST" Q "" ; must have @TEST declaration
-	I $P($$UP(LINE),"@TEST")["(" Q "" ; can't have an argument
-	S TAG=$P(LINE," "),LINE=$P(LINE," ",2,400),NOTE=$P($$UP(LINE),"@TEST"),LINE=$E(LINE,$L(NOTE)+5+1,$L(LINE))
-	F  Q:NOTE=""  S CHAR=$E(NOTE),NOTE=$E(NOTE,2,$L(NOTE)) I " ;"'[CHAR Q  ;
-	I $L(NOTE)'=0 Q "" ; @TEST must be first text on line
-	F  Q:$E(LINE)'=" "  S LINE=$E(LINE,2,$L(LINE)) ; remove leading spaces from test info
-	S TAG=TAG_U_LINE
-	Q TAG
-	;
-	; VEN/SMH 17DEC2013 - Remove dependence on VISTA - Uppercase here instead of XLFSTR.
-UP(X)	;
-	Q $TR(X,"abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ")
-	;
-COV(NMSP,COVCODE,VERBOSITY)	; VEN/SMH - PUBLIC ENTRY POINT; Coverage calculations
-	; NMSP: Namespace of the routines to analyze. End with * to include all routines.
-	;       Not using * will only include the routine with NMSP name.
-	;       e.g. PSOM* will include all routines starting with PSOM
-	;            PSOM will only include PSOM.
-	; COVCODE: Mumps code to run over which coverage will be calculated. Typically Unit Tests.
-	; VERBOSITY (optional): Scalar from -1 to 3.
-	;    - -1 = Global output in ^TMP("%utCOVREPORT",$J)
-	;    - 0 = Print only total coverage
-	;    - 1 = Break down by routine
-	;    - 2 = Break down by routine and tag
-	;    - 3 = Break down by routine and tag, and print lines that didn't execute for each tag.
-	;
-	Q:'(+$SY=47)  ; GT.M only!
-        ;
-	; ZEXCEPT: CTRAP - not really a variable
-	S VERBOSITY=+$G(VERBOSITY) ; Get 0 if not passed.
-	N %ZR ; GT.M specific
-	D SILENT^%RSEL(NMSP,"SRC") ; GT.M specific. On Cache use $O(^$R(RTN)).
-	;
-	N RN S RN=""
-	W "Loading routines to test coverage...",!
-	F  S RN=$O(%ZR(RN)) Q:RN=""  W RN," " D
-	. N L2 S L2=$T(+2^@RN)
-	. S L2=$TR(L2,$C(9,32)) ; Translate spaces and tabs out
-	. I $E(L2,1,2)'=";;" K %ZR(RN)  ; Not a human produced routine
-	;
-	N RTNS M RTNS=%ZR
-	K %ZR
-	;
-	N GL
-	S GL=$NA(^TMP("%utCOVCOHORT",$J))
-	K @GL
-	D RTNANAL(.RTNS,GL)
-	K ^TMP("%utCOVCOHORTSAV",$J)
-	M ^TMP("%utCOVCOHORTSAV",$J)=^TMP("%utCOVCOHORT",$J)
-	;
-	;
-	K ^TMP("%utCOVRESULT",$J)
-	VIEW "TRACE":1:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M START PROFILING
-	DO  ; Run the code, but keep our variables to ourselves.
-	. NEW $ETRAP,$ESTACK
-	. SET $ETRAP="Q:($ES&$Q) -9 Q:$ES  W ""CTRL-C ENTERED"""
-	. USE $PRINCIPAL:(CTRAP=$C(3))
-	. NEW (DUZ,IO,COVCODE,U,DILOCKTM,DISYS,DT,DTIME,IOBS,IOF,IOM,ION,IOS,IOSL,IOST,IOT,IOXY)
-	. XECUTE COVCODE
-	VIEW "TRACE":0:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M STOP PROFILING
-	;
-	D COVCOV($NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J))) ; Venn diagram matching between globals
-	;
-	; Report
-	I VERBOSITY=-1 D
-	. K ^TMP("%utCOVREPORT",$J)
-	. D COVRPTGL($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),$NA(^TMP("%utCOVREPORT",$J)))
-	E  D COVRPT($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),VERBOSITY)
-	;
-	QUIT
-	;
-RTNANAL(RTNS,GL)	; [Private] - Routine Analysis
-	; Create a global similar to the trace global produced by GT.M in GL
-	; Only non-comment lines are stored.
-	; A tag is always stored. Tag,0 is stored only if there is code on the tag line (format list or actual code).
-	; tags by themselves don't count toward the total.
-	;
-	N RTN S RTN=""
-	F  S RTN=$O(RTNS(RTN)) Q:RTN=""  D                       ; for each routine
-	. N TAG
-	. S TAG=RTN                                              ; start the tags at the first
-	. 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)
-	. . I $E(LN)?1A D  QUIT                                  ; formal line
-	. . . N T                                                ; Terminator
-	. . . N J F J=1:1:$L(LN) S T=$E(LN,J) Q:T'?1AN           ; Loop to...
-	. . . S TAG=$E(LN,1,J-1)                                 ; Get tag
-	. . . S @GL@(RTN,TAG)=TAG                                ; store line
-	. . . I T="(" S @GL@(RTN,TAG,0)=LN                       ; formal list
-	. . . E  D                                               ; No formal list
-	. . . . N LNTR S LNTR=$P(LN,TAG,2,999),LNTR=$TR(LNTR,$C(9,32)) ; Get rest of line, Remove spaces and tabs
-	. . . . I $E(LNTR)=";" QUIT                              ; Comment
-	. . . . S @GL@(RTN,TAG,0)=LN                             ; Otherwise, store for testing
-	. . . S I=0                                              ; Start offsets from zero (first one at the for will be 1)
-	. . I $C(32,9)[$E(LN) D  QUIT                            ; Regular line
-	. . . N LNTR S LNTR=$TR(LN,$C(32,9))                     ; Remove all spaces and tabs
-	. . . I $E(LNTR)=";" QUIT                                ; Comment line -- don't want.
-	. . . S @GL@(RTN,TAG,I)=LN                               ; Record line
-	QUIT
-	;
-ACTLINES(GL)	; [Private] $$ ; Count active lines
-	;
-	N CNT S CNT=0
-	N REF S REF=GL
-	N GLQL S GLQL=$QL(GL)
-	F  S REF=$Q(@REF) Q:REF=""  Q:(GL'=$NA(@REF,GLQL))  D
-	. N REFQL S REFQL=$QL(REF)
-	. N LASTSUB S LASTSUB=$QS(REF,REFQL)
-	. I LASTSUB?1.N S CNT=CNT+1
-	QUIT CNT
-	;
-COVCOV(C,R)	; [Private] - Analyze coverage Cohort vs Result
-	N RTN S RTN=""
-	F  S RTN=$O(@C@(RTN)) Q:RTN=""  D  ; For each routine in cohort set
-	. I '$D(@R@(RTN)) QUIT             ; Not present in result set
-	. N TAG S TAG=""
-	. F  S TAG=$O(@R@(RTN,TAG)) Q:TAG=""  D  ; For each tag in the routine in the result set
-	. . N LN S LN=""
-	. . F  S LN=$O(@R@(RTN,TAG,LN)) Q:LN=""  D  ; for each line in the tag in the routine in the result set
-	. . . I $D(@C@(RTN,TAG,LN)) K ^(LN)  ; if present in cohort, kill off
-	QUIT
-	;
-COVRPT(C,S,R,V)	; [Private] - Coverage Report
-	; C = COHORT    - Global name
-	; S = SURVIVORS - Global name
-	; R = RESULT    - Global name
-	; V = Verbosity - Scalar from -1 to 3
-	N ORIGLINES S ORIGLINES=$$ACTLINES(C)
-	N LEFTLINES S LEFTLINES=$$ACTLINES(S)
-	W !!
-	W "ORIG: "_ORIGLINES,!
-	W "LEFT: "_LEFTLINES,!
-	W "COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00),!
-	W !!
-	W "BY ROUTINE:",!
-	I V=0 QUIT  ; No verbosity. Don't print routine detail
-	N RTN S RTN=""
-	F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
-	. N O S O=$$ACTLINES($NA(@C@(RTN)))
-	. N L S L=$$ACTLINES($NA(@S@(RTN)))
-	. W ?3,RTN,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
-	. I V=1 QUIT  ; Just print the routine coverage for V=1
-	. N TAG S TAG=""
-	. F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
-	. . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
-	. . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
-	. . W ?5,TAG,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
-	. . I V=2 QUIT  ; Just print routine/tags coverage for V=2; V=3 print uncovered lines
-	. . N LN S LN=""
-	. . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  W TAG_"+"_LN_": "_^(LN),!
-	QUIT
-	;
-COVRPTGL(C,S,R,OUT)	; [Private] - Coverage Global for silent invokers
-	; C = COHORT    - Global name
-	; S = SURVIVORS - Global name
-	; R = RESULT    - Global name
-	; OUT = OUTPUT  - Global name
-	;
-	N O S O=$$ACTLINES(C)
-	N L S L=$$ACTLINES(S)
-	S @OUT=(O-L)_"/"_O
-	N RTN,TAG,LN S (RTN,TAG,LN)=""
-	F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
-	. N O S O=$$ACTLINES($NA(@C@(RTN)))
-	. N L S L=$$ACTLINES($NA(@S@(RTN)))
-	. S @OUT@(RTN)=(O-L)_"/"_O
-	. F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
-	. . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
-	. . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
-	. . S @OUT@(RTN,TAG)=(O-L)_"/"_O
-	. . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  S @OUT@(RTN,TAG,LN)=@S@(RTN,TAG,LN)
-	QUIT
-	;
-TESTCOVR	; entry under coverage analysis
-	D ENTRY^%uttcovr ; does analysis while running various unit tests
-	Q
-	;
+%ut1 ;VEN/SMH/JLI - CONTINUATION OF M-UNIT PROCESSING ;09/10/14  14:27
+ ;;0.1;MASH UTILITIES;;
+ ;
+ ;following is original header from XTMUNIT1 in unreleased patch XT*7.3*81 VA code
+ ;XTMUNIT1    ;JLI/FO-OAK-CONTINUATION OF UNIT TEST ROUTINE ;2014-04-17  5:26 PM
+ ;;7.3;TOOLKIT;**81**;APR 25 1995;Build 24
+ ;
+ ;
+ ; Original by Dr. Joel Ivey
+ ; Major contributions by Dr. Sam Habiel
+ ;
+ ; Changes:
+ ; 130726 SMH - Moved test collection logic from %utUNIT to here (multiple places)
+ ; 131218 SMH - dependence on XLFSTR removed
+ ; 131218 SMH - CHEKTEST refactored to use $TEXT instead of ^%ZOSF("LOAD")
+ ; 131218 SMH - CATCHERR now nulls out $ZS if on GT.M
+ ;
+ Q
+ ;
+CHEKTEST(%utROU,%ut,%utUETRY) ; Collect Test list.
+ ; %utROU - input - Name of routine to check for tags with @TEST attribute
+ ; %ut - input/output - passed by reference
+ ; %utUETRY - input/output - passed by reference
+ ;
+ ; Test list collected in two ways:
+ ; - @TEST on labellines
+ ; - Offsets of XTENT
+ ;
+ S %ut("ENTN")=0 ; Number of test, sub to %utUETRY.
+ ;
+ ; This stanza and everything below is for collecting @TEST.
+ ; VEN/SMH - block refactored to use $TEXT instead of ^%ZOSF("LOAD")
+ N I,LIST
+ S I=$L($T(@(U_%utROU))) I I<0 Q "-1^Invalid Routine Name"
+ ; 140731 JLI - the following SMH code is replaced by the code below
+ ; Complexity galore: $TEXT loops through routine
+ ; IF tab or space isn't the first character ($C(9,32)) and line contains @TEST
+ ; Load that line as a testing entry point
+ ; F I=1:1 S LINE=$T(@("+"_I_U_%utROU)) Q:LINE=""  I $C(9,32)'[$E(LINE),$$UP(LINE)["@TEST" D
+ ; . N TAGNAME,CHAR,NPAREN S TAGNAME="",NPAREN=0
+ ; . F  Q:LINE=""  S CHAR=$E(LINE),LINE=$E(LINE,2,999) Q:CHAR=""  Q:" ("[CHAR  S TAGNAME=TAGNAME_CHAR
+ ; . ; should be no paren or arguments
+ ; . I CHAR="(" Q
+ ; . F  Q:LINE=""  S CHAR=$E(LINE) Q:" ;"'[CHAR  S LINE=$E(LINE,2,999)
+ ; . I $$UP($E(LINE,1,5))="@TEST" S LINE=$E(LINE,6,999) D
+ ; . . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=TAGNAME
+ ; . . F  Q:LINE=""  S CHAR=$E(LINE) Q:CHAR?1AN  S LINE=$E(LINE,2,999)
+ ; . . S %utUETRY(%ut("ENTN"),"NAME")=LINE
+ ; JLI 140731 - end of code replaced by following code
+ ; JLI 140731 - the following code replaces the code above
+ D NEWSTYLE(.LIST,%utROU)
+ 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)
+ ; JLI 140731 - end of replacement code
+ ;
+ ;
+ ; This Stanza is to collect XTENT offsets
+ N %utUI F %utUI=1:1 S %ut("ELIN")=$T(@("XTENT+"_%utUI_"^"_%utROU)) Q:$P(%ut("ELIN"),";",3)=""  D
+ . S %ut("ENTN")=%ut("ENTN")+1,%utUETRY(%ut("ENTN"))=$P(%ut("ELIN"),";",3),%utUETRY(%ut("ENTN"),"NAME")=$P(%ut("ELIN"),";",4)
+ . Q
+ ;
+ QUIT
+ ;
+ ; VEN/SMH 26JUL2013 - Moved GETTREE here.
+GETTREE(%utROU,%utULIST) ;
+ ; first get any other routines this one references for running subsequently
+ ; then any that they refer to as well
+ ; this builds a tree of all routines referred to by any routine including each only once
+ N %utUK,%utUI,%utUJ,%utURNAM,%utURLIN
+ F %utUK=1:1 Q:'$D(%utROU(%utUK))  D
+ . F %utUI=1:1 S %utURLIN=$T(@("XTROU+"_%utUI_"^"_%utROU(%utUK))) S %utURNAM=$P(%utURLIN,";",3) Q:%utURNAM=""  D
+ . . F %utUJ=1:1:%utULIST I %utROU(%utUJ)=%utURNAM S %utURNAM="" Q
+ . . I %utURNAM'="",$T(@("+1^"_%utURNAM))="" W:'$D(XWBOS) "Referenced routine ",%utURNAM," not found.",! Q
+ . . S:%utURNAM'="" %utULIST=%utULIST+1,%utROU(%utULIST)=%utURNAM
+ QUIT
+ ;
+NEWSTYLE(LIST,ROUNAME) ; JLI 140726 identify and return list of newstyle tags or entries for this routine
+ ; LIST - input, passed by reference - returns containing array with list of tags identified as tests
+ ;                   LIST indicates number of tags identified, LIST(n)=tag^test_info where tag is entry point for test
+ ; ROUNAME - input - routine name in which tests should be identified
+ ;
+ N I,VALUE,LINE
+ K LIST S LIST=0
+ ; search routine by line for a tag and @TEST declaration
+ F I=1:1 S LINE=$T(@("+"_I_"^"_ROUNAME)) Q:LINE=""  S VALUE=$$CHECKTAG(LINE) I VALUE'="" S LIST=LIST+1,LIST(LIST)=VALUE
+ Q
+ ;
+CHECKTAG(LINE) ; JLI 140726 check line to determine @test TAG
+ ; LINE - input - Line of code to be checked
+ ; returns null line if not @TEST line, otherwise TAG^NOTE
+ N TAG,NOTE,CHAR
+ I $E(LINE)=" " Q "" ; test entry must have a tag
+ I $$UP(LINE)'["@TEST" Q "" ; must have @TEST declaration
+ I $P($$UP(LINE),"@TEST")["(" Q "" ; can't have an argument
+ S TAG=$P(LINE," "),LINE=$P(LINE," ",2,400),NOTE=$P($$UP(LINE),"@TEST"),LINE=$E(LINE,$L(NOTE)+5+1,$L(LINE))
+ F  Q:NOTE=""  S CHAR=$E(NOTE),NOTE=$E(NOTE,2,$L(NOTE)) I " ;"'[CHAR Q  ;
+ I $L(NOTE)'=0 Q "" ; @TEST must be first text on line
+ F  Q:$E(LINE)'=" "  S LINE=$E(LINE,2,$L(LINE)) ; remove leading spaces from test info
+ S TAG=TAG_U_LINE
+ Q TAG
+ ;
+ ; VEN/SMH 17DEC2013 - Remove dependence on VISTA - Uppercase here instead of XLFSTR.
+UP(X) ;
+ Q $TR(X,"abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+ ;
+COV(NMSP,COVCODE,VERBOSITY) ; VEN/SMH - PUBLIC ENTRY POINT; Coverage calculations
+ ; NMSP: Namespace of the routines to analyze. End with * to include all routines.
+ ;       Not using * will only include the routine with NMSP name.
+ ;       e.g. PSOM* will include all routines starting with PSOM
+ ;            PSOM will only include PSOM.
+ ; COVCODE: Mumps code to run over which coverage will be calculated. Typically Unit Tests.
+ ; VERBOSITY (optional): Scalar from -1 to 3.
+ ;    - -1 = Global output in ^TMP("%utCOVREPORT",$J)
+ ;    - 0 = Print only total coverage
+ ;    - 1 = Break down by routine
+ ;    - 2 = Break down by routine and tag
+ ;    - 3 = Break down by routine and tag, and print lines that didn't execute for each tag.
+ ;
+ Q:'(+$SY=47)  ; GT.M only!
+ ;
+ ; ZEXCEPT: CTRAP - not really a variable
+ S VERBOSITY=+$G(VERBOSITY) ; Get 0 if not passed.
+ N %ZR ; GT.M specific
+ D SILENT^%RSEL(NMSP,"SRC") ; GT.M specific. On Cache use $O(^$R(RTN)).
+ ;
+ N RN S RN=""
+ W "Loading routines to test coverage...",!
+ F  S RN=$O(%ZR(RN)) Q:RN=""  W RN," " D
+ . N L2 S L2=$T(+2^@RN)
+ . S L2=$TR(L2,$C(9,32)) ; Translate spaces and tabs out
+ . I $E(L2,1,2)'=";;" K %ZR(RN)  ; Not a human produced routine
+ ;
+ N RTNS M RTNS=%ZR
+ K %ZR
+ ;
+ N GL
+ S GL=$NA(^TMP("%utCOVCOHORT",$J))
+ K @GL
+ D RTNANAL(.RTNS,GL)
+ K ^TMP("%utCOVCOHORTSAV",$J)
+ M ^TMP("%utCOVCOHORTSAV",$J)=^TMP("%utCOVCOHORT",$J)
+ ;
+ ;
+ K ^TMP("%utCOVRESULT",$J)
+ VIEW "TRACE":1:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M START PROFILING
+ DO  ; Run the code, but keep our variables to ourselves.
+ . NEW $ETRAP,$ESTACK
+ . SET $ETRAP="Q:($ES&$Q) -9 Q:$ES  W ""CTRL-C ENTERED"""
+ . USE $PRINCIPAL:(CTRAP=$C(3))
+ . NEW (DUZ,IO,COVCODE,U,DILOCKTM,DISYS,DT,DTIME,IOBS,IOF,IOM,ION,IOS,IOSL,IOST,IOT,IOXY)
+ . XECUTE COVCODE
+ VIEW "TRACE":0:$NA(^TMP("%utCOVRESULT",$J))  ; GT.M STOP PROFILING
+ ;
+ D COVCOV($NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J))) ; Venn diagram matching between globals
+ ;
+ ; Report
+ I VERBOSITY=-1 D
+ . K ^TMP("%utCOVREPORT",$J)
+ . D COVRPTGL($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),$NA(^TMP("%utCOVREPORT",$J)))
+ E  D COVRPT($NA(^TMP("%utCOVCOHORTSAV",$J)),$NA(^TMP("%utCOVCOHORT",$J)),$NA(^TMP("%utCOVRESULT",$J)),VERBOSITY)
+ ;
+ QUIT
+ ;
+RTNANAL(RTNS,GL) ; [Private] - Routine Analysis
+ ; Create a global similar to the trace global produced by GT.M in GL
+ ; Only non-comment lines are stored.
+ ; A tag is always stored. Tag,0 is stored only if there is code on the tag line (format list or actual code).
+ ; tags by themselves don't count toward the total.
+ ;
+ N RTN S RTN=""
+ F  S RTN=$O(RTNS(RTN)) Q:RTN=""  D                       ; for each routine
+ . N TAG
+ . S TAG=RTN                                              ; start the tags at the first
+ . 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)
+ . . I $E(LN)?1A D  QUIT                                  ; formal line
+ . . . N T                                                ; Terminator
+ . . . N J F J=1:1:$L(LN) S T=$E(LN,J) Q:T'?1AN           ; Loop to...
+ . . . S TAG=$E(LN,1,J-1)                                 ; Get tag
+ . . . S @GL@(RTN,TAG)=TAG                                ; store line
+ . . . I T="(" S @GL@(RTN,TAG,0)=LN                       ; formal list
+ . . . E  D                                               ; No formal list
+ . . . . N LNTR S LNTR=$P(LN,TAG,2,999),LNTR=$TR(LNTR,$C(9,32)) ; Get rest of line, Remove spaces and tabs
+ . . . . I $E(LNTR)=";" QUIT                              ; Comment
+ . . . . S @GL@(RTN,TAG,0)=LN                             ; Otherwise, store for testing
+ . . . S I=0                                              ; Start offsets from zero (first one at the for will be 1)
+ . . I $C(32,9)[$E(LN) D  QUIT                            ; Regular line
+ . . . N LNTR S LNTR=$TR(LN,$C(32,9))                     ; Remove all spaces and tabs
+ . . . I $E(LNTR)=";" QUIT                                ; Comment line -- don't want.
+ . . . S @GL@(RTN,TAG,I)=LN                               ; Record line
+ QUIT
+ ;
+ACTLINES(GL) ; [Private] $$ ; Count active lines
+ ;
+ N CNT S CNT=0
+ N REF S REF=GL
+ N GLQL S GLQL=$QL(GL)
+ F  S REF=$Q(@REF) Q:REF=""  Q:(GL'=$NA(@REF,GLQL))  D
+ . N REFQL S REFQL=$QL(REF)
+ . N LASTSUB S LASTSUB=$QS(REF,REFQL)
+ . I LASTSUB?1.N S CNT=CNT+1
+ QUIT CNT
+ ;
+COVCOV(C,R) ; [Private] - Analyze coverage Cohort vs Result
+ N RTN S RTN=""
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D  ; For each routine in cohort set
+ . I '$D(@R@(RTN)) QUIT             ; Not present in result set
+ . N TAG S TAG=""
+ . F  S TAG=$O(@R@(RTN,TAG)) Q:TAG=""  D  ; For each tag in the routine in the result set
+ . . N LN S LN=""
+ . . F  S LN=$O(@R@(RTN,TAG,LN)) Q:LN=""  D  ; for each line in the tag in the routine in the result set
+ . . . I $D(@C@(RTN,TAG,LN)) K ^(LN)  ; if present in cohort, kill off
+ QUIT
+ ;
+COVRPT(C,S,R,V) ; [Private] - Coverage Report
+ ; C = COHORT    - Global name
+ ; S = SURVIVORS - Global name
+ ; R = RESULT    - Global name
+ ; V = Verbosity - Scalar from -1 to 3
+ N ORIGLINES S ORIGLINES=$$ACTLINES(C)
+ N LEFTLINES S LEFTLINES=$$ACTLINES(S)
+ W !!
+ W "ORIG: "_ORIGLINES,!
+ W "LEFT: "_LEFTLINES,!
+ W "COVERAGE PERCENTAGE: "_$S(ORIGLINES:$J(ORIGLINES-LEFTLINES/ORIGLINES*100,"",2),1:100.00),!
+ W !!
+ W "BY ROUTINE:",!
+ I V=0 QUIT  ; No verbosity. Don't print routine detail
+ N RTN S RTN=""
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
+ . N O S O=$$ACTLINES($NA(@C@(RTN)))
+ . N L S L=$$ACTLINES($NA(@S@(RTN)))
+ . W ?3,RTN,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+ . I V=1 QUIT  ; Just print the routine coverage for V=1
+ . N TAG S TAG=""
+ . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
+ . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
+ . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
+ . . W ?5,TAG,?21,$S(O:$J(O-L/O*100,"",2),1:"100.00"),!
+ . . I V=2 QUIT  ; Just print routine/tags coverage for V=2; V=3 print uncovered lines
+ . . N LN S LN=""
+ . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  W TAG_"+"_LN_": "_^(LN),!
+ QUIT
+ ;
+COVRPTGL(C,S,R,OUT) ; [Private] - Coverage Global for silent invokers
+ ; C = COHORT    - Global name
+ ; S = SURVIVORS - Global name
+ ; R = RESULT    - Global name
+ ; OUT = OUTPUT  - Global name
+ ;
+ N O S O=$$ACTLINES(C)
+ N L S L=$$ACTLINES(S)
+ S @OUT=(O-L)_"/"_O
+ N RTN,TAG,LN S (RTN,TAG,LN)=""
+ F  S RTN=$O(@C@(RTN)) Q:RTN=""  D
+ . N O S O=$$ACTLINES($NA(@C@(RTN)))
+ . N L S L=$$ACTLINES($NA(@S@(RTN)))
+ . S @OUT@(RTN)=(O-L)_"/"_O
+ . F  S TAG=$O(@C@(RTN,TAG)) Q:TAG=""  D
+ . . N O S O=$$ACTLINES($NA(@C@(RTN,TAG)))
+ . . N L S L=$$ACTLINES($NA(@S@(RTN,TAG)))
+ . . S @OUT@(RTN,TAG)=(O-L)_"/"_O
+ . . F  S LN=$O(@S@(RTN,TAG,LN)) Q:LN=""  S @OUT@(RTN,TAG,LN)=@S@(RTN,TAG,LN)
+ QUIT
+ ;
+TESTCOVR ; entry under coverage analysis
+ D ENTRY^%uttcovr ; does analysis while running various unit tests
+ Q
+ ;
diff --git a/Routines/%utcover.m b/Routines/%utcover.m
new file mode 100644
index 0000000..245cb1f
--- /dev/null
+++ b/Routines/%utcover.m
@@ -0,0 +1,138 @@
+%utcover	;JLI - generic coverage and unit test runner ;07/02/15  09:56
+	;;1.0;MASH UTILITIES;;
+	;
+	Q
+	;
+TESTONLY(TESTROUS)	; RUN TESTS FOR SPECIFIED ROUTINES
+	; input TESTROUS - passed by reference - array of routine names to run tests for
+	;               specify those to be called directly by including ^ as part of
+	;               TAG^ROUTINE or ^ROUTINE.
+	;               ROUTINE names without a ^ will be called as EN^%ut("ROUTINE")
+	;               Sometimes to get complete coverage, different entry points may
+	;               need to be called (e.g., at top and for VERBOSE), these should each
+	;               be included.
+	;               If the subscript is a number, it will take the list of comma separated
+	;               values as the routines.  If the the subscript is not a number, it will
+	;               take it as a routine to be added to the list, then if the value of the
+	;               contains a comma separated list of routines, they will be added as well.
+	;               Thus a value of
+	;                 TESTROUS(1)="A^ROU1,^ROU1,^ROU2,ROU3"
+	;               or a value of
+	;                 TESTROUS("A^ROU1")="^ROU1,^ROU2,ROU3"
+	;               will both result in tests for
+	;                 D A^ROU1,^ROU1,^ROU2,EN^%ut("ROU3")
+	K ^TMP("%utCOVER",$J,"TESTROUS")
+	M ^TMP("%utCOVER",$J,"TESTROUS")=TESTROUS
+	;
+COVENTRY	; setup of COVERAGE NEWs most variables, so TESTROUS passed by global
+	;
+	N I,ROU,VAL,VALS,UTDATA,TESTS,TESTROUS
+	M TESTROUS=^TMP("%utCOVER",$J,"TESTROUS")
+	S ROU="" F  S ROU=$O(TESTROUS(ROU)) Q:ROU=""  D
+	. I ROU'=+ROU S TESTS(ROU)=""
+	. F I=1:1 S VAL=$P(TESTROUS(ROU),",",I) Q:VAL=""  S TESTS(VAL)=""
+	. Q
+	S ROU="" F  S ROU=$O(TESTS(ROU)) Q:ROU=""  D
+	. W !!,"RUNNING ",ROU
+	. I ROU[U D @ROU
+	. I ROU'[U D @("EN^%ut("""_ROU_""")")
+	. S VALS=$G(^TMP("%ut",$J,"UTVALS")) I VALS="" Q
+	. F I=1:1 S VAL=$P(VALS,U,I) Q:VAL=""  S UTDATA(I)=$G(UTDATA(I))+VAL
+	. K ^TMP("%ut",$J,"UTVALS")
+	. Q
+	I $D(UTDATA) D
+	. W !!!,"------------ SUMMARY ------------"
+	. W !,"Ran ",UTDATA(1)," Routine",$S(UTDATA(1)>1:"s",1:""),", ",UTDATA(2)," Entry Tag",$S(UTDATA(2)>1:"s",1:"")
+	. 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:""),"."
+	. Q
+	K ^TMP("%utCOVER",$J,"TESTROUS")
+	Q
+	;
+COVERAGE(ROUNMSP,TESTROUS,XCLDROUS,RESLTLVL)	; run coverage analysis
+	; input ROUNMSP - Namespace for routine(s) to be analyzed
+	;                 ROUNAME will result in only the routine ROUNAME being analyzed
+	;                 ROUN* will result in all routines beginning with ROUN being analyzed
+	; input TESTROUS - passed by reference - see TESTROUS description for JUSTTEST
+	; input XCLDROUS - passed by reference - routines passed in a manner similar to TESTROUS,
+	;                  but only the routine names, whether as arguments or a comma separated
+	;                  list of routines, will be excluded from the analysis of coverage.  These
+	;                  would normally be names of routines which are only for unit tests, or
+	;                  others which should not be included in the analysis for some reason.
+	; input RESLTLVL - This value determines the amount of information to be generated for the
+	;                  analysis.  A missing or null value will be considered to be level 1
+	;                     1  -  Listing of analysis only for routine overall
+	;                     2  -  Listing of analysis for routine overall and for each TAG
+	;                     3  -  Full analysis for each tag, and lists out those lines which were
+	;                           not executed during the analysis
+	;
+	N I,ROU,TYPE,VAL,XCLUDE
+	S RESLTLVL=$G(RESLTLVL,1)
+	I RESLTLVL<1 S RESLTLVL=1
+	I RESLTLVL>3 S RESLTLVL=3
+	M ^TMP("%utCOVER",$J,"TESTROUS")=TESTROUS ;
+	D COV^%ut(ROUNMSP,"D COVENTRY^%utCOVER",-1)
+	K ^TMP("%utCOVER",$J,"TESTROUS")
+	S ROU="" F  S ROU=$O(XCLDROUS(ROU)) Q:ROU=""  D
+	. I ROU'=+ROU S XCLUDE(ROU)=""
+	. F I=1:1 S VAL=$P(XCLDROUS(ROU),",",I) Q:VAL=""  S XCLUDE(VAL)=""
+	. Q
+	D LIST(.XCLUDE,RESLTLVL)
+	Q
+	;
+LIST(XCLDROUS,TYPE)	;
+	; ZEXCEPT: TYPE1  - NEWed and set below for recursion
+	; input - ROULIST - a comma separated list of routine names that will
+	;       be used to identify desired routines.  Any name
+	;       that begins with one of the specified values will
+	;       be included
+	; input - TYPE - value indicating amount of detail desired
+	;       1=summary with listing by routine
+	;       2=moderate with listing by tags
+	;       3=full with listing of untouched lines
+	;
+	N CURRCOV,CURRLIN,LINCOV,LINE,LINTOT,ROULIST,ROUNAME,TAG,TOTCOV,TOTLIN,XVAL
+	;
+	D TRIMDATA(.XCLDROUS) ; remove undesired routines from data
+	;
+	N JOB,NAME,BASE,GLOB
+	S GLOB=$NA(^TMP("%utCOVREPORT",$J))
+	S TOTCOV=0,TOTLIN=0
+	; F NAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
+	I TYPE>1 S ROUNAME="" F  S ROUNAME=$O(@GLOB@(ROUNAME)) Q:ROUNAME=""  S XVAL=^(ROUNAME) D
+	. S CURRCOV=$P(XVAL,"/"),CURRLIN=$P(XVAL,"/",2)
+	. W !!,"Routine ",ROUNAME,"   ",CURRCOV," out of ",CURRLIN," lines covered"
+	. I CURRLIN>0 W "  (",$P((100*CURRCOV)/CURRLIN,"."),"%)"
+	. I TYPE=2 W "  - Summary"
+	. S TAG="" F  S TAG=$O(@GLOB@(ROUNAME,TAG)) Q:TAG=""  S XVAL=^(TAG) D
+	. . S LINCOV=$P(XVAL,"/"),LINTOT=$P(XVAL,"/",2)
+	. . W !," Tag ",TAG,"^",ROUNAME,"   ",LINCOV," out of ",LINTOT," lines covered"
+	. . I TYPE=2 Q
+	. . I LINCOV=LINTOT Q
+	. . W !,"   the following is a list of lines NOT covered"
+	. . S LINE="" F  S LINE=$O(@GLOB@(ROUNAME,TAG,LINE)) Q:LINE=""  D
+	. . . I LINE=0 W !,"   ",TAG,"  ",@GLOB@(ROUNAME,TAG,LINE) Q
+	. . . W !,"   ",TAG,"+",LINE,"  ",@GLOB@(ROUNAME,TAG,LINE)
+	. . . Q
+	. . Q
+	. Q
+	; for type=3 generate a summary at bottom after detail
+	I TYPE=3 N TYPE1 S TYPE1=2 D LIST(.XCLDROUS,2) K TYPE1
+	I TYPE=2,$G(TYPE1) Q  ; CAME IN FROM ABOVE LINE
+	; summarize by just routine name
+	W !!
+	S ROUNAME="" F  S ROUNAME=$O(@GLOB@(ROUNAME)) Q:ROUNAME=""  S XVAL=^(ROUNAME) D
+	. S CURRCOV=$P(XVAL,"/"),CURRLIN=$P(XVAL,"/",2)
+	. S TOTCOV=TOTCOV+CURRCOV,TOTLIN=TOTLIN+CURRLIN
+	. W !,"Routine ",ROUNAME,"   ",CURRCOV," out of ",CURRLIN," lines covered"
+	. I CURRLIN>0 W "  (",$P((100*CURRCOV)/CURRLIN,"."),"%)"
+	W !!,"Overall Analysis ",TOTCOV," out of ",TOTLIN," lines covered"
+	I TOTLIN>0 W " (",$P((100*TOTCOV)/TOTLIN,"."),"% coverage)"
+	Q
+	;
+TRIMDATA(ROULIST)	;
+	N TYPNAME,ROUNAME
+	F TYPNAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
+	. S ROUNAME="" F  S ROUNAME=$O(ROULIST(ROUNAME)) Q:ROUNAME=""  K ^TMP(TYPNAME,$J,ROUNAME)
+	. Q
+	Q
+	;
diff --git a/Routines/%utt1.m b/Routines/%utt1.m
index faa5d59..0da83a8 100644
--- a/Routines/%utt1.m
+++ b/Routines/%utt1.m
@@ -1,149 +1,150 @@
-%utt1	; VEN/SMH - Testing routines for M-Unit;08/28/14  11:42
-	;;0.1;MASH UTILITIES;
-%utNITT	; VEN/SMH - Testing routines for M-Unit;2014-04-01  2:04 PM
-	;
-	; THIS ROUTINE IS THE UNIFIED UNIT TESTER FOR ALL OF M-UNIT.
-	;
-	; Dear Users,
-	;
-	; I know about about the irony of a test suite for the testing suite,
-	; so stop snikering. Aside from that, it's actually going to be hard.
-	;
-	; Truly yours,
-	;
-	; Sam H
-	;
-	D EN^%ut($T(+0),1) ; Run tests here, be verbose.
-	QUIT
-	;
-STARTUP	; M-Unit Start-Up - This runs before anything else.
-	S ^TMP($J,"%ut","STARTUP")=""
-	S KBANCOUNT=1
-	QUIT
-	;
-SHUTDOWN	; M-Unit Shutdown - This runs after everything else is done.
-	K ^TMP($J,"%ut","STARTUP")
-	K KBANCOUNT
-	QUIT
-	;
-	;
-	;
-SETUP	; This runs before every test.
-	S KBANCOUNT=KBANCOUNT+1
-	QUIT
-	;
-TEARDOWN	; This runs after every test
-	S KBANCOUNT=KBANCOUNT-1
-	QUIT
-	;
-	;
-	;
-T1	; @TEST - Make sure Start-up Ran
-	D CHKTF($D(^TMP($J,"%ut","STARTUP")),"Start-up node on ^TMP must exist")
-	QUIT
-	;
-T2	; @TEST - Make sure Set-up runs
-	D CHKEQ(KBANCOUNT,2,"KBANCount not incremented properly at SETUP")
-	QUIT
-	;
-T3	; @TEST - Make sure Teardown runs
-	D CHKEQ(KBANCOUNT,2,"KBANCount not decremented properly at TEARDOWN")
-	QUIT
-	;
-T4	; Specified in XTMTAG
-	; 140731 JLI - note that this will fail when run from the GUI runner, since it calls each tag separately
-	I $G(%utGUI) D CHKEQ(%utETRY,"T4","T4 should be the value for %utETRY in the GUI Runner")
-	I '$G(%utGUI) D CHKEQ(%utETRY(4),"T4","T4 should be the collected as the fourth entry in %utETRY")
-	QUIT
-	;
-T5	; ditto
-	D CHKTF(0,"This is an intentional failure.")
-	D CHKEQ(%ut("FAIL"),1,"By this point, we should have failed one test")
-	D FAIL^%ut("Intentionally throwing a failure")
-	D CHKEQ(%ut("FAIL"),2,"By this point, we should have failed two tests")
-	; S %ut("FAIL")=0 ; Okay... Boy's and Girls... as the developer I can do that.
-	QUIT
-	;
-T6	; ditto
-	N TESTCOUNT S TESTCOUNT=%ut("CHK")
-	D SUCCEED^%ut
-	D SUCCEED^%ut
-	D CHKEQ(%ut("CHK"),TESTCOUNT+2,"Succeed should increment the number of tests")
-	QUIT
-	;
-T7	; Make sure we write to principal even though we are on another device
-	; This is a rather difficult test to carry out for GT.M and Cache...
-	N D
-	I +$SY=47 S D="/tmp/test.txt" ; All GT.M ; VMS not supported.
-	I +$SY=0 D  ; All Cache
-	. I $ZVERSION(1)=2 S D=$SYSTEM.Util.GetEnviron("temp")_"\test.txt" I 1 ; Windows
-	. E  S D="/tmp/test.txt" ; not windows; VMS not supported.
-	I +$SY=0 O D:"NWS" ; Cache new file
-	I +$SY=47 O D:(newversion) ; GT.M new file
-	U D
-	WRITE "HELLO",!
-	WRITE "HELLO",!
-	C D
-	;
-	; Now open back the file, and read the hello, but open in read only so
-	; M-Unit will error out if it will write something out there.
-	;
-	; Per VISTA conventions, current IO device should be IO, old is IO(0).
-	;
-	I +$SY=0 O D:"R"
-	I +$SY=47 O D:(readonly)
-	U D
-	N X READ X:1
-	D CHKTF(X="HELLO")  ; This should write to the screen the dot not to the file.
-	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.
-	I +$SY=0 C D:"D"
-	I +$SY=47 C D:(delete)
-	U $P
-	S IO=$IO
-	QUIT
-	;
-	; At the moment T8^%utt1 throws a fail, with no message
-	; in the GUI runner.  For some reason, both X and Y
-	; variables are returned as null strings, while in the
-	; command line runner, Y has a value containing the
-	; word being sought
-	;
-T8	; If IO starts with another device, write to that device as if it's the pricipal device
-	N D
-	I +$SY=47 S D="/tmp/test.txt" ; All GT.M ; VMS not supported.
-	I +$SY=0 D  ; All Cache
-	. I $ZVERSION(1)=2 S D=$SYSTEM.Util.GetEnviron("temp")_"\test.txt" I 1 ; Windows
-	. E  S D="/tmp/test.txt" ; not windows; VMS not supported.
-	I +$SY=0 O D:"NWS" ; Cache new file
-	I +$SY=47 O D:(newversion) ; GT.M new file
-	S IO=D
-	U D
-	D ^%utt4 ; Run some Unit Tests
-	C D
-	I +$SY=0 O D:"R" ; Cache read only
-	I +$SY=47 O D:(readonly) ; GT.M read only
-	U D
-	N X,Y R X:1,Y:1
-	I +$SY=0 C D:"D"
-	I +$SY=47 C D:(delete)
-	D CHKTF(Y["MAIN")
-	S IO=$P
-	QUIT
-	;
-LO(X)	Q $TR(X,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")
-	; Shortcut methods for M-Unit
-CHKTF(X,Y)	  D CHKTF^%ut(X,$G(Y))   QUIT
-CHKEQ(A,B,M)	D CHKEQ^%ut(A,B,$G(M)) QUIT
-	;
-XTENT	; Entry points
-	;;T4;Entry point using XTMENT
-	;;T5;Error count check
-	;;T6;Succeed Entry Point
-	;;T7;Make sure we write to principal even though we are on another device
-	;;T8;If IO starts with another device, write to that device as if it's the pricipal device
-	;
-XTROU	; Routines containing additional tests
-	;;%utt2; old %utNITU
-	;;%utt4; old %utNITW
-	;;%utt5;
-	;;%utt6;
+%utt1 ; VEN/SMH - Testing routines for M-Unit;08/29/14  11:35
+ ;;0.1;MASH UTILITIES;;
+%utNITT ; VEN/SMH - Testing routines for M-Unit;2014-04-01  2:04 PM
+ ;
+ ; THIS ROUTINE IS THE UNIFIED UNIT TESTER FOR ALL OF M-UNIT.
+ ;
+ ; Dear Users,
+ ;
+ ; I know about about the irony of a test suite for the testing suite,
+ ; so stop snikering. Aside from that, it's actually going to be hard.
+ ;
+ ; Truly yours,
+ ;
+ ; Sam H
+ ;
+ D EN^%ut($T(+0),1) ; Run tests here, be verbose.
+ QUIT
+ ;
+STARTUP ; M-Unit Start-Up - This runs before anything else.
+ S ^TMP($J,"%ut","STARTUP")=""
+ S KBANCOUNT=1
+ QUIT
+ ;
+SHUTDOWN ; M-Unit Shutdown - This runs after everything else is done.
+ K ^TMP($J,"%ut","STARTUP")
+ K KBANCOUNT
+ QUIT
+ ;
+ ;
+ ;
+SETUP ; This runs before every test.
+ S KBANCOUNT=KBANCOUNT+1
+ QUIT
+ ;
+TEARDOWN ; This runs after every test
+ S KBANCOUNT=KBANCOUNT-1
+ QUIT
+ ;
+ ;
+ ;
+T1 ; @TEST - Make sure Start-up Ran
+ D CHKTF($D(^TMP($J,"%ut","STARTUP")),"Start-up node on ^TMP must exist")
+ QUIT
+ ;
+T2 ; @TEST - Make sure Set-up runs
+ D CHKEQ(KBANCOUNT,2,"KBANCount not incremented properly at SETUP")
+ QUIT
+ ;
+T3 ; @TEST - Make sure Teardown runs
+ D CHKEQ(KBANCOUNT,2,"KBANCount not decremented properly at TEARDOWN")
+ QUIT
+ ;
+T4 ; Specified in XTMTAG
+ ; 140731 JLI - note that this will fail when run from the GUI runner, since it calls each tag separately
+ I $G(%utGUI) D CHKEQ(%utETRY,"T4","T4 should be the value for %utETRY in the GUI Runner")
+ I '$G(%utGUI) D CHKEQ(%utETRY(4),"T4","T4 should be the collected as the fourth entry in %utETRY")
+ QUIT
+ ;
+T5 ; ditto
+ D CHKTF(0,"This is an intentional failure.")
+ D CHKEQ(%ut("FAIL"),1,"By this point, we should have failed one test")
+ D FAIL^%ut("Intentionally throwing a failure")
+ D CHKEQ(%ut("FAIL"),2,"By this point, we should have failed two tests")
+ ; S %ut("FAIL")=0 ; Okay... Boy's and Girls... as the developer I can do that.
+ QUIT
+ ;
+T6 ; ditto
+ N TESTCOUNT S TESTCOUNT=%ut("CHK")
+ D SUCCEED^%ut
+ D SUCCEED^%ut
+ D CHKEQ(%ut("CHK"),TESTCOUNT+2,"Succeed should increment the number of tests")
+ QUIT
+ ;
+T7 ; Make sure we write to principal even though we are on another device
+ ; This is a rather difficult test to carry out for GT.M and Cache...
+ N D
+ I +$SY=47 S D="/tmp/test.txt" ; All GT.M ; VMS not supported.
+ I +$SY=0 D  ; All Cache
+ . I $ZVERSION(1)=2 S D=$SYSTEM.Util.GetEnviron("temp")_"\test.txt" I 1 ; Windows
+ . E  S D="/tmp/test.txt" ; not windows; VMS not supported.
+ I +$SY=0 O D:"NWS" ; Cache new file
+ I +$SY=47 O D:(newversion) ; GT.M new file
+ U D
+ WRITE "HELLO",!
+ WRITE "HELLO",!
+ C D
+ ;
+ ; Now open back the file, and read the hello, but open in read only so
+ ; M-Unit will error out if it will write something out there.
+ ;
+ ; Per VISTA conventions, current IO device should be IO, old is IO(0).
+ ;
+ I +$SY=0 O D:"R"
+ I +$SY=47 O D:(readonly)
+ U D
+ N X READ X:1
+ D CHKTF(X="HELLO")  ; This should write to the screen the dot not to the file.
+ 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.
+ I +$SY=0 C D:"D"
+ I +$SY=47 C D:(delete)
+ U $P
+ S IO=$IO
+ QUIT
+ ;
+ ; At the moment T8^%utt1 throws a fail, with no message
+ ; in the GUI runner.  For some reason, both X and Y
+ ; variables are returned as null strings, while in the
+ ; command line runner, Y has a value containing the
+ ; word being sought
+ ;
+T8 ; If IO starts with another device, write to that device as if it's the pricipal device
+ N D
+ I +$SY=47 S D="/tmp/test.txt" ; All GT.M ; VMS not supported.
+ I +$SY=0 D  ; All Cache
+ . I $ZVERSION(1)=2 S D=$SYSTEM.Util.GetEnviron("temp")_"\test.txt" I 1 ; Windows
+ . E  S D="/tmp/test.txt" ; not windows; VMS not supported.
+ I +$SY=0 O D:"NWS" ; Cache new file
+ I +$SY=47 O D:(newversion) ; GT.M new file
+ S IO=D
+ U D
+ D ^%utt4 ; Run some Unit Tests
+ C D
+ I +$SY=0 O D:"R" ; Cache read only
+ I +$SY=47 O D:(readonly) ; GT.M read only
+ U D
+ N X,Y,Z R X:1,Y:1,Z:1
+ I +$SY=0 C D:"D"
+ I +$SY=47 C D:(delete)
+ ;D CHKTF(Y["MAIN") ; JLI 140829 commented out, gui doesn't run verbose
+ D CHKTF((Y["MAIN")!(Z["Ran 1 Routine"),"Write to system during test didn't work")
+ S IO=$P
+ QUIT
+ ;
+LO(X) Q $TR(X,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")
+ ; Shortcut methods for M-Unit
+CHKTF(X,Y)   D CHKTF^%ut(X,$G(Y))   QUIT
+CHKEQ(A,B,M) D CHKEQ^%ut(A,B,$G(M)) QUIT
+ ;
+XTENT ; Entry points
+ ;;T4;Entry point using XTMENT
+ ;;T5;Error count check
+ ;;T6;Succeed Entry Point
+ ;;T7;Make sure we write to principal even though we are on another device
+ ;;T8;If IO starts with another device, write to that device as if it's the pricipal device
+ ;
+XTROU ; Routines containing additional tests
+ ;;%utt2; old %utNITU
+ ;;%utt4; old %utNITW
+ ;;%utt5;
+ ;;%utt6;
diff --git a/Routines/%utt2.m b/Routines/%utt2.m
index 4b42d24..b2d62ea 100644
--- a/Routines/%utt2.m
+++ b/Routines/%utt2.m
@@ -1,12 +1,12 @@
-%utt2	; VEN/SMH - Bad Ass Continuation of Unit Tests;08/04/14  09:12
-	;;0.1;MASH UTILITIES;
-XTMUNITU	; VEN/SMH - Bad Ass Continuation of Unit Tests;2014-04-01  1:03 PM
-	;
-T11	; @TEST An @TEST Entry point in Another Routine invoked through XTROU offsets
-	D CHKTF^%ut(1)
-	QUIT
-T12	;
-	D CHKTF^%ut(1)
-	QUIT
-XTENT	;
-	;;T12;An XTENT offset entry point in Another Routine invoked through XTROU offsets
+%utt2 ; VEN/SMH - Bad Ass Continuation of Unit Tests;08/04/14  09:12
+ ;;0.1;MASH UTILITIES;;
+XTMUNITU ; VEN/SMH - Bad Ass Continuation of Unit Tests;2014-04-01  1:03 PM
+ ;
+T11 ; @TEST An @TEST Entry point in Another Routine invoked through XTROU offsets
+ D CHKTF^%ut(1)
+ QUIT
+T12 ;
+ D CHKTF^%ut(1)
+ QUIT
+XTENT ;
+ ;;T12;An XTENT offset entry point in Another Routine invoked through XTROU offsets
diff --git a/Routines/%utt3.m b/Routines/%utt3.m
index b55fec1..feb7f35 100644
--- a/Routines/%utt3.m
+++ b/Routines/%utt3.m
@@ -1,43 +1,43 @@
-%utt3	; VEN/SMH - Unit Tests Coverage Tests;08/14/14  14:02
-	;;0.1;MASH UTILITIES;
-XTMUNITV	; VEN/SMH - Unit Tests Coverage Tests;2014-04-16  7:14 PM
-	;
-	; *** BE VERY CAREFUL IN MODIFIYING THIS ROUTINE ***
-	; *** THE UNIT TEST COUNTS ACTIVE AND INACTIVE LINES OF CODE ***
-	; *** IF YOU MODIFY THIS, MODIFY XTMUNITW AS WELL ***
-	;
-	; Coverage tester in %utt4
-	; 20 Lines of code
-	; 5 do not run as they are dead code
-	; Expected Coverage: 15/20 = 75%
-	;
-STARTUP	; Doesn't count
-	N X    ; Counts
-	S X=1  ; Counts
-	QUIT   ; Counts
-	;
-SHUTDOWN	K X,Y QUIT     ; Counts; ZEXCEPT: X,Y
-	;
-SETUP	S Y=$G(Y)+1 QUIT  ; Counts
-	;
-TEARDOWN	; Doesn't count
-	S Y=Y-1 ; Counts
-	QUIT    ; Counts
-	;
-T1	; @TEST Test 1
-	D CHKTF^%ut($D(Y)) ; Counts
-	QUIT                   ; Counts
-	;
-T2	; @TEST Test 2
-	D INTERNAL(1)          ; Counts
-	D CHKTF^%ut(1)     ; Counts
-	QUIT                   ; Counts
-	S X=1                  ; Dead code
-	QUIT                   ; Dead code
-	;
-INTERNAL(A)	; Counts
-	S A=A+1    ; Counts
-	QUIT       ; Counts
-	S A=2      ; Dead code
-	S Y=2      ; Dead code
-	QUIT       ; Dead code
+%utt3 ; VEN/SMH - Unit Tests Coverage Tests;08/14/14  14:02
+ ;;0.1;MASH UTILITIES;;
+XTMUNITV ; VEN/SMH - Unit Tests Coverage Tests;2014-04-16  7:14 PM
+ ;
+ ; *** BE VERY CAREFUL IN MODIFIYING THIS ROUTINE ***
+ ; *** THE UNIT TEST COUNTS ACTIVE AND INACTIVE LINES OF CODE ***
+ ; *** IF YOU MODIFY THIS, MODIFY XTMUNITW AS WELL ***
+ ;
+ ; Coverage tester in %utt4
+ ; 20 Lines of code
+ ; 5 do not run as they are dead code
+ ; Expected Coverage: 15/20 = 75%
+ ;
+STARTUP ; Doesn't count
+ N X    ; Counts
+ S X=1  ; Counts
+ QUIT   ; Counts
+ ;
+SHUTDOWN K X,Y QUIT     ; Counts; ZEXCEPT: X,Y
+ ;
+SETUP S Y=$G(Y)+1 QUIT  ; Counts
+ ;
+TEARDOWN ; Doesn't count
+ S Y=Y-1 ; Counts
+ QUIT    ; Counts
+ ;
+T1 ; @TEST Test 1
+ D CHKTF^%ut($D(Y)) ; Counts
+ QUIT                   ; Counts
+ ;
+T2 ; @TEST Test 2
+ D INTERNAL(1)          ; Counts
+ D CHKTF^%ut(1)     ; Counts
+ QUIT                   ; Counts
+ S X=1                  ; Dead code
+ QUIT                   ; Dead code
+ ;
+INTERNAL(A) ; Counts
+ S A=A+1    ; Counts
+ QUIT       ; Counts
+ S A=2      ; Dead code
+ S Y=2      ; Dead code
+ QUIT       ; Dead code
diff --git a/Routines/%utt4.m b/Routines/%utt4.m
index 5ee6712..9dec328 100644
--- a/Routines/%utt4.m
+++ b/Routines/%utt4.m
@@ -1,22 +1,21 @@
-%utt4	; VEN/SMH - Coverage Test Runner;2014-08-28  8:37 PM
-	;;0.1;MASH UTILITIES;
-XTMUNITW	; VEN/SMH - Coverage Test Runner;2014-04-17  3:30 PM
-	;;7.3;KERNEL TOOLKIT;;
-	;
-	; This tests code in XTMUNITV for coverage
-	D EN^%ut($T(+0),1) QUIT
-	;
-MAIN	; @TEST - Test coverage calculations
-	Q:$D(^TMP("%uttcovr",$J))  ; already running coverage analysis from %uttcovr
-	Q:$$ISUTEST^%ut  ; already running a unit test
-        Q:'(+$SY=47)  ; GT.M ONLY
-	;D COV^%ut1("XTMUNITV","D EN^%ut(""XTMUNITV"",1)",-1)  ; Only produce output global.
-	D COV^%ut1("%utt3","D EN^%ut(""%utt3"",1)",-1)  ; Only produce output global.
-	D CHKEQ^%ut(^TMP("%utCOVREPORT",$J),"15/20")
-	;D CHKEQ^%ut(^TMP("XTMCOVREPORT",$J,"XTMUNITV","INTERNAL"),"3/6")
-	D CHKEQ^%ut(^TMP("%utCOVREPORT",$J,"%utt3","INTERNAL"),"3/6")
-	;D CHKTF^%ut($D(^TMP("XTMCOVREPORT",$J,"XTMUNITV","T2",4)))
-	D CHKTF^%ut($D(^TMP("%utCOVREPORT",$J,"%utt3","T2",4)))
-	;D CHKEQ^%ut(^TMP("XTMCOVREPORT",$J,"XTMUNITV","SETUP"),"1/1")
-	D CHKEQ^%ut(^TMP("%utCOVREPORT",$J,"%utt3","SETUP"),"1/1")
-	QUIT
+%utt4 ; VEN/SMH - Coverage Test Runner;08/23/14  08:33
+ ;;0.1;MASH UTILITIES;;
+XTMUNITW ; VEN/SMH - Coverage Test Runner;2014-04-17  3:30 PM
+ ;;7.3;KERNEL TOOLKIT;;
+ ;
+ ; This tests code in XTMUNITV for coverage
+ D EN^%ut($T(+0),1) QUIT
+ ;
+MAIN ; @TEST - Test coverage calculations
+ Q:$D(^TMP("%uttcovr",$J))  ; already running coverage analysis from %uttcovr
+ Q:'(+$SY=47)  ; GT.M ONLY
+ ;D COV^%ut1("XTMUNITV","D EN^%ut(""XTMUNITV"",1)",-1)  ; Only produce output global.
+ D COV^%ut1("%utt3","D EN^%ut(""%utt3"",1)",-1)  ; Only produce output global.
+ D CHKEQ^%ut(^TMP("%utCOVREPORT",$J),"15/20")
+ ;D CHKEQ^%ut(^TMP("XTMCOVREPORT",$J,"XTMUNITV","INTERNAL"),"3/6")
+ D CHKEQ^%ut(^TMP("%utCOVREPORT",$J,"%utt3","INTERNAL"),"3/6")
+ ;D CHKTF^%ut($D(^TMP("XTMCOVREPORT",$J,"XTMUNITV","T2",4)))
+ D CHKTF^%ut($D(^TMP("%utCOVREPORT",$J,"%utt3","T2",4)))
+ ;D CHKEQ^%ut(^TMP("XTMCOVREPORT",$J,"XTMUNITV","SETUP"),"1/1")
+ D CHKEQ^%ut(^TMP("%utCOVREPORT",$J,"%utt3","SETUP"),"1/1")
+ QUIT
diff --git a/Routines/%utt5.m b/Routines/%utt5.m
index 6978a06..a56a8e8 100644
--- a/Routines/%utt5.m
+++ b/Routines/%utt5.m
@@ -1,123 +1,135 @@
-%utt5	;JLI - test for aspects of MUnit functionality ;08/24/14  21:31
-	;;0.1;MASH UTILITIES;
-	Q
-	;
-OLDSTYLE	;
-	; ZEXCEPT: %ut - Newed in EN^%zu
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %ut("ENT")="OLDSTYLE",%utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"OLDSTYLE")=""
-	D CHKEQ^%ut(5,5,"SET EQUAL ON PURPOSE - OLDSTYLE DONE")
-	D CHKTF^%ut(4=4,"MY EQUAL VALUE")
-	Q
-	;
-OLDSTYL1	;
-	; ZEXCEPT: %ut - Newed in EN^%zu
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %ut("ENT")="OLDSTYL1",%utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"OLDSTYL1")=""
-	D CHKEQ^%ut(4,4,"SET EQUAL ON PURPOSE - OLDSTYL1 DONE")
-	Q
-	;
-NEWSTYLE	; @TEST identify new style test indicator functionality
-	; ZEXCEPT: %ut - Newed in EN^%zu
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %ut("ENT")="NEWSTYLE" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"NEWSTYLE")=""
-	D CHKEQ^%ut(4,4,"SET EQUAL ON PURPOSE - NEWSTYLE DONE")
-	Q
-	;
-BADCHKEQ	;
-	; ZEXCEPT: %ut - Newed in EN^%zu
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %ut("ENT")="BADCHKEQ" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADCHKEQ")=""
-	D CHKEQ^%ut(4,3,"SET UNEQUAL ON PURPOSE - SHOULD FAIL")
-	Q
-	;
-BADCHKTF	;
-	; ZEXCEPT: %ut - Newed in EN^%zu
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %ut("ENT")="BADCHKTF" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADCHKTF")=""
-	D CHKTF^%ut(0,"SET FALSE (0) ON PURPOSE - SHOULD FAIL")
-	Q
-	;
-BADERROR	;
-	; ZEXCEPT: %ut - Newed in EN^%zu
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	N X
-	I $D(%utt6var) S %ut("ENT")="BADERROR" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADERROR")=""
-	; following syntax error is on purpose to throw an error
-	S X= ; syntax error on purpose
-	Q
-	;
-CALLFAIL	;
-	; ZEXCEPT: %ut - Newed in EN^%zu
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	N X
-	I $D(%utt6var) S %ut("ENT")="CALLFAIL" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"CALLFAIL")=""
-	D FAIL^%ut("Called FAIL to test it")
-	Q
-	;
-LEAKSOK	;
-	N CODE,LOCATN,MYVALS,X
-	S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSOK TEST",MYVALS("X")=""
-	D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find no leaks
-	Q
-	;
-LEAKSBAD	;
-	N CODE,LOCATN,MYVALS,X
-	S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSBAD TEST - X NOT SPECIFIED"
-	D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find X since it isn't indicated
-	Q
-	;
-NVLDARG1	;
-	D CHKEQ^%ut(1)
-	Q
-	;
-ISUTEST	;
-	D CHKTF^%ut($$ISUTEST^%ut,"ISUTEST returned FALSE!")
-	Q
-	;
-BADFORM1(X)	; @TEST should not be selected - arguments
-	; ZEXCEPT: %ut - Newed in EN^%zu
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %ut("ENT")="NEWSTYLE" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADFORM1")=""
-	D CHKEQ^%ut(4,3,"SHOULD NOT BE SELECTED - ARGUMENTS - BADFORM1")
-	Q
-	;
-BADFORM2	; ABC @TEST should not be selected - @TEST NOT FIRST
-	; ZEXCEPT: %ut - Newed in EN^%zu
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADFORM2")=""
-	D CHKEQ^%ut(4,3,"SHOULD NOT BE SELECTED - @TEST NOT FIRST - BADFORM2")
-	Q
-	;
-STARTUP	;
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var),$D(^TMP("%utt5",$J)) K ^TMP("%utt5",$J)
-	I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"STARTUP")=""
-	Q
-	;
-SHUTDOWN	;
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"SHUTDOWN")=""
-	Q
-	;
-SETUP	;
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"SETUP")=""
-	Q
-	;
-TEARDOWN	;
-	; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
-	I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"TEARDOWN")=""
-	Q
-	;
-XTENT	;
-	;;OLDSTYLE; identify old style test indicator functionality
-	;;OLDSTYL1; identify old style test indicator 2
-	;;BADCHKEQ; CHKEQ should fail on unequal value
-	;;BADCHKTF; CHKTF should fail on false value
-	;;BADERROR; throws an error on purpose
-	;;CALLFAIL; called FAIL to test it
-	;;LEAKSOK;check leaks should be ok
-	;;LEAKSBAD;check leaks with leak
-	;;NVLDARG1;check invalid arg in CHKEQ
-	;;ISUTEST;check ISUTEST inside unit test
+%utt5 ;JLI - test for aspects of MUnit functionality ;08/29/14  11:23
+ ;;0.1;MASH UTILITIES;;
+ Q
+ ;
+OLDSTYLE ;
+ ; ZEXCEPT: %ut - Newed in EN^%zu
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ I $D(%utt6var) S %ut("ENT")="OLDSTYLE",%utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"OLDSTYLE")=""
+ D CHKEQ^%ut(5,5,"SET EQUAL ON PURPOSE - OLDSTYLE DONE")
+ D CHKTF^%ut(4=4,"MY EQUAL VALUE")
+ Q
+ ;
+OLDSTYL1 ;
+ ; ZEXCEPT: %ut - Newed in EN^%zu
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ I $D(%utt6var) S %ut("ENT")="OLDSTYL1",%utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"OLDSTYL1")=""
+ D CHKEQ^%ut(4,4,"SET EQUAL ON PURPOSE - OLDSTYL1 DONE")
+ Q
+ ;
+NEWSTYLE ; @TEST identify new style test indicator functionality
+ ; ZEXCEPT: %ut - Newed in EN^%zu
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ I $D(%utt6var) S %ut("ENT")="NEWSTYLE" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"NEWSTYLE")=""
+ D CHKEQ^%ut(4,4,"SET EQUAL ON PURPOSE - NEWSTYLE DONE")
+ Q
+ ;
+BADCHKEQ ;
+ ; ZEXCEPT: %ut - Newed in EN^%zu
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ I $D(%utt6var) S %ut("ENT")="BADCHKEQ" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADCHKEQ")=""
+ D CHKEQ^%ut(4,3,"SET UNEQUAL ON PURPOSE - SHOULD FAIL")
+ Q
+ ;
+BADCHKTF ;
+ ; ZEXCEPT: %ut - Newed in EN^%zu
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ I $D(%utt6var) S %ut("ENT")="BADCHKTF" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADCHKTF")=""
+ D CHKTF^%ut(0,"SET FALSE (0) ON PURPOSE - SHOULD FAIL")
+ Q
+ ;
+BADERROR ;
+ ; ZEXCEPT: %ut - Newed in EN^%zu
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ N X
+ I $D(%utt6var) S %ut("ENT")="BADERROR" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADERROR")=""
+ ; following syntax error is on purpose to throw an error
+ S X= ; syntax error on purpose
+ Q
+ ;
+CALLFAIL ;
+ ; ZEXCEPT: %ut - Newed in EN^%zu
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ N X
+ I $D(%utt6var) S %ut("ENT")="CALLFAIL" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"CALLFAIL")=""
+ D FAIL^%ut("Called FAIL to test it")
+ Q
+ ;
+LEAKSOK ;
+ N CODE,LOCATN,MYVALS,X
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSOK TEST",MYVALS("X")=""
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find no leaks
+ Q
+ ;
+LEAKSBAD ;
+ N CODE,LOCATN,MYVALS,X
+ S CODE="S X=$$NOW^XLFDT()",LOCATN="LEAKSBAD TEST - X NOT SPECIFIED"
+ D CHKLEAKS^%ut(CODE,LOCATN,.MYVALS) ; should find X since it isn't indicated
+ Q
+ ;
+NVLDARG1 ;
+ D CHKEQ^%ut(1)
+ Q
+ ;
+ISUTEST ;
+ D CHKTF^%ut($$ISUTEST^%ut,"ISUTEST returned FALSE!")
+ Q
+ ;
+BADFORM1(X) ; @TEST should not be selected - arguments
+ ; ZEXCEPT: %ut - Newed in EN^%zu
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ I $D(%utt6var) S %ut("ENT")="NEWSTYLE" S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADFORM1")=""
+ D CHKEQ^%ut(4,3,"SHOULD NOT BE SELECTED - ARGUMENTS - BADFORM1")
+ Q
+ ;
+BADFORM2 ; ABC @TEST should not be selected - @TEST NOT FIRST
+ ; ZEXCEPT: %ut - Newed in EN^%zu
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"BADFORM2")=""
+ D CHKEQ^%ut(4,3,"SHOULD NOT BE SELECTED - @TEST NOT FIRST - BADFORM2")
+ Q
+ ;
+STARTUP ;
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ; ZEXCEPT: KBANCOUNT created here, killed in SHUTDOWN
+ I $D(%utt6var),$D(^TMP("%utt5",$J)) K ^TMP("%utt5",$J)
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"STARTUP")=""
+ ; following brought from %utt1, since only one STARTUP can RUN in a set
+ I '$D(%utt6var) D
+ . S ^TMP($J,"%ut","STARTUP")=""
+ . S KBANCOUNT=1
+ . Q
+ Q
+ ;
+SHUTDOWN ;
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ ; ZEXCEPT: KBANCOUNT created in STARTUP, killed here
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"SHUTDOWN")=""
+ ; following brought from %utt1, since only one SHUTDOWN can RUN in a set
+ I '$D(%utt6var) D
+ . K ^TMP($J,"%ut","STARTUP")
+ . K KBANCOUNT
+ . Q
+ Q
+ ;
+SETUP ;
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"SETUP")=""
+ Q
+ ;
+TEARDOWN ;
+ ; ZEXCEPT: %utt6cnt,%utt6var - if present, NEWED following top entry of routine %utt6
+ I $D(%utt6var) S %utt6cnt=$G(%utt6cnt)+1,^TMP("%utt5",$J,%utt6cnt,"TEARDOWN")=""
+ Q
+ ;
+XTENT ;
+ ;;OLDSTYLE; identify old style test indicator functionality
+ ;;OLDSTYL1; identify old style test indicator 2
+ ;;BADCHKEQ; CHKEQ should fail on unequal value
+ ;;BADCHKTF; CHKTF should fail on false value
+ ;;BADERROR; throws an error on purpose
+ ;;CALLFAIL; called FAIL to test it
+ ;;LEAKSOK;check leaks should be ok
+ ;;LEAKSBAD;check leaks with leak
+ ;;NVLDARG1;check invalid arg in CHKEQ
+ ;;ISUTEST;check ISUTEST inside unit test
diff --git a/Routines/%utt6.m b/Routines/%utt6.m
index a4aef02..6a7ddc6 100644
--- a/Routines/%utt6.m
+++ b/Routines/%utt6.m
@@ -1,110 +1,112 @@
-%utt6	;JLI - Unit tests for MUnit functionality ;08/28/14  11:52
-	;;0.1;MASH UTILITIES;
-	;
-	; This routine uses ZZUTJLI2 as a test routine, it does not include the routine as an extension,
-	; since it uses it for tests.
-	;
-	; ZZUTJLI2 currently contains 3 tests (2 old style, 1 new style), it also specifies STARTUP and
-	; SHUTDOWN (should be 1 each) and SETUP and TEARDOWN (should be 3 each, 1 for each test) enteries, each of these
-	; creates an entry under the ^TMP("ZZUTJLI2" global node, indicating function then continues the process.
-	; Should be 2+3n entries (1+1 for STARTUP and SHUTDOWN, then 3 for each of the tests (SETUP, test,
-	; and TEARDOWN).
-	;
-	; This first section is more of a functional test, since it checks the full unit test processing from both
-	; a command line and a GUI call approach.  Data for analysis is saved under ^TMP("ZZUTJLI2_C", for command
-	; line and ^TMP("ZZUTJLI2_G", for gui processing.
-	;
-	; The counts for the command line processing are based on the number of unit test tags
-	; determined for the GUI processing as well.  The numbers are 2 (startup and shutdown)
-	;  + 3 x the number of tests present.
-	;
-	; run unit tests by command line
-	N VERBOSE
-	S VERBOSE=0
-VERBOSE	;
-	I '$D(VERBOSE) N VERBOSE S VERBOSE=1
-	N ZZUTCNT,JLICNT,JLIEXPCT,JLII,JLIX,ZZUTRSLT,%utt5,%utt6,%utt6var
-	W !!,"RUNNING COMMAND LINE TESTS VIA DOSET^%ut",!
-	D DOSET^%ut(1,VERBOSE) ; run `1 in M-UNIT TEST GROUP file
-	;
-	W !!!,"Running command line tests by RUNSET^%ut",!
-	D RUNSET^%ut("TESTS FOR UNIT TEST ROUTINES")
-	;
-	; Call GUISET to obtain list of tags via entry in M-UNIT TEST GROUP file
-	; silent to the user
-	D GUISET^%ut(.%utt6,1)
-	K ^TMP("%utt6_GUISET",$J) M ^TMP("%utt6_GUISET",$J)=@%utt6
-	;
-	W !!!,"RUNNING COMMAND LINE UNIT TESTS FOR %utt5",!
-	N ZZUTCNT,JLICNT,JLIEXPCT,JLII,JLIX,ZZUTRSLT
-	S ZZUTCNT=0
-	K ^TMP("%utt5",$J) ; kill any contents of data storage
-	D EN^%ut("%utt5",VERBOSE) ; should do STARTUP(1x), then SETUP, test, TEARDOWN (each together 3x) and SHUTDOWN (1x)
-	K ^TMP("%utt5_C",$J) M ^TMP("%utt5_C",$J)=^TMP("%utt5",$J)
-	;
-	; now run unit tests by GUI - first determines unit test tags
-	W !!!,"RUNNING UNIT TESTS FOR %utt5 VIA GUI CALLS - Silent",!
-	S ZZUTCNT=0
-	K ^TMP("%utt5",$J),^TMP("%utt6",$J)
-	D GUILOAD^%ut(.%utt6,"%utt5")
-	M ^TMP("%utt6",$J)=@%utt6
-	S %utt6=$NA(^TMP("%utt6",$J))
-	; then run each tag separately
-	; JLICNT is count of unit test tags, which can be determined for GUI call for each unit test tag
-	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))
-	; and close it with a null routine name
-	D GUINEXT^%ut(.ZZUTRSLT,"")
-	K ^TMP("%utt5_G",$J) M ^TMP("%utt5_G",$J)=^TMP("%utt5",$J)
-	S JLIEXPCT=2+(3*JLICNT) ; number of lines that should be in the global nodes for command line and GUI
-	;
-	; now run the unit tests in this routine
-	W !!,"NOW RUNNING UNIT TESTS FOR %utt6",!!
-	D EN^%ut("%utt6",VERBOSE)
-	K ^TMP("%utt5",$J),^TMP("%utt5_C",$J),^TMP("%utt5_G",$J),^TMP("%utt6",$J),^TMP("%utt6_GUISET",$J)
-	Q
-	;
-	;
-	;           WARNING     --      WARNING     --      WARNING
-	; If the number of NEW STYLE tests in %utt5 is increased (it is currently 1), then the following
-	; test will need to be updated to reflect the change(s)
-	;     END OF WARNING  --  END OF WARNING  --  END OF WARNING
-	;
-NEWSTYLE	; tests return of valid new style or @TEST indicators
-	N LIST
-	D NEWSTYLE^%ut1(.LIST,"%utt5")
-	D CHKEQ^%ut(LIST,1,"Returned an incorrect number ("_LIST_") of New Style indicators - should be one")
-	I LIST>0 D CHKEQ^%ut(LIST(1),"NEWSTYLE^identify new style test indicator functionality","Returned incorrect TAG^reason "_LIST(1))
-	I LIST>0 D CHKEQ^%ut($G(LIST(2)),"","Returned a value for LIST(2) - should not have any value (i.e., null)")
-	Q
-	;
-CKGUISET	;
-	; ZEXCEPT: %utt6var - if present, is NEWed and created in code following VERBOSE
-	I '$D(%utt6var) Q
-	N MAX
-	S MAX=$O(^TMP("%utt6_GUISET",$J,""),-1)
-	D CHKTF^%ut(^TMP("%utt6_GUISET",$J,MAX)["%utt6^NEWSTYLE","GUISET returned incorrect list")
-	Q
-	;
-CHKCMDLN	; check command line processing of %utt5
-	; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
-	I '$D(%utt6var) Q
-	D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
-	D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
-	D CHKTF^%ut($O(^TMP("%utt5_C",$J,1,""))="STARTUP","Incorrect function for entry 1,'"_$O(^TMP("%utt5_C",$J,1,""))_"' should be 'STARTUP'")
-	D CHKTF^%ut($O(^TMP("%utt5_C",$J,JLIEXPCT,""))="SHUTDOWN","Incorrect function for entry "_JLIEXPCT_", '"_$O(^TMP("%utt5_C",$J,JLIEXPCT,""))_"' should be 'SHUTDOWN'")
-	Q
-	;
-CHKGUI	; check GUI processing of %utt5
-	; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
-	I '$D(%utt6var) Q
-	D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
-	D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
-	D CHKTF^%ut($O(^TMP("%utt5_G",$J,1,""))="STARTUP","Incorrect function for entry 1,'"_$O(^TMP("%utt5Z_G",1,""))_"' should be 'STARTUP'")
-	D CHKTF^%ut($O(^TMP("%utt5_G",$J,JLIEXPCT,""))="SHUTDOWN","Incorrect function for entry "_JLIEXPCT_", '"_$O(^TMP("%utt5_G",$J,JLIEXPCT,""))_"' should be 'SHUTDOWN'")
-	Q
-	;
-XTENT	;
-	;;CHKCMDLN;check command line processing of %utt5
-	;;CHKGUI;check GUI processing of %utt5
-	;;CKGUISET;check list of tests returned by GUISET
-	;;NEWSTYLE;test return of valid new style or @TEST indicators
+%utt6 ;JLI - Unit tests for MUnit functionality ;08/29/14  11:43
+ ;;0.1;MASH UTILITIES;;
+ ;
+ ; This routine uses ZZUTJLI2 as a test routine, it does not include the routine as an extension,
+ ; since it uses it for tests.
+ ;
+ ; ZZUTJLI2 currently contains 3 tests (2 old style, 1 new style), it also specifies STARTUP and
+ ; SHUTDOWN (should be 1 each) and SETUP and TEARDOWN (should be 3 each, 1 for each test) enteries, each of these
+ ; creates an entry under the ^TMP("ZZUTJLI2" global node, indicating function then continues the process.
+ ; Should be 2+3n entries (1+1 for STARTUP and SHUTDOWN, then 3 for each of the tests (SETUP, test,
+ ; and TEARDOWN).
+ ;
+ ; This first section is more of a functional test, since it checks the full unit test processing from both
+ ; a command line and a GUI call approach.  Data for analysis is saved under ^TMP("ZZUTJLI2_C", for command
+ ; line and ^TMP("ZZUTJLI2_G", for gui processing.
+ ;
+ ; The counts for the command line processing are based on the number of unit test tags
+ ; determined for the GUI processing as well.  The numbers are 2 (startup and shutdown)
+ ;  + 3 x the number of tests present.
+ ;
+ ; run unit tests by command line
+ N VERBOSE
+ S VERBOSE=0
+VERBOSE ;
+ I '$D(VERBOSE) N VERBOSE S VERBOSE=1
+ N ZZUTCNT,JLICNT,JLIEXPCT,JLII,JLIX,ZZUTRSLT,%utt5,%utt6,%utt6var
+ W !!,"RUNNING COMMAND LINE TESTS VIA DOSET^%ut",!
+ D DOSET^%ut(1,VERBOSE) ; run `1 in M-UNIT TEST GROUP file
+ ;
+ W !!!,"Running command line tests by RUNSET^%ut",!
+ D RUNSET^%ut("TESTS FOR UNIT TEST ROUTINES")
+ ;
+ ; Call GUISET to obtain list of tags via entry in M-UNIT TEST GROUP file
+ ; silent to the user
+ D GUISET^%ut(.%utt6,1)
+ K ^TMP("%utt6_GUISET",$J) M ^TMP("%utt6_GUISET",$J)=@%utt6
+ ;
+ W !!!,"RUNNING COMMAND LINE UNIT TESTS FOR %utt5",!
+ N ZZUTCNT,JLICNT,JLIEXPCT,JLII,JLIX,ZZUTRSLT
+ S ZZUTCNT=0
+ K ^TMP("%utt5",$J) ; kill any contents of data storage
+ D EN^%ut("%utt5",VERBOSE) ; should do STARTUP(1x), then SETUP, test, TEARDOWN (each together 3x) and SHUTDOWN (1x)
+ K ^TMP("%utt5_C",$J) M ^TMP("%utt5_C",$J)=^TMP("%utt5",$J)
+ ;
+ ; now run unit tests by GUI - first determines unit test tags
+ W !!!,"RUNNING UNIT TESTS FOR %utt5 VIA GUI CALLS - Silent",!
+ S ZZUTCNT=0
+ K ^TMP("%utt5",$J),^TMP("%utt6",$J)
+ D GUILOAD^%ut(.%utt6,"%utt5")
+ M ^TMP("%utt6",$J)=@%utt6
+ S %utt6=$NA(^TMP("%utt6",$J))
+ ; then run each tag separately
+ ; JLICNT is count of unit test tags, which can be determined for GUI call for each unit test tag
+ 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))
+ ; and close it with a null routine name
+ D GUINEXT^%ut(.ZZUTRSLT,"")
+ K ^TMP("%utt5_G",$J) M ^TMP("%utt5_G",$J)=^TMP("%utt5",$J)
+ S JLIEXPCT=2+(3*JLICNT) ; number of lines that should be in the global nodes for command line and GUI
+ ;
+ ; now run the unit tests in this routine
+ W !!,"NOW RUNNING UNIT TESTS FOR %utt6",!!
+ D EN^%ut("%utt6",VERBOSE)
+ K ^TMP("%utt5",$J),^TMP("%utt5_C",$J),^TMP("%utt5_G",$J),^TMP("%utt6",$J),^TMP("%utt6_GUISET",$J)
+ ; clean up after GUI calls as well
+ K ^TMP("GUI-MUNIT",$J),^TMP("GUINEXT",$J),^TMP("MUNIT-%utRSLT",$J)
+ Q
+ ;
+ ;
+ ;           WARNING     --      WARNING     --      WARNING
+ ; If the number of NEW STYLE tests in %utt5 is increased (it is currently 1), then the following
+ ; test will need to be updated to reflect the change(s)
+ ;     END OF WARNING  --  END OF WARNING  --  END OF WARNING
+ ;
+NEWSTYLE ; tests return of valid new style or @TEST indicators
+ N LIST
+ D NEWSTYLE^%ut1(.LIST,"%utt5")
+ D CHKEQ^%ut(LIST,1,"Returned an incorrect number ("_LIST_") of New Style indicators - should be one")
+ I LIST>0 D CHKEQ^%ut(LIST(1),"NEWSTYLE^identify new style test indicator functionality","Returned incorrect TAG^reason "_LIST(1))
+ I LIST>0 D CHKEQ^%ut($G(LIST(2)),"","Returned a value for LIST(2) - should not have any value (i.e., null)")
+ Q
+ ;
+CKGUISET ;
+ ; ZEXCEPT: %utt6var - if present, is NEWed and created in code following VERBOSE
+ I '$D(%utt6var) Q
+ N MAX
+ S MAX=$O(^TMP("%utt6_GUISET",$J,""),-1)
+ D CHKTF^%ut(^TMP("%utt6_GUISET",$J,MAX)["%utt6^NEWSTYLE","GUISET returned incorrect list")
+ Q
+ ;
+CHKCMDLN ; check command line processing of %utt5
+ ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+ I '$D(%utt6var) Q
+ D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+ D CHKTF^%ut($D(^TMP("%utt5_C",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
+ D CHKTF^%ut($O(^TMP("%utt5_C",$J,1,""))="STARTUP","Incorrect function for entry 1,'"_$O(^TMP("%utt5_C",$J,1,""))_"' should be 'STARTUP'")
+ D CHKTF^%ut($O(^TMP("%utt5_C",$J,JLIEXPCT,""))="SHUTDOWN","Incorrect function for entry "_JLIEXPCT_", '"_$O(^TMP("%utt5_C",$J,JLIEXPCT,""))_"' should be 'SHUTDOWN'")
+ Q
+ ;
+CHKGUI ; check GUI processing of %utt5
+ ; ZEXCEPT: JLIEXPCT,%utt6var - if present NEWed and created in code following VERBOSE tag
+ I '$D(%utt6var) Q
+ D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT))=10,"Not enough entries in %utt5 expected "_JLIEXPCT)
+ D CHKTF^%ut($D(^TMP("%utt5_G",$J,JLIEXPCT+1))=0,"Too many entries in %utt5 expected "_JLIEXPCT)
+ D CHKTF^%ut($O(^TMP("%utt5_G",$J,1,""))="STARTUP","Incorrect function for entry 1,'"_$O(^TMP("%utt5Z_G",1,""))_"' should be 'STARTUP'")
+ D CHKTF^%ut($O(^TMP("%utt5_G",$J,JLIEXPCT,""))="SHUTDOWN","Incorrect function for entry "_JLIEXPCT_", '"_$O(^TMP("%utt5_G",$J,JLIEXPCT,""))_"' should be 'SHUTDOWN'")
+ Q
+ ;
+XTENT ;
+ ;;CHKCMDLN;check command line processing of %utt5
+ ;;CHKGUI;check GUI processing of %utt5
+ ;;CKGUISET;check list of tests returned by GUISET
+ ;;NEWSTYLE;test return of valid new style or @TEST indicators
diff --git a/Routines/%uttcovr.m b/Routines/%uttcovr.m
index 72df422..323a035 100644
--- a/Routines/%uttcovr.m
+++ b/Routines/%uttcovr.m
@@ -1,46 +1,46 @@
-%uttcovr	;JLI/JIVEYSOFT - runs coverage tests on %ut and %ut1 routines via unit tests ;2014-09-10  5:19 PM
-	;;0.1;MASH UTILITIES;
-	;
-	I '(+$SY=47) W !,"This coverage analysis is currently only available in GT.M" Q  ; GT.M only!
-	;
-	; if SHOWALL is true (1) all coverage globals data are listed
-	; if SHOWALL is false (0), only the %utCOVREPORT global is listed
-	I '$D(SHOWALL) N SHOWALL S SHOWALL=0
-	; set global node so %utt4 doesn't run its own analysis
-	S ^TMP("%uttcovr",$J)=1
-	; start analysis of %ut - it calls entry below
-	D COV^%ut1("%ut","D TESTCOVR^%ut",3)
-	D LIST("%ut") ; output results of analysis
-	; start analysis of %ut1
-	D COV^%ut1("%ut1","D TESTCOVR^%ut1",3)
-	D LIST("%ut1")
-	K ^TMP("%uttcovr",$J)
-	Q
-	;
-SHOWALL	; Entry to get all coverage globals listed
-	N SHOWALL
-	S SHOWALL=1
-	D ^%uttcovr
-	Q
-	;
-ENTRY	;
-	D ^%utt1 ; verbose
-	D EN^%ut("%utt1") ; non-verbose
-	; run tests from top of %utt6, runs both command line and gui analyses
-	D ^%utt6 ; non-verbose
-	D VERBOSE^%utt6 ; verbose
-	Q
-	;
-LIST(ROU)	;
-	; ZEXCEPT: SHOWALL - NEWed and set in SHOWALL or entering at %uttcovr
-	N JOB,NAME,BASE,GLOB
-	S JOB=$J
-	W !!!,ROU_" COVERAGE ANALYSIS"
-	F NAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
-	. I 'SHOWALL,NAME'="%utCOVREPORT" Q
-	. W !!!,NAME," GLOBAL DATA",!
-	. S BASE="^TMP("""_NAME_""","_JOB,GLOB=BASE_")"
-	. I $D(GLOB)#2 W !,GLOB,"=",$G(@GLOB)
-	. F  S GLOB=$Q(@GLOB) Q:GLOB'[BASE  I $D(GLOB)#2 W !,GLOB,"=",@GLOB
-	. Q
-	Q
+%uttcovr ;JLI/JIVEYSOFT - runs coverage tests on %ut and %ut1 routines via unit tests ;09/10/14  14:34
+ ;;0.1;MASH UTILITIES;;
+ ;
+ I '(+$SY=47) W !,"This coverage analysis is currently only available in GT.M" Q  ; GT.M only!
+ ;
+ ; if SHOWALL is true (1) all coverage globals data are listed
+ ; if SHOWALL is false (0), only the %utCOVREPORT global is listed
+ I '$D(SHOWALL) N SHOWALL S SHOWALL=0
+ ; set global node so %utt4 doesn't run its own analysis
+ S ^TMP("%uttcovr",$J)=1
+ ; start analysis of %ut - it calls entry below
+ D COV^%ut1("%ut","D TESTCOVR^%ut",-1)
+ D LIST("%ut") ; output results of analysis
+ ; start analysis of %ut1
+ D COV^%ut1("%ut1","D TESTCOVR^%ut1",3)
+ D LIST("%ut1")
+ K ^TMP("%uttcovr",$J)
+ Q
+ ;
+SHOWALL ; Entry to get all coverage globals listed
+ N SHOWALL
+ S SHOWALL=1
+ D ^%uttcovr
+ Q
+ ;
+ENTRY ;
+ D ^%utt1 ; verbose
+ D EN^%ut("%utt1") ; non-verbose
+ ; run tests from top of %utt6, runs both command line and gui analyses
+ D ^%utt6 ; non-verbose
+ D VERBOSE^%utt6 ; verbose
+ Q
+ ;
+LIST(ROU) ;
+ ; ZEXCEPT: SHOWALL - NEWed and set in SHOWALL or entering at %uttcovr
+ N JOB,NAME,BASE,GLOB
+ S JOB=$J
+ W !!!,ROU_" COVERAGE ANALYSIS"
+ F NAME="%utCOVREPORT","%utCOVRESULT","%utCOVCOHORT","%utCOVCOHORTSAV" D
+ . I 'SHOWALL,NAME'="%utCOVREPORT" Q
+ . W !!!,NAME," GLOBAL DATA",!
+ . S BASE="^TMP("""_NAME_""","_JOB,GLOB=BASE_")"
+ . I $D(GLOB)#2 W !,GLOB,"=",$G(@GLOB)
+ . F  S GLOB=$Q(@GLOB) Q:GLOB'[BASE  I $D(GLOB)#2 W !,GLOB,"=",@GLOB
+ . Q
+ Q
diff --git a/Routines/ZZUTPOST.m b/Routines/ZZUTPOST.m
new file mode 100644
index 0000000..20f1455
--- /dev/null
+++ b/Routines/ZZUTPOST.m
@@ -0,0 +1,148 @@
+ut01POST ;VEN-SMH/JLI - post install for M-Unit Test software ;08/28/14  12:29
+ ;;0.1;MASH UTILITIES;;
+ N X,I
+ I +$SY=47 D  R X:$G(DTIME,300) D MES^XPDUTL(" ")
+ . S X(1)=" "
+ . S X(2)="In the next section, as it tries to copy the ut* routines"
+ . S X(3)="to %ut* routines watch for text that indicates the following:"
+ . S X(4)=" "
+ . S X(5)="cp: cannot create regular file `/_ut.m': Permission denied"
+ . S X(6)=" "
+ . S X(7)="If this is seen, respond Yes at the prompt after the attempt:"
+ . S X(8)="   Press ENTER to continue: "
+ . F I=1:1:18 D MES^XPDUTL(" ") ; create a blank screen for text
+ . D MES^XPDUTL(.X)
+ . Q
+ D RENAME
+ I +$SY=47 D  R X:$G(DTIME,300) I "Yy"[$E($G(X)) D GTMPROB
+ . K X
+ . S X(1)=" "
+ . S X(2)="  Your entry on the next line may not echo"
+ . S X(3)="If error text was seen enter Y (and RETURN):  NO// "
+ . D MES^XPDUTL(.X)
+ . Q
+ Q
+ ;
+RENAME ;
+ N %S,%D ; Source, destination
+ S U="^"
+ S %S="ut^ut1^utt1^utt2^utt3^utt4^utt5^utt6^uttcovr"
+ S %D="%ut^%ut1^%utt1^%utt2^%utt3^%utt4^%utt5^%utt6^%uttcovr"
+ ;
+MOVE ; rename % routines
+ N %,X,Y,M
+ F %=1:1:$L(%D,"^") D  D MES(M) I +$SY=47 D MES(" ")
+ . S M="",X=$P(%S,U,%) ; from
+ . S Y=$P(%D,U,%) ; to
+ . Q:X=""
+ . S M="Routine: "_$J(X,8)
+ . Q:Y=""  I $T(^@X)=""  S M=M_"  Missing" Q
+ . S M=M_" Loaded, "
+ . D COPY(X,Y)
+ . S M=M_"Saved as "_$J(Y,8)
+ ;
+ QUIT  ; END
+ ;
+COPY(FROM,TO) ;
+ N XVAL
+ I +$SYSTEM=0 S XVAL="ZL @FROM ZS @TO" X XVAL QUIT
+ I +$SYSTEM=47 DO  QUIT
+ . S FROM=$$PATH(FROM)
+ . S TO=$$PATH(TO,"WRITE")
+ . N CMD S CMD="cp "_FROM_" "_TO
+ . O "cp":(shell="/bin/sh":command=CMD:WRITEONLY)::"PIPE"
+ . U "cp" C "cp"
+ QUIT
+ ;
+PATH(ROUTINE,MODE) ; for GT.M return source file with path for a routine
+ ;input: ROUTINE=Name of routine
+ ;       MODE="READ" or "WRITE" defaults to READ
+ ;output: Full filename
+ ;
+ S MODE=$G(MODE,"READ") ;set MODE to default value
+ N FILE S FILE=$TR(ROUTINE,"%","_")_".m" ;convert rtn name to filename
+ N ZRO S ZRO=$ZRO
+ ;
+ ; Get source routine
+ N %ZR
+ I MODE="READ" D SILENT^%RSEL(ROUTINE,"SRC") Q %ZR(ROUTINE)_FILE
+ ;
+ ; We are writing. Parse directories and get 1st routine directory
+ N DIRS
+ D PARSEZRO(.DIRS,ZRO)
+ N PATH S PATH=$$ZRO1ST(.DIRS)
+ ;
+ QUIT PATH_FILE ;end of PATH return directory and filename
+ ;
+ ;
+PARSEZRO(DIRS,ZRO) ; Parse $zroutines properly into an array
+ N PIECE
+ N I
+ F I=1:1:$L(ZRO," ") S PIECE(I)=$P(ZRO," ",I)
+ N CNT S CNT=1
+ F I=0:0 S I=$O(PIECE(I)) Q:'I  D
+ . S DIRS(CNT)=$G(DIRS(CNT))_PIECE(I)
+ . I DIRS(CNT)["("&(DIRS(CNT)[")") S CNT=CNT+1 QUIT
+ . I DIRS(CNT)'["("&(DIRS(CNT)'[")") S CNT=CNT+1 QUIT
+ . S DIRS(CNT)=DIRS(CNT)_" " ; prep for next piece
+ QUIT
+ ;
+ZRO1ST(DIRS) ; $$ Get first routine directory
+ N OUT ; $$ return
+ N %1 S %1=DIRS(1) ; 1st directory
+ ; Parse with (...)
+ I %1["(" DO
+ . S OUT=$P(%1,"(",2)
+ . I OUT[" " S OUT=$P(OUT," ")
+ . E  S OUT=$P(OUT,")")
+ ; no parens
+ E  S OUT=%1
+ ;
+ ; Add trailing slash
+ I $E(OUT,$L(OUT))'="/" S OUT=OUT_"/"
+ QUIT OUT
+ ;
+MES(T,B) ;Write message.
+ S B=$G(B)
+ I $L($T(BMES^XPDUTL)) D BMES^XPDUTL(T):B,MES^XPDUTL(T):'B Q
+ W:B ! W !,T
+ Q
+ ;
+TEST ; @TEST - TESTING TESTING
+ ;
+ N ZR S ZR="o(p r) /var/abc(/var/abc/r/) /abc/def $gtm_dist/libgtmutl.so vista.so"
+ N DIRS D PARSEZRO(.DIRS,ZR)
+ N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+ I FIRSTDIR'="p" S $EC=",U1,"
+ ;
+ N ZR S ZR="/var/abc(/var/abc/r/) o(p r) /abc/def $gtm_dist/libgtmutl.so vista.so"
+ N DIRS D PARSEZRO(.DIRS,ZR)
+ N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+ I FIRSTDIR'="/var/abc/r/" S $EC=",U1,"
+ ;
+ N ZR S ZR="/abc/def /var/abc(/var/abc/r/) o(p r) $gtm_dist/libgtmutl.so vista.so"
+ N DIRS D PARSEZRO(.DIRS,ZR)
+ N FIRSTDIR S FIRSTDIR=$$ZRO1ST(.DIRS)
+ I FIRSTDIR'="/abc/def" S $EC=",U1,"
+ ;
+ WRITE "All tests have run successfully!",!
+ QUIT
+ ;
+GTMPROB ; come here in case of error trying to run unit tests - checks whether renaming worked
+ N X
+ S X(1)=" "
+ S X(2)="*** An error occurred during renaming of routines to %ut*."
+ S X(3)="*** The renaming has been seen to fail on one type of Linux system."
+ S X(4)="*** In this case, at the Linux command line copy each ut*.m routine"
+ S X(5)="*** (ut.m, ut1.m, utt1.m, utt2.m, utt3.m, utt4.m, utt5.m, utt6.m, and "
+ S X(6)="*** uttcovr.m) to _ut*.m (e.g., 'cp ut.m _ut.m', 'cp ut1.m _ut1.m',"
+ S X(7)="*** 'cp utt1.m _utt1.m', etc., to 'cp uttcovr.m _uttcovr.m').  Then in GT.M"
+ S X(8)="*** use the command 'ZLINK %ut', then 'ZLINK %ut1', etc., these may"
+ S X(9)="*** indicate an undefined local variable error, but continue doing it."
+ S X(10)="*** When complete, use the M command 'DO ^%utt1' to run the unit tests on"
+ S X(11)="*** the %ut and %ut1 routines to confirm they are working"
+ S X(12)=" "
+ S X(13)="  Press Enter to continue: "
+ D MES^XPDUTL(.X)
+ R X:$G(DTIME,300)
+ Q
diff --git a/Routines/ZZUTPRE.m b/Routines/ZZUTPRE.m
new file mode 100644
index 0000000..ed3144c
--- /dev/null
+++ b/Routines/ZZUTPRE.m
@@ -0,0 +1,42 @@
+ut01PRE ;VEN/JLI - pre installation routine to set up MASH UTILITIES package and assign %ut routines and globals ;08/22/14  13:02
+ ;;0.1;MASH UTILITIES;;
+ ;
+ ; The following is used to create, if it does not exist, the MASH UTILITIES
+ ; package, and to assign the %u namespace to this package.  This special
+ ; processing is necessary, since the input transform currently will not accept a
+ ; % or lower case character in the namespace.
+ 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
+ ; and if necessary, as in CACHE, map %ut routine and namespace in the current account.
+ I +$SY=0 D CACHEMAP ; This routine is CACHE specific
+ Q
+ ; The following code was provided by Sam Habiel to map %
+CACHEMAP ; Map %ut* Globals and Routines away from %SYS in Cache
+ ; Get current namespace
+ N NMSP
+ I $P($P($ZV,") ",2),"(")<2012 S NMSP=$ZU(5)
+ I $P($P($ZV,") ",2),"(")>2011 S NMSP=$NAMESPACE
+ ;
+ N $ET S $ET="ZN NMSP D ^%ZTER S $EC="""""
+ ;
+ ZN "%SYS" ; Go to SYS
+ ;
+ ; Props
+ N % S %=##Class(Config.Namespaces).Get(NMSP,.PROP) ; Get all namespace properties
+ I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) S $EC=",U-CONFIG-FAIL," QUIT
+ ;
+ N DBG S DBG=PROP("Globals")  ; get the database globals location
+ N DBR S DBR=PROP("Routines") ; get the database routines location
+ ;
+ ; Map %ut globals away from %SYS
+ N % S %=##class(Config.Configuration).GetGlobalMapping(NMSP,"%ut*","",DBG,DBG)
+ I '% S %=##class(Config.Configuration).AddGlobalMapping(NMSP,"%ut*","",DBG,DBG)
+ I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) S $EC=",U-CONFIG-FAIL," QUIT
+ ;
+ ; Map %ut routines away from %SYS
+ N PROPRTN S PROPRTN("Database")=DBR
+ N % S %=##Class(Config.MapRoutines).Get(NMSP,"%ut*",.PROPRTN)
+ N PROPRTN S PROPRTN("Database")=DBR  ; Cache seems to like deleting this
+ I '% S %=##Class(Config.MapRoutines).Create(NMSP,"%ut*",.PROPRTN)
+ I '% W !,"Error="_$SYSTEM.Status.GetErrorText(%) S $EC=",U-CONFIG-FAIL," QUIT
+ ZN NMSP ; Go back
+ QUIT