DFRefactorImportExportFile.json

{
   "iNoOfFunctions": 37,
   "Data": [
     {
       "ID": "18",
       "Function_Name": "ChangeCalcToMoveStatement",
       "Function_Description": "",
       "Function_Help": "Changes legacy Calc\/MoveInt\/MoveStr\/MoveNum\/MoveReal -> 'Move' command.\r\nThe legacy commands compiles but does not work with the Studio's statement completion.",
       "SummaryText": "Changed: Calc\/MoveInt\/MoveStr\/MoveReal -> Move",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "1",
       "Function_Name": "ChangeCurrent_ObjectToSelf",
       "Function_Description": "",
       "Function_Help": "Changes legacy Current_Object -> Self\r\nReplaces the legacy keyword 'Current_Object' with 'Self'",
       "SummaryText": "Changed: Legacy Current_Object -> Self",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "2",
       "Function_Name": "ChangeDfTrueDfFalse",
       "Function_Description": "",
       "Function_Help": "Replaces legacy DfTrue and DFFalse with True or False",
       "SummaryText": "DFTrue -> True",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "4",
       "Function_Name": "ChangeGetAddress",
       "Function_Description": "",
       "Function_Help": "Replaces legacy GetAddress command with function AddressOf.\r\nExample: GetAddress of sVal to aAddress --> Move (AddressOf(sVal)) to aAddress",
       "SummaryText": "GetAdress -> (AddressOf(",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "36",
       "Function_Name": "ChangeIfNotCommandToExpression",
       "Function_Description": "",
       "Function_Help": "Changes command \"IFNOT\" into an expression\r\nExample: IFNOT Found Begin -->  If (Not(Found)) Begin",
       "SummaryText": "IFNOT command -> If (not('indicator'))",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "5",
       "Function_Name": "ChangeInsertCommandToFunction",
       "Function_Description": "",
       "Function_Help": "Changes legacy Insert command to use the function Insert.\r\nExample: Insert \",\" In sText At 2 --> Move (Insert(\",\", sText, 2)) to sText\r\nIf sOne Eq \"A\" Insert \"B\" in sOne at 2 --> If sOne Eq \"A\" Move (Insert(\"B\", sOne, 2)) to sOne",
       "SummaryText": "Insert command -> (Insert(",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "6",
       "Function_Name": "ChangeInToContains",
       "Function_Description": "",
       "Function_Help": "Replaces IN command with expression operator Contains.\r\nIt also swap places for the two variables involved and adds paranthesis.",
       "SummaryText": "Changed: 'In' to 'Contains'",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "33",
       "Function_Name": "ChangeLeftCommandToFunction",
       "Function_Description": "",
       "Function_Help": "Changes legacy Left command with Left.\r\nExample: Left sVar 5 to sLeft -> Move (Left(sVar, 5)) to sLeft",
       "SummaryText": "Changed: 'Left' command to function: 'Left'",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "3",
       "Function_Name": "ChangeLegacyIndicators",
       "Function_Description": "",
       "Function_Help": "Changes legacy 'Indicate' to expression\r\nExamples:\r\n- Indicate Found as True\" --> Move True to Found\r\n- [Select] Indicate Select as Windowindex Eq Fieldindex --> Move (WindowInex = FieldIndex) to Select\r\n- [Found] and [FindErr] indicator statements.\r\n- [Found| Command -> e.g. If Found Command\r\n- While [Not Found]   -> e.g. While (Not(Found))\r\n- [Found|Not Found|FindErr|Not FindErr] While   -> e.g. While (Not(Found))\r\n- [Found] Indicate Found as Invoice.CustNum eq Customer.Number -> If (Found) Move (Invoice.CustNum eq Customer.Number) to Found\r\n- If [Not Found] Reread hTable -> If (Not(Found)) Reread hTable\r\n- [~Found] begin -> If (Not(Found)) Begin\r\n- [Found ~Found] Begin -> If (Found and Not(Found)) Begin\r\nKnown limitations:\r\n- It can only handle max two booleans within the same square bracket. E.g. [Found Select]\r\n- It can't handle \"GROUP\" and\/or \"ALL\" indicator directives. If any of those two are found,\r\n  this function will leave the sLine as it is.",
       "SummaryText": "Changed: [Found] -> (Not(Found))",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "8",
       "Function_Name": "ChangeLegacyOperators",
       "Function_Description": "",
       "Function_Help": "Changes legacy comparison operators to: <, <=, =, <>, >, >=\r\nReplaces: gt, ge, lt, le, eq, ne with > >= < <= = <>\r\nIt does not change operators in e.g. find operations.",
       "SummaryText": "Changed: lt, le, eq, ne, gt, ge to: <, <=, =, <>, >, >=",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "32",
       "Function_Name": "ChangeLegacyShadow_State",
       "Function_Description": "",
       "Function_Help": "Changes Shadow_State and Object_Shadow_State to Enabled_State\r\nExample: Set Shadow_State [of oObject] to True -> Set Enabled_State [of oObject] to False\r\n         Set Object_Shadow_State [of oObject] to True -> Set Enabled_State [of oObject] to False",
       "SummaryText": "Changed: Shadow_State to Enabled_State",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "9",
       "Function_Name": "ChangeLengthCommandToFunction",
       "Function_Description": "",
       "Function_Help": "Changes usage of the legacy Length command with function Length.\r\nExample: Length sVar to iLength -> Move (Length(sVar)) to iLength",
       "SummaryText": "Changed: 'Length' command to function 'Length'",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "10",
       "Function_Name": "ChangePosCommandToFunction",
       "Function_Description": "",
       "Function_Help": "Changes usage of legacy Pos command with function Pos.\r\nExample: Pos \"-\"  in sIns to iPos --> Move (Pos(\"-\",sIns)) to iPos",
       "SummaryText": "Changed: Pos command to function Pos",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "11",
       "Function_Name": "ChangeReplaceCommandToFunction",
       "Function_Description": "",
       "Function_Help": "Changes legacy Replace command with function Replace.\r\nExample: Replace \",\" In sText With \".\" --> Move (Replace(\",\",sText,\".\")) to sText",
       "SummaryText": "Changed: Replace command to function Replace",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "34",
       "Function_Name": "ChangeRightCommandToFunction",
       "Function_Description": "",
       "Function_Help": "Changes legacy Right command with function Right\r\nExample: Right sVar 5 to sLeft -> Move (Rigth(sVar, 5)) to sLeft",
       "SummaryText": "Changed: Right command to function",
       "Selected": true,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "35",
       "Function_Name": "ChangeSquareBracketsIndicators",
       "Function_Description": "",
       "Function_Help": "Changes legacy square brackets found indicators; [Found] [FindErr] to expressions; (Found) or (Not(Found))\r\nIt does not change the 'Indicate' key word, only change square brackets to expressions.\r\nSample Code:\r\n  - [Found] and [FindErr] indicator statements to (Found) and (FindErr).\r\n  - [Found| Command -> e.g. If (Found) Command\r\n  - While [Not Found]   -> e.g. While (Not(Found))\r\n  - [Not Found] While   -> e.g. While (Not(Found))\r\n  - If [Not Found] Reread hTable -> If (Not(Found)) Reread hTable\r\n  - [~Found] Begin -> If (Not(Found)) Begin\r\n  - [Found ~Found] Begin -> If (Found and Not(Found)) Begin\r\nKnown limitations:\r\n  - It can't handle \"GROUP\" and\/or \"ALL\" indicator directives. If any of those two are found,\r\n    the function will leave the sLine as it is.",
       "SummaryText": "Changed: Square indicator expression [xxx] --> Paranthesis expression (xxx)",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "12",
       "Function_Name": "ChangeSysdate4",
       "Function_Description": "",
       "Function_Help": "Changes legacy Sysdate4 command to Sysdate command.\r\nExample: Sysdate4 dDate -> Sysdate dDate",
       "SummaryText": "Changed: Sysdate4 command to Sysdate",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "13",
       "Function_Name": "ChangeTrimCommandToFunction",
       "Function_Description": "",
       "Function_Help": "Changes lecacy Trim command with function Trim.\r\nExample: Trim sVal to sVal -> Move (Trim(sVal)) to sVal",
       "SummaryText": "Changed: Trim command to function Trim",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "15",
       "Function_Name": "ChangeUClassToRefClass",
       "Function_Description": "",
       "Function_Help": "Changes legacy Get Create U_Class to: Get Create (RefClass(Class))",
       "SummaryText": "Changed: 'Create U_Class' to 'Create (RefClass(Class))'",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "14",
       "Function_Name": "ChangeZeroStringCommandToFunction",
       "Function_Description": "",
       "Function_Help": "Changes legacy ZeroString command with function ZeroString.\r\nExample: ZeroString iLength to sParameter --> Move (ZeroString(iLength)) to sParameter",
       "SummaryText": "Changed: ZeroString command to function",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "16",
       "Function_Name": "EditorNormalizeCase",
       "Function_Description": "",
       "Function_Help": "Adjusts the casing of all scopes and keywords to match the casing as defined in the language configuration.\r\nThis is a wrapper function for the cScintillaEdit editor.\r\nA visible (paged) instantiation of the cScintillaEdit class is needed for this function to operate properly.\r\nThe DFRefactor program's 'Editor' view is used for this.",
       "SummaryText": "Changed: Proper Upper and lowercasing",
       "Selected": false,
       "Type": 3,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "17",
       "Function_Name": "EditorReIndent",
       "Function_Description": "",
       "Function_Help": "Reindents the source code with the number of spaces specified in the sParameter variable.\r\nThis is a wrapper function for the cScintillaEdit editor.\r\nA visible (paged) instantiation of the cScintillaEdit class is needed for this function to operate properly.\r\nThe DFRefactor program's 'Editor' view is used for this.",
       "SummaryText": "Reindented code",
       "Selected": false,
       "Type": 3,
       "bHasParameter": true,
       "Parameter": "4",
       "ParameterValidation": "1,2,3,4,5,6,7,8",
       "ParameterHelp": "Select the indent size you want to use for spaces when indenting code\r\nand when breaking a line on rewriting a single line to multiple lines.\r\nIt is the same value that can be set on the Editor Settings dialog tab size.",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "37",
       "Function_Name": "NormalizeArrayNotation",
       "Function_Description": "",
       "Function_Help": "A array variable declaration like e.g. \"String [] asAddress\", is changed to: \"String[] asAddress\"\r\n (Note the removed SPACE between \"String\" and \"[]\".",
       "SummaryText": "Changed: NormalizeArrayNotation",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "23",
       "Function_Name": "RemoveEndComments",
       "Function_Description": "",
       "Function_Help": "Removes end of line comments for: End_Class, End_Object, End_Function & End_Procedure.",
       "SummaryText": "Removed: End comments",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "20",
       "Function_Name": "RemoveLocalKeyWord",
       "Function_Description": "",
       "Function_Help": "Removes 'Local' keyword if present from procedures and functions variable declaration lines.",
       "SummaryText": "Removed: 'Local' key word",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "19",
       "Function_Name": "RemoveMultipleBlankLines",
       "Function_Description": "",
       "Function_Help": "Removes blank lines if more than xx 'Max blank lines'\r\nRemoves consecutive empty blank lines if more than sParameter value.\r\nTakes a source file as a string array as a parameter.\r\nReturns the passed string array with removed duplicated empty lines.",
       "SummaryText": "Removed: Consecutive blank Lines",
       "Selected": false,
       "Type": 6,
       "bHasParameter": true,
       "Parameter": "2",
       "ParameterValidation": "1,2,3,4,5,6",
       "ParameterHelp": "Select max number of consecutive blank lines allowed in source files.",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "24",
       "Function_Name": "RemoveOldStudioMarkers",
       "Function_Description": "",
       "Function_Help": "Removes legacy IDE markers '\/\/AB-Store' etc.\r\nReturns True if at least one legacy IDE (Studio) source code marker was found.",
       "SummaryText": "Removed: Legacy IDE markers",
       "Selected": false,
       "Type": 2,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "30",
       "Function_Name": "RemoveProjectObjectStructure",
       "Function_Description": "",
       "Function_Help": "Removes legacy Register_Object structures on top of e.g. view files.\r\nIt removes old style Studio 'Project Object Structures\"\r\nIt does not do so for WebApp (*.wo) files.",
       "SummaryText": "Removed: Register_Object structures",
       "Selected": false,
       "Type": 2,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "21",
       "Function_Name": "RemovePropertyPrivate",
       "Function_Description": "",
       "Function_Help": "Removes 'Private' keyword from Property declaration lines.",
       "SummaryText": "Removed: 'Private' property key word",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "22",
       "Function_Name": "RemovePropertyPublic",
       "Function_Description": "",
       "Function_Help": "Removes 'Public' property members from property declaration lines.",
       "SummaryText": "Removed: 'Puplic' property key word",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "25",
       "Function_Name": "RemoveSansSerif",
       "Function_Description": "",
       "Function_Help": "Removes \"MS Sans Serif\" font source lines.",
       "SummaryText": "Removed: 'MS Sans Serif' lines",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "7",
       "Function_Name": "RemoveStudioGeneratedComments",
       "Function_Description": "",
       "Function_Help": "Removes old Studio generated comments lines.\r\nExamples:\r\n\/\/ fires when the button is clicked\r\n\/\/OnChange is called on every changed character\r\n\/\/ Visual DataFlex xx.x Client Size Adjuster\r\n\/\/ Visual DataFlex xx.x Migration Utility\r\n...and so on",
       "SummaryText": "Removed: Studio generated comments",
       "Selected": false,
       "Type": 2,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "26",
       "Function_Name": "RemoveTrailingSpaces",
       "Function_Description": "",
       "Function_Help": "Removes spaces at the end of lines (trailing spaces).",
       "SummaryText": "Removed: Spaces at end of line",
       "Selected": false,
       "Type": 1,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "27",
       "Function_Name": "RemoveUnusedLocals",
       "Function_Description": "",
       "Function_Help": "Removes variables from functions and procedures that aren't used.\r\nA limitation is that it does not remove unused *struct* variables.\r\nPass a source file as a string array.\r\nRemoves all unusad locally defined, in Procedures & Functions, for the\r\npassed string array. Returns number of removed unused local variables.",
       "SummaryText": "Removed: Unused local variables",
       "Selected": false,
       "Type": 6,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "29",
       "Function_Name": "ReportUnusedSourceFiles",
       "Function_Description": "",
       "Function_Help": "Reports Only! Makes no changes to the source code.\r\nCheck all files in the current workspace to see if they are used, else list them in a report.\r\nPass an array with *all source files*\r\nReturns a list of unused files. See the DFRefactor programs: 'Other Log Files' toolbar button for results.",
       "SummaryText": "Report created: Files that are never used",
       "Selected": false,
       "Type": 4,
       "bHasParameter": false,
       "Parameter": "",
       "ParameterValidation": "",
       "ParameterHelp": "",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "31",
       "Function_Name": "RestyleDDOs",
       "Function_Description": "",
       "Function_Help": "The naming style of data-dictionaries *objects* over time has changed.\r\nThe new style is:\r\n Object o<tablename>_DD is a c<TableName>Datadictionary\r\nThey also have a switch so you can keep on using the legacy style name which is:\r\n Object o<tablename>_DD is a <tablename>_Datadictionary\r\n\r\nHowever before VDF12, this is how it looked:\r\n Object <tableName>_DD is a <tablename>_Datadictionary\r\n\r\nThis caused tremendous headaches as due to the extra \"o\" we ended up with name clashes\r\nall over the place. Copying old code into new views\/dialogs simply breaks and if your\r\ncodebase has mixed styles then the compiler will not catch that.\r\nA code nightmare.\r\n\r\nExamples:\r\n <TableName>_DD - o<TableName>DD (eDDStudioStyle)\r\n <TableName>_DD - o<TableName>_dd (neDDNewStyle)",
       "SummaryText": "Renamed DataDictionary objects",
       "Selected": false,
       "Type": 7,
       "bHasParameter": true,
       "Parameter": "eDDNewStyle",
       "ParameterValidation": "eDDStudioStyle,eDDNewStyle,eDDOldStyle",
       "ParameterHelp": "Valid values;\r\neDDStudioStyle - o<TableName>DD\r\neDDNewStyle - o<TableName>_dd\r\noDDOldStyle - <TableName>_DD }",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     },
     {
       "ID": "28",
       "Function_Name": "SplitInlineIfElseLine",
       "Function_Description": "",
       "Function_Help": "Splits If\/Else single lines to If\/Else - Begin constructs.\r\nIt does *not* split if the last word is = \"Break\", as that could\r\nchange the program logic.\r\nThe function accepts a parameter controlling the If\/Else or Begin\/End block constructs.\r\nValid sParameters, See: EnumList;",
       "SummaryText": "Split If\/Else line",
       "Selected": false,
       "Type": 1,
       "bHasParameter": true,
       "Parameter": "eSplitToBeginEndBlock",
       "ParameterValidation": "eSplitBySpaceAndSemicolon,eSplitBySemicolon,eSplitToBeginEndBlock",
       "ParameterHelp": "Valid values;\r\neSplitBySpaceAndSemicolon - Split line with space and semicolon\r\neSplitBySemicolon - Split line with semicolon\r\neSplitToBeginEndBlock - Use a Begin\/End block }",
       "bPrivate": false,
       "bPublished": true,
       "Counter": 0
     }
   ],
   "Code": [
     {
       "sFunctionName": "ChangeCalcToMoveStatement",
       "iSourceLines": 33,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy Calc\/MoveInt\/MoveStr\/MoveNum\/MoveReal -> 'Move' command.",
         "        The legacy commands compiles but does not work with the Studio's statement completion.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: Calc\/MoveInt\/MoveStr\/MoveReal -> Move }",
         "        \"\"\" }",
         "    Function ChangeCalcToMoveStatement String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged bFound",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        \/\/ Check if line contains one of the keywords and that none of the keywords are within quotes.",
         "        Get IsKeywordInLine \"calc|moveint|movenum|movereal|movestr\" TokenizerData.asLineTokens to bFound",
         "        If (bFound = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move False to bChanged",
         "        If (bChanged = False) Get _SubstituteCalcKeyword (&sLine) \"calc\"    4 to bChanged",
         "        If (bChanged = False) Get _SubstituteCalcKeyword (&sLine) \"moveint\" 7 to bChanged",
         "        If (bChanged = False) Get _SubstituteCalcKeyword (&sLine) \"movenum\" 7 to bChanged",
         "        If (bChanged = False) Get _SubstituteCalcKeyword (&sLine) \"movereal\" 8 to bChanged",
         "        If (bChanged = False and TokenizerData.bIsMoveStatement = False) Begin",
         "            Get _SubstituteCalcKeyword (&sLine) \"movestr\" 7 to bChanged",
         "        End",
         "",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeCurrent_ObjectToSelf",
       "iSourceLines": 41,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy Current_Object -> Self",
         "        Replaces the legacy keyword 'Current_Object' with 'Self'",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: Legacy Current_Object -> Self }",
         "        \"\"\" }",
         "    Function ChangeCurrent_ObjectToSelf String ByRef sLine String sParameter Returns Boolean",
         "        String sChar",
         "        Boolean bFound",
         "        Integer iPos iItem",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move (SearchArray(CS_Current_Object, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem = -1) Begin",
         "            Move (Pos(Lowercase(CS_Current_Object), Lowercase(sLine))) to iPos",
         "            If (iPos <> 0) Begin",
         "                Move (Mid(sLine, 1, (iPos -1))) to sChar",
         "                If (sChar <> \"(\") Begin",
         "                    Function_Return",
         "                End",
         "            End",
         "            Else Begin",
         "                Function_Return False",
         "            End",
         "        End",
         "",
         "        Get ReplaceLineToken TokenizerData sLine CS_Current_Object CS_Self to sLine",
         "        \/\/ Note! We call ourself recursively if there are more than one \"current_object\".",
         "        Move (Pos(Lowercase(CS_Current_Object), Lowercase(sLine))) to iPos",
         "        If (iPos <> 0) Begin",
         "            Get ChangeCurrent_ObjectToSelf (&sLine) \"\" to bFound",
         "        End",
         "",
         "        Function_Return True",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeDfTrueDfFalse",
       "iSourceLines": 43,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Replaces legacy DfTrue and DFFalse with True or False",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = DFTrue -> True }",
         "        \"\"\" }",
         "    Function ChangeDfTrueDfFalse String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bFound",
         "        String sNewBoolean",
         "        Integer iPos",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "",
         "        If (TokenizerData.bLineIsReady = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        \/\/ Note: The sKeywords string must be separated by \"|\" _and_ end with a \"|\".",
         "        Get IsKeywordInLine (CS_DfTrue + CS_D + CS_DfFalse + CS_D) TokenizerData.asLineTokens to bFound",
         "        If (bFound = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move (Trim(sLine)) to sLine",
         "        Repeat",
         "            Move CS_True to sNewBoolean",
         "            Move (Pos(Lowercase(CS_DfTrue), Lowercase(TokenizerData.sOverstrikeLine))) to iPos",
         "            If (iPos = 0) Begin",
         "                Move (Pos(Lowercase(CS_DfFalse), Lowercase(TokenizerData.sOverstrikeLine))) to iPos",
         "                Move CS_False to sNewBoolean",
         "            End",
         "            If (iPos <> 0) Begin",
         "                Move (Overstrike(\"||\" + sNewBoolean, sLine, iPos)) to sLine",
         "                Move (Replace(\"||\", sLine, \"\")) to sLine",
         "                Move (Overstrike(\"||\" + sNewBoolean, TokenizerData.sOverstrikeLine, iPos)) to TokenizerData.sOverstrikeLine",
         "                Move (Replace(\"||\", TokenizerData.sOverstrikeLine, \"\")) to TokenizerData.sOverstrikeLine",
         "            End",
         "        Until (iPos = 0)",
         "",
         "        Move (TokenizerData.sIndentation + String(sLine)) to sLine",
         "        Function_Return True",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeGetAddress",
       "iSourceLines": 34,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Replaces legacy GetAddress command with function AddressOf.",
         "        Example: GetAddress of sVal to aAddress --> Move (AddressOf(sVal)) to aAddress",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = GetAdress -> (AddressOf( }",
         "        \"\"\" }",
         "    Function ChangeGetAddress String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bFound",
         "        String sText",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        Move sLine to sText",
         "",
         "        If (TokenizerData.bLineIsReady = True or TokenizerData.bHasEndSemiColon = True or TokenizerData.bIsInFunction = True or ;",
         "            TokenizerData.bIsInProcedure = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Get IsKeywordInLine (CS_GetAddress + CS_D) TokenizerData.asLineTokens to bFound",
         "        If (bFound = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        If (TokenizerData.sEndComment <> \"\") Begin",
         "            Move (TokenizerData.sIndentation + CS_Move * \"(\" + CS_AddressOf + \"(\" + TokenizerData.OfStatement.sCode + \"))\" * CS_To * String(TokenizerData.ToStatement.sCode) * String(TokenizerData.sEndComment)) to sLine",
         "        End",
         "        Else Begin",
         "            Move (TokenizerData.sIndentation + CS_Move * \"(\" + CS_AddressOf + \"(\" + TokenizerData.OfStatement.sCode + \"))\" * CS_To * String(TokenizerData.ToStatement.sCode)) to sLine",
         "        End",
         "",
         "        Function_Return True",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeIfNotCommandToExpression",
       "iSourceLines": 43,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes command \"IFNOT\" into an expression",
         "        Example: IFNOT Found Begin -->  If (Not(Found)) Begin",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = IFNOT command -> If (not('indicator')) }",
         "        \"\"\" }",
         "    Function ChangeIfNotCommandToExpression String ByRef sLine String sParameter Returns Boolean",
         "        tTokenizer TokenizerData",
         "        Integer iItem iPos iSize iCount",
         "        String sCode sToken",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move (SearchArray(\"IFNOT\", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem = -1) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move sLine to sCode",
         "        Move (Pos(\"ifnot\", Lowercase(sCode))) to iPos",
         "        Move (Left(sCode, (iPos + Length(\"ifnot\")))) to sCode",
         "        If (iPos <> 0) Begin",
         "            Move (Overstrike(\"|||||\", sCode, iPos)) to sCode",
         "            Move (Replace(\"|||||\", sCode, CS_If)) to sCode",
         "            Increment iItem",
         "            Move TokenizerData.asLineTokens[iItem] to sToken",
         "            Append sCode \"(\" CS_Not \"(\" sToken \")) \"",
         "            Move (TokenizerData.iTokenCount) to iSize",
         "            Decrement iSize",
         "            For iCount from (iItem +1) to iSize",
         "                Append sCode TokenizerData.asLineTokens[iCount] CS_S",
         "            Loop",
         "        End",
         "        Move (RTrim(sCode)) to sCode",
         "        If (sLine <> sCode) Begin",
         "            Move sCode to sLine",
         "        End",
         "        Function_Return True",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeInsertCommandToFunction",
       "iSourceLines": 68,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy Insert command to use the function Insert.",
         "        Example: Insert \",\" In sText At 2 --> Move (Insert(\",\", sText, 2)) to sText",
         "        If sOne Eq \"A\" Insert \"B\" in sOne at 2 --> If sOne Eq \"A\" Move (Insert(\"B\", sOne, 2)) to sOne",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Insert command -> (Insert( }",
         "        \"\"\" }",
         "    Function ChangeInsertCommandToFunction String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged bFound",
         "        String sNose sLineLC sToken sVar1 sVar2 sText",
         "        Integer iPos iItem iInPos",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move (SearchArray(CS_Insert, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem = -1) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move (Trim(sLine)) to sLine",
         "",
         "        Move \"\" to sNose",
         "        Move (Lowercase(sLine)) to sLineLC",
         "        Move (SearchArray(CS_Insert, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        \/\/ If anything left of the CS_Insert command, save it in \"sNose\" (start string)",
         "        If (iItem > 0) Begin",
         "            Move (Pos(Lowercase(CS_Insert), sLineLC)) to iPos",
         "            Move (Left(sLine, (iPos -1))) to sNose",
         "            Move (Replace(sNose, sLine, \"\")) to sLine",
         "        End",
         "",
         "        \/\/ Remove the CS_Insert command",
         "        Move TokenizerData.asLineTokens[iItem] to sToken",
         "        Move (Replace(sToken, sLine, \"\")) to sLine",
         "        \/\/ Get the first variable",
         "        Move TokenizerData.asLineTokens[iItem + 1] to sVar1",
         "",
         "        \/\/ Find and remove the \"IN\" keyword.",
         "        Move (SearchArray(CS_In, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Move TokenizerData.asLineTokens[iItem] to sToken",
         "            Move (Replace(sToken, sLine, \"\")) to sLine",
         "            Move TokenizerData.asLineTokens[iItem + 1] to sVar2",
         "        End",
         "",
         "        \/\/ Find and remove the \"AT\" keyword, and save the next parameter which is the position to insert at.",
         "        Move (SearchArray(CS_At, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Move TokenizerData.asLineTokens[iItem] to sToken",
         "            Move (Replace(sToken, sLine, \"\")) to sLine",
         "            Move TokenizerData.asLineTokens[iItem + 1] to iInPos",
         "        End",
         "",
         "        Move \"\" to sText",
         "        If (sNose <> \"\") Begin",
         "            Move sNose to sText",
         "            Move (Trim(sText) + CS_S) to sText",
         "        End",
         "        Append sText CS_Move CS_S \"(\" CS_Insert \"(\" sVar1 \",\" sVar2 \",\" iInPos \"))\" \" \" CS_To CS_S sVar2",
         "",
         "        Get AssembleOutputLine sText TokenizerData to sLine",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeInToContains",
       "iSourceLines": 62,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Replaces IN command with expression operator Contains.",
         "        It also swap places for the two variables involved and adds paranthesis.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: 'In' to 'Contains' }",
         "        \"\"\" }",
         "    Function ChangeInToContains String ByRef sLine String sParameter Returns Boolean",
         "        String sOrg sPattern sMatched sRemain sHost sSub sText sAfter sBefore sExpression",
         "        Integer iSize iCount iItem",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True) Begin",
         "            Function_Return False",
         "        End",
         "        Move (SearchArray(CS_With, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Function_Return False",
         "        End",
         "        Move (SearchArray(CS_Insert, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Function_Return False",
         "        End",
         "        Move (SearchArray(CS_Pos, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Function_Return False",
         "        End",
         "        Move (SearchArray(CS_In, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem = -1) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move sLine to sOrg",
         "        Move sLine to sText",
         "        Move TokenizerData.asLineTokens[iItem -1] to sAfter",
         "        Move TokenizerData.asLineTokens[iItem +1] to sBefore",
         "        Decrement iItem",
         "        Move (\"(\" + sBefore * CS_Contains * String(sAfter) + \")\") to sExpression",
         "        \/\/ Set the \"Before\" array item to the expression",
         "        Move sExpression            to TokenizerData.asLineTokens[iItem]",
         "        \/\/ Add expression to the expression array:",
         "        Move (SizeOfArray(TokenizerData.aExpressions)) to iSize",
         "        Move sExpression            to TokenizerData.aExpressions[iSize].sExpression",
         "        Move (Length(sExpression))  to TokenizerData.aExpressions[iSize].iLength",
         "        Move (Pos(sAfter, sOrg))    to TokenizerData.aExpressions[iSize].iStartPos",
         "        If (TokenizerData.BooleanIndicator.AsBoolean.sCode <> \"\") Begin",
         "            Move sExpression to TokenizerData.BooleanIndicator.AsBoolean.sCode",
         "        End",
         "        Increment iItem",
         "        \/\/ Remove the two items we have concatenated.",
         "        Move (RemoveFromArray(TokenizerData.asLineTokens, iItem)) to TokenizerData.asLineTokens",
         "        Move (RemoveFromArray(TokenizerData.asLineTokens, iItem)) to TokenizerData.asLineTokens",
         "        Get RebuildLineFromTokens TokenizerData.asLineTokens 0 to sText",
         "",
         "        Set pTokenizer to TokenizerData",
         "        If (sText <> sOrg) Begin",
         "            Get AssembleOutputLine (Trim(sText)) TokenizerData to sLine",
         "        End",
         "",
         "        Function_Return (sLine <> sOrg)",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeLeftCommandToFunction",
       "iSourceLines": 12,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy Left command with Left.",
         "        Example: Left sVar 5 to sLeft -> Move (Left(sVar, 5)) to sLeft",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: 'Left' command to function: 'Left' }",
         "        \"\"\" }",
         "    Function ChangeLeftCommandToFunction String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged",
         "        Get SingleCommandSyntaxToFunction (&sLine) CS_Left to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeLegacyIndicators",
       "iSourceLines": 260,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy 'Indicate' to expression",
         "        Examples:",
         "        - Indicate Found as True\" --> Move True to Found",
         "        - [Select] Indicate Select as Windowindex Eq Fieldindex --> Move (WindowInex = FieldIndex) to Select",
         "        - [Found] and [FindErr] indicator statements.",
         "        - [Found| Command -> e.g. If Found Command",
         "        - While [Not Found]   -> e.g. While (Not(Found))",
         "        - [Found|Not Found|FindErr|Not FindErr] While   -> e.g. While (Not(Found))",
         "        - [Found] Indicate Found as Invoice.CustNum eq Customer.Number -> If (Found) Move (Invoice.CustNum eq Customer.Number) to Found",
         "        - If [Not Found] Reread hTable -> If (Not(Found)) Reread hTable",
         "        - [~Found] begin -> If (Not(Found)) Begin",
         "        - [Found ~Found] Begin -> If (Found and Not(Found)) Begin",
         "        Known limitations:",
         "        - It can only handle max two booleans within the same square bracket. E.g. [Found Select]",
         "        - It can't handle \"GROUP\" and\/or \"ALL\" indicator directives. If any of those two are found,",
         "          this function will leave the sLine as it is.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: [Found] -> (Not(Found)) }",
         "        \"\"\" }",
         "    Function ChangeLegacyIndicators String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged bStartBracket bHasBracket bIndicateStart bIfStart",
         "        String sToken sOverstrikeLine sNot sTo sMove sIf sFirstCmd sSecondCmd sExpression",
         "        Integer iItem iSize iPos",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin",
         "            Function_Return False",
         "        End",
         "        Get HasBracket TokenizerData.BooleanIndicator to bHasBracket",
         "        If (TokenizerData.BooleanIndicator.bHasIndicateCommand = False and bHasBracket = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        \/\/ Use sOverstrikeLine so string literal content cannot trigger a false-positive match.",
         "        If (Lowercase(TokenizerData.sOverstrikeLine) contains (Lowercase(CS_Find) + CS_S) or ;",
         "            Lowercase(TokenizerData.sOverstrikeLine) contains (Lowercase(CS_Send) + CS_S) or ;",
         "            Lowercase(TokenizerData.sOverstrikeLine) contains (Lowercase(CS_Constrain) + CS_S)) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move (SearchArray(\"GROUP\", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Function_Return False",
         "        End",
         "        Move (SearchArray(\"ALL\", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        \/\/ Has If-statement?",
         "        Move (TokenizerData.bHasIfCommand = True) to bIfStart",
         "        If (bIfStart = True) Begin",
         "            Move (SearchArray(CS_If, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "            If (iItem <> -1) Begin",
         "                Move TokenizerData.asLineTokens[iItem] to sIf",
         "            End",
         "        End",
         "        Else Begin",
         "            Move CS_If to sIf",
         "        End",
         "",
         "        \/\/ Has Move-statement?",
         "        Move (SearchArray(CS_Move, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Move TokenizerData.asLineTokens[iItem] to sMove",
         "        End",
         "        Else Begin",
         "            Move CS_Move to sMove",
         "        End",
         "        Move TokenizerData.FirstLeftCommand.sCode  to sFirstCmd",
         "        Move TokenizerData.SecondLeftCommand.sCode to sSecondCmd",
         "",
         "        \/\/ Has To-statement?",
         "        Move (SearchArray(CS_To, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Move TokenizerData.asLineTokens[iItem] to sTo",
         "        End",
         "        Else Begin",
         "            Move CS_To to sTo",
         "        End",
         "",
         "        Move 0 to iItem",
         "        Move TokenizerData.asLineTokens[iItem] to sToken",
         "        \/\/ Starts with a indicator bracket?",
         "        Move (Left(sToken, 1) = \"[\") to bStartBracket",
         "        Move CS_Not to sNot",
         "",
         "        \/\/ Get the \"Not\" keyword:",
         "        If (TokenizerData.BooleanIndicator.FirstBoolean.bHasNot  = True or ;",
         "            TokenizerData.BooleanIndicator.SecondBoolean.bHasNot = True or ;",
         "            TokenizerData.BooleanIndicator.ToBoolean.bHasNot     = True or ;",
         "            TokenizerData.BooleanIndicator.AsBoolean.bHasNot     = True) Begin",
         "            Move (SearchArray(\"[not\", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "            If (iItem = -1) Begin",
         "                Move (Pos((\"[\" + CS_Tilde), TokenizerData.sLine)) to iItem",
         "                If (iItem = 0) Begin",
         "                    Move -1 to iItem",
         "                End",
         "                Else If (iItem > 0) Begin",
         "                    Move -1 to iItem",
         "                End",
         "            End",
         "            If (iItem <> -1) Begin",
         "                Get ReplaceBrackets TokenizerData.asLineTokens[iItem] to sNot",
         "            End",
         "        End",
         "",
         "        \/\/ Has an \"Indicate\" command?",
         "        Move (SearchArray(CS_Indicate, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        Move (iItem <> -1) to bIndicateStart",
         "",
         "        \/\/ Add \"Not\" operator and add paranthesis to boolean expressions\/variables;",
         "        If (TokenizerData.BooleanIndicator.FirstBoolean.bHasNot = True) Begin",
         "            Move (\"(\" + sNot + \"(\" + TokenizerData.BooleanIndicator.FirstBoolean.sCode + \"))\") to TokenizerData.BooleanIndicator.FirstBoolean.sCode",
         "        End",
         "        Else If (TokenizerData.BooleanIndicator.FirstBoolean.sCode <> \"\" and Left(TokenizerData.BooleanIndicator.FirstBoolean.sCode, 1) <> \"(\") Begin",
         "            Move (\"(\" + TokenizerData.BooleanIndicator.FirstBoolean.sCode + \")\") to TokenizerData.BooleanIndicator.FirstBoolean.sCode",
         "        End",
         "        If (TokenizerData.BooleanIndicator.SecondBoolean.bHasNot = True) Begin",
         "            Move (\"(\" + sNot + \"(\" + TokenizerData.BooleanIndicator.SecondBoolean.sCode + \"))\") to TokenizerData.BooleanIndicator.SecondBoolean.sCode",
         "        End",
         "        Else If (Left(TokenizerData.BooleanIndicator.SecondBoolean.sCode, 1) <> \"(\" and Right(TokenizerData.BooleanIndicator.SecondBoolean.sCode, 1) <> \")\") Begin",
         "            If (TokenizerData.BooleanIndicator.SecondBoolean.sCode <> \"\") Begin",
         "                Move (\"(\" + TokenizerData.BooleanIndicator.SecondBoolean.sCode + \")\") to TokenizerData.BooleanIndicator.SecondBoolean.sCode",
         "            End",
         "        End",
         "        If (TokenizerData.BooleanIndicator.ToBoolean.bHasNot = True) Begin",
         "            Move (\"(\" + sNot + \"(\" + TokenizerData.BooleanIndicator.ToBoolean.sCode + \"))\") to TokenizerData.BooleanIndicator.ToBoolean.sCode",
         "        End",
         "        If (Left(TokenizerData.BooleanIndicator.ToBoolean.sCode, 1) <> \"(\" and Right(TokenizerData.BooleanIndicator.ToBoolean.sCode, 1) <> \")\") Begin",
         "            If (TokenizerData.BooleanIndicator.ToBoolean.sCode <> \"\" and not(TokenizerData.BooleanIndicator.ToBoolean.sCode contains CS_S)) Begin",
         "                Move (\"(\" + TokenizerData.BooleanIndicator.ToBoolean.sCode + \")\") to TokenizerData.BooleanIndicator.ToBoolean.sCode",
         "            End",
         "        End",
         "        If (TokenizerData.BooleanIndicator.AsBoolean.bHasNot = True) Begin",
         "            Move (\"(\" + sNot + \"(\" + TokenizerData.BooleanIndicator.AsBoolean.sCode + \"))\") to TokenizerData.BooleanIndicator.AsBoolean.sCode",
         "        End",
         "        If (Left(TokenizerData.BooleanIndicator.AsBoolean.sCode, 1) <> \"(\" and Right(TokenizerData.BooleanIndicator.AsBoolean.sCode, 1) <> \")\") Begin",
         "            If (TokenizerData.BooleanIndicator.AsBoolean.sCode <> \"\") Begin",
         "                Move (\"(\" + TokenizerData.BooleanIndicator.AsBoolean.sCode + \")\") to TokenizerData.BooleanIndicator.AsBoolean.sCode",
         "            End",
         "        End",
         "",
         "        Case Begin",
         "            \/\/ This was too much code, so it was broken out to a helper-function (sub):",
         "            Case (bStartBracket = True)",
         "                Get _ChangeLegacyIndicators_Sub TokenizerData TokenizerData.sOverstrikeLine (&bChanged) to sOverstrikeLine",
         "                Case Break",
         "",
         "            \/\/ 'If [False] Indicate Select as Windowindex Eq Fieldindex \/\/ Comment'",
         "            \/\/ 'If [not found] Move (Windowindex Eq Fieldindex) to Select \/\/ Comment'",
         "            \/\/ 'If dDate LE '01\/01\/1984' Indicate ERROR_DATE True'",
         "            Case (bIfStart = True)",
         "                Move sIf to sOverstrikeLine",
         "                Move TokenizerData.BooleanIndicator.FirstBoolean.sCode to sToken",
         "                Get ReplaceParanthesis sToken to sToken",
         "                Move (Pos(Lowercase(sToken), Lowercase(Trim(sLine)))) to iPos",
         "                If (iPos < TokenizerData.SecondLeftCommand.iStartPos) Begin",
         "                    Move TokenizerData.BooleanIndicator.SecondBoolean.sCode to sToken",
         "                    Move (SearchArray(sToken, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "                    If (iItem = -1) Begin",
         "                        Get ReplaceParanthesis sToken to sToken",
         "                        Move (SearchArray(sToken, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "                    End",
         "                    If (iItem <> -1) Begin",
         "                        Increment iItem",
         "                        If (iItem <= SizeOfArray(TokenizerData.asLineTokens)) Begin",
         "                            Move TokenizerData.asLineTokens[iItem] to sToken",
         "                            If (Lowercase(sToken) = Lowercase(CS_As)) Begin",
         "                                Increment iItem",
         "                                Move TokenizerData.asLineTokens[iItem] to sToken",
         "                            End",
         "                        End",
         "                        If (Lowercase(sToken) = Lowercase(CS_To)) Begin",
         "                            Increment iItem",
         "                            Move TokenizerData.asLineTokens[iItem] to sToken",
         "                            Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode CS_S sMove",
         "                            Move TokenizerData.BooleanIndicator.SecondBoolean.sCode to sExpression",
         "                            Append sOverstrikeLine CS_S sExpression CS_S sTo CS_S sToken",
         "                        End",
         "                        Else Begin",
         "                            Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode CS_S sMove",
         "                            Move TokenizerData.BooleanIndicator.SecondBoolean.sCode to sExpression",
         "                            Get ReplaceParanthesis sExpression to sExpression",
         "                            Append sOverstrikeLine CS_S sToken CS_S sTo CS_S sExpression",
         "                        End",
         "                    End",
         "                End",
         "                Else Begin",
         "                    Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode",
         "                    If (TokenizerData.BooleanIndicator.AsBoolean.sCode <> \"\") Begin",
         "                        Append sOverstrikeLine CS_S sMove CS_S TokenizerData.BooleanIndicator.AsBoolean.sCode",
         "                        Move TokenizerData.BooleanIndicator.SecondBoolean.sCode to sToken",
         "                        Append sOverstrikeLine CS_S sTo   CS_S sToken",
         "                    End",
         "                    Else Begin",
         "                        Append sOverstrikeLine CS_S sMove CS_S TokenizerData.BooleanIndicator.SecondBoolean.sCode",
         "                        Move TokenizerData.BooleanIndicator.ToBoolean.sCode to sToken",
         "                        Get ReplaceParanthesis sToken to sToken",
         "                        Append sOverstrikeLine CS_S sTo   CS_S sToken",
         "                    End",
         "                End",
         "",
         "                Case Break",
         "",
         "            \/\/ 'Indicate Found as True'",
         "            \/\/ 'Indicate [Found] as True'",
         "            \/\/ 'Indicate Select as Windowindex Eq Fieldindex \/\/ Comment'",
         "            Case (bIndicateStart = True)",
         "                Move CS_Move to sOverstrikeLine",
         "                If (Left(TokenizerData.BooleanIndicator.FirstBoolean.sCode, 1) = \"(\") Begin",
         "                    Get ReplaceParanthesis TokenizerData.BooleanIndicator.FirstBoolean.sCode to TokenizerData.BooleanIndicator.FirstBoolean.sCode",
         "                End",
         "                \/\/ If AsBoolean.sCode = \"\" we have a missing \"as\" keyword on line, so we adjust for that here.",
         "                If (TokenizerData.BooleanIndicator.AsBoolean.sCode = \"\") Begin",
         "                    Move (SizeOfArray(TokenizerData.asLineTokens)) to iSize",
         "                    Move TokenizerData.asLineTokens[iSize -1] to TokenizerData.BooleanIndicator.AsBoolean.sCode",
         "                End",
         "                If (TokenizerData.BooleanIndicator.AsBoolean.sCode <> \"\" and Left(TokenizerData.BooleanIndicator.AsBoolean.sCode, 1) <> \"(\") Begin",
         "                    Move (\"(\" + TokenizerData.BooleanIndicator.AsBoolean.sCode +\")\") to TokenizerData.BooleanIndicator.AsBoolean.sCode",
         "                End",
         "                Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.AsBoolean.sCode CS_S CS_To CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode",
         "                Case Break",
         "",
         "            \/\/ Starts with any other than: \"If\", \"Indicate\" or a square bracket indicator as e.g. \"[Not Found]\". I.e. another command.",
         "            Case Else",
         "                \/\/ Do we have a e.g. \"While [Not Found]\" construct?",
         "                If (Pos(sFirstCmd, TokenizerData.sOverstrikeLine) < Pos(\"[\", TokenizerData.sOverstrikeLine)) Begin",
         "                    Move sFirstCmd to sOverstrikeLine",
         "                    Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode",
         "                End",
         "                Else Begin",
         "                    Move TokenizerData.BooleanIndicator.ToBoolean.sCode to sToken",
         "                    If (sToken = \"\") Begin",
         "                        Move TokenizerData.BooleanIndicator.AsBoolean.sCode to sToken",
         "                    End",
         "                    Move (CS_Move * String(sToken)) to sOverstrikeLine",
         "                    If (SearchArray(sTo, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP)) <> -1) Begin",
         "                        Append sOverstrikeLine CS_S sTo CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode",
         "                    End",
         "                    Else Begin",
         "                        Move TokenizerData.asLineTokens[(SizeOfArray(TokenizerData.asLineTokens) -1)] to sToken",
         "                        Move (SearchArray(CS_As, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "                        If (iItem <> -1) Begin",
         "                            Move TokenizerData.BooleanIndicator.FirstBoolean.sCode to sToken",
         "                            Append sOverstrikeLine CS_S sTo CS_S sToken",
         "                        End",
         "                        Else Begin",
         "                            Append sOverstrikeLine CS_S sToken",
         "                        End",
         "                    End",
         "                End",
         "        Case End",
         "",
         "        Get AssembleOutputLine sOverstrikeLine TokenizerData to sLine",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeLegacyOperators",
       "iSourceLines": 49,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy comparison operators to: <, <=, =, <>, >, >=",
         "        Replaces: gt, ge, lt, le, eq, ne with > >= < <= = <>",
         "        It does not change operators in e.g. find operations.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: lt, le, eq, ne, gt, ge to: <, <=, =, <>, >, >= }",
         "        \"\"\" }",
         "    Function ChangeLegacyOperators String ByRef sLine String sParameter Returns Boolean",
         "        String sExpression sOrg sOrgNS sOverStrikeLine sChar",
         "        Boolean bFound bChanged bHasEndComment",
         "        Integer iItem iPos iLeftParanthesis iRightParanthesis",
         "        tTokenizer TokenizerData",
         "        tOperatorsInfo OperatorInfo",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True) Begin",
         "            Function_Return False",
         "        End",
         "        If (TokenizerData.OperatorsInfo.bIsLegacy = False) Begin",
         "            Function_Return False",
         "        End",
         "        If (Lowercase(TokenizerData.FirstLeftCommand.sCode) = Lowercase(CS_Find) or Lowercase(TokenizerData.SecondLeftCommand.sCode) = Lowercase(CS_Find)) Begin",
         "            Function_Return False",
         "        End",
         "        Move (SearchArray(CS_Constrain, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Function_Return False",
         "        End",
         "        Get HasLegacyOperator TokenizerData.sOverstrikeLine to bFound",
         "        If (bFound = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move (Ltrim(sLine)) to sOrg",
         "        Get RebuildLineFromTokens TokenizerData.asLineTokens 0 to sOrgNS",
         "        If (SizeOfArray(TokenizerData.aExpressions) <> 0) Begin",
         "            Get ReplaceAllLegacyOperators sOrgNS to sOrgNS",
         "        End",
         "",
         "        Move (TokenizerData.sIndentation + String(sOrgNS)) to sOrgNS",
         "        If (sOrg <> sOrgNS) Begin",
         "            Move sOrgNS to sLine",
         "            If (TokenizerData.sEndComment <> \"\" and not(sLine contains TokenizerData.sEndComment)) Begin",
         "                Append sLine CS_S TokenizerData.sEndComment",
         "            End",
         "        End",
         "        Function_Return (sOrg <> sOrgNS)",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeLegacyShadow_State",
       "iSourceLines": 100,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes Shadow_State and Object_Shadow_State to Enabled_State",
         "        Example: Set Shadow_State [of oObject] to True -> Set Enabled_State [of oObject] to False",
         "                 Set Object_Shadow_State [of oObject] to True -> Set Enabled_State [of oObject] to False",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: Shadow_State to Enabled_State }",
         "        \"\"\" }",
         "    Function ChangeLegacyShadow_State String ByRef sLine Returns Boolean",
         "        String sToState sText sLineLC sEndComment sSpaces",
         "        Boolean bFound",
         "        Integer iPos",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Get IsKeywordInLine CS_Object_Shadow_State TokenizerData.asLineTokens to bFound",
         "        If (bFound = False) Begin",
         "            Get IsKeywordInLine CS_Shadow_State TokenizerData.asLineTokens to bFound",
         "        End",
         "        If (bFound = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        If (TokenizerData.sEndComment <> \"\") Begin",
         "            Get EndComment sLine to sEndComment",
         "            Move (Replace(sEndComment, sLine, \"\")) to sLine",
         "            Move (Rtrim(sLine)) to sText",
         "            Move (Replace(sText, sLine, \"\")) to sSpaces",
         "            Move (sSpaces + String(sEndComment)) to sEndComment",
         "            Move (Rtrim(sLine)) to sLine",
         "        End",
         "",
         "        Move (Lowercase(sLine)) to sLineLC",
         "        Move (Pos(Lowercase(CS_Object_Shadow_State), sLineLC)) to iPos",
         "        If (iPos <> 0) Begin",
         "            Get ReplaceLineToken TokenizerData sLine CS_Object_Shadow_State CS_Enabled_State to sLine",
         "        End",
         "        Else Begin",
         "            Move (Pos(Lowercase(CS_Shadow_State), sLineLC)) to iPos",
         "            If (iPos <> 0) Begin",
         "                Get ReplaceLineToken TokenizerData sLine CS_Shadow_State CS_Enabled_State to sLine",
         "            End",
         "        End",
         "        Move (Lowercase(sLine)) to sLineLC",
         "",
         "        \/\/ We also need to negate any \"True\" or \"False\" in the \"to\" part of the line",
         "        Move TokenizerData.ToStatement.sCode to sToState",
         "        If (Lowercase(sToState) = Lowercase(CS_True) or Lowercase(sToState) = Lowercase(CS_False)) Begin",
         "            Get IsKeywordInLine CS_True TokenizerData.asLineTokens to bFound",
         "            If (bFound = True) Begin",
         "                Move (Pos(Lowercase(CS_True), sLineLC)) to iPos",
         "                If (iPos <> 0) Begin",
         "                    Get ReplaceLineToken TokenizerData sLine CS_True CS_False to sLine",
         "                End",
         "            End",
         "            Else Begin",
         "                Get IsKeywordInLine CS_False TokenizerData.asLineTokens to bFound",
         "                Move (Pos(Lowercase(CS_False), sLineLC)) to iPos",
         "                If (iPos <> 0) Begin",
         "                    Get ReplaceLineToken TokenizerData sLine CS_False CS_True to sLine",
         "                End",
         "            End",
         "        End",
         "        \/\/ Or any self defined boolean variable at end of line:",
         "        Else Begin",
         "            Move (Pos(Lowercase(CS_Not), Lowercase(sToState))) to iPos",
         "            \/\/ Add \"not\" keyword",
         "            If (iPos = 0) Begin",
         "                Move (Replace(sToState, sLine, (\"(\" + CS_Not + \"(\" + sToState + \"))\"))) to sLine",
         "            End",
         "            \/\/ Remove \"not\" keyword and its parantheses. Note that it can contain spaces.",
         "            Else Begin",
         "                Move (Replace(\"(\", sToState, \"\")) to sText",
         "                Move (Replace(Lowercase(CS_Not), sText, \"\")) to sText",
         "                Move (Pos(Lowercase(CS_Not), Lowercase(sToState))) to iPos",
         "                Move (Overstrike(\"   \", sToState, iPos)) to sToState",
         "                Move (Replaces(\"(\", sToState, \"\")) to sToState",
         "                Move (Replaces(\")\", sToState, \"\")) to sToState",
         "                Move (Trim(sToState))              to sToState",
         "                Move (Pos(Lowercase(CS_S + CS_To + CS_S), sLineLC)) to iPos",
         "                If (iPos <> 0) Begin",
         "                    Move (Left(sLine, (iPos -1))) to sLine",
         "                    Append sLine CS_S CS_To CS_S sToState",
         "                End",
         "            End",
         "        End",
         "        Move (Rtrim(sLine)) to sLine",
         "        If (sEndComment <> \"\") Begin",
         "            Append sLine sEndComment",
         "        End",
         "        Else If (TokenizerData.sEndComment <> \"\") Begin",
         "            Append sLine CS_S TokenizerData.sEndComment",
         "        End",
         "",
         "        Function_Return True",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeLengthCommandToFunction",
       "iSourceLines": 12,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes usage of the legacy Length command with function Length.",
         "        Example: Length sVar to iLength -> Move (Length(sVar)) to iLength",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: 'Length' command to function 'Length' }",
         "        \"\"\" }",
         "    Function ChangeLengthCommandToFunction String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged",
         "        Get SingleCommandSyntaxToFunction (&sLine) CS_Length to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangePosCommandToFunction",
       "iSourceLines": 12,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes usage of legacy Pos command with function Pos.",
         "        Example: Pos \"-\"  in sIns to iPos --> Move (Pos(\"-\",sIns)) to iPos",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: Pos command to function Pos }",
         "        \"\"\" }",
         "    Function ChangePosCommandToFunction String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged",
         "        Get SingleCommandSyntaxToFunction (&sLine) CS_Pos to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeReplaceCommandToFunction",
       "iSourceLines": 12,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy Replace command with function Replace.",
         "        Example: Replace \",\" In sText With \".\" --> Move (Replace(\",\",sText,\".\")) to sText",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: Replace command to function Replace }",
         "        \"\"\" }",
         "    Function ChangeReplaceCommandToFunction String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged",
         "        Get SingleCommandSyntaxToFunction (&sLine) CS_Replace to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeRightCommandToFunction",
       "iSourceLines": 12,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy Right command with function Right",
         "        Example: Right sVar 5 to sLeft -> Move (Rigth(sVar, 5)) to sLeft",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: Right command to function }",
         "        \"\"\" }",
         "    Function ChangeRightCommandToFunction String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged",
         "        Get SingleCommandSyntaxToFunction (&sLine) CS_Right to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeSquareBracketsIndicators",
       "iSourceLines": 77,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy square brackets found indicators; [Found] [FindErr] to expressions; (Found) or (Not(Found))",
         "        It does not change the 'Indicate' key word, only change square brackets to expressions.",
         "        Sample Code:",
         "          - [Found] and [FindErr] indicator statements to (Found) and (FindErr).",
         "          - [Found| Command -> e.g. If (Found) Command",
         "          - While [Not Found]   -> e.g. While (Not(Found))",
         "          - [Not Found] While   -> e.g. While (Not(Found))",
         "          - If [Not Found] Reread hTable -> If (Not(Found)) Reread hTable",
         "          - [~Found] Begin -> If (Not(Found)) Begin",
         "          - [Found ~Found] Begin -> If (Found and Not(Found)) Begin",
         "        Known limitations:",
         "          - It can't handle \"GROUP\" and\/or \"ALL\" indicator directives. If any of those two are found,",
         "            the function will leave the sLine as it is.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: Square indicator expression [xxx] --> Paranthesis expression (xxx) }",
         "        \"\"\" }",
         "    Function ChangeSquareBracketsIndicators String ByRef sLine String sParameter Returns Boolean",
         "        String sNewCode sVarName sExpression",
         "        Boolean bFound bHasBracket bChanged",
         "        Integer iStart iEnd iItem iLeftBracketNo",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True or;",
         "            TokenizerData.bIsInCommand = True or;",
         "            TokenizerData.bIsInStruct  = True or;",
         "            TokenizerData.bIsInImage   = True or;",
         "            TokenizerData.bIsVariableDeclaration = True) Begin",
         "            Function_Return False",
         "        End",
         "        Get HasBracket TokenizerData.BooleanIndicator to bHasBracket",
         "        If (bHasBracket = False) Begin",
         "            Function_Return False",
         "        End",
         "        \/\/ We leave compound square bracket expessions combined withe keywords: \"GROUP\" and \"ALL\" alone:",
         "        Move (SearchArray(\"GROUP\", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Function_Return False",
         "        End",
         "        Move (SearchArray(\"ALL\", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem <> -1) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move TokenizerData.sOverstrikeLine to sNewCode",
         "        Move 1 to iLeftBracketNo",
         "",
         "        While (Pos(\"[\", sNewCode) > 0)",
         "",
         "            Move (Pos(\"[\", sNewCode)) to iStart",
         "            Move (Pos(\"]\", sNewCode)) to iEnd",
         "            Move (Mid(sNewCode, (iEnd - iStart -1), (iStart +1))) to sVarName",
         "            \/\/ Convert bracketed indicators variables to an expression",
         "            Get ConvertBracketIndicatorsToExpression iLeftBracketNo TokenizerData to sExpression",
         "            Increment iLeftBracketNo",
         "",
         "            \/\/ Handle negation cases",
         "            If (sVarName <> \"\") Begin",
         "                Move (Replace(\"[\" + sVarName + \"]\", sNewCode, sExpression)) to sNewCode",
         "            End",
         "        Loop",
         "",
         "        Get FixIndicatorsLoopRepeatCommand sNewCode to sNewCode",
         "        \/\/ If the old expression started with a bracket, insert an \"If\" statement at start of line.",
         "        If (Left(Trim(sNewCode), 1) = \"(\") Begin",
         "            Move (\"If\" * String(sNewCode)) to sNewCode",
         "        End",
         "",
         "        Get RestoreOverstrikeLineValues sNewCode TokenizerData to sNewCode",
         "        Get AssembleOutputLine sNewCode TokenizerData to sNewCode",
         "        Move (sNewCode <> sLine) to bChanged",
         "        Move sNewCode to sLine",
         "",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeSysdate4",
       "iSourceLines": 31,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy Sysdate4 command to Sysdate command.",
         "        Example: Sysdate4 dDate -> Sysdate dDate",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: Sysdate4 command to Sysdate }",
         "        \"\"\" }",
         "    Function ChangeSysdate4 String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bFound",
         "        tTokenizer TokenizerData",
         "        tToken Token",
         "",
         "        Get pTokenizer to TokenizerData",
         "        Get IsCommentLineOrBlank sLine to bFound",
         "        If (TokenizerData.bLineIsReady = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move TokenizerData.FirstLeftCommand to Token",
         "        Move (Lowercase(Token.sCode) = Lowercase(CS_Sysdate4)) to bFound",
         "        If (bFound = False) Begin",
         "            Move TokenizerData.SecondLeftCommand to Token",
         "            Move (Lowercase(Token.sCode) = Lowercase(CS_Sysdate4)) to bFound",
         "            If (bFound = False) Begin",
         "                Function_Return False",
         "            End",
         "        End",
         "",
         "        Move (Replace(\"4\", sLine, \"\")) to sLine",
         "        Function_Return True",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeTrimCommandToFunction",
       "iSourceLines": 43,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes lecacy Trim command with function Trim.",
         "        Example: Trim sVal to sVal -> Move (Trim(sVal)) to sVal",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: Trim command to function Trim }",
         "        \"\"\" }",
         "    Function ChangeTrimCommandToFunction String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged bFound",
         "        Integer iItem iPos",
         "        tTokenizer TokenizerData",
         "        String sVarName sKeyword sKeywordLC sLineLC",
         "",
         "        Get pTokenizer to TokenizerData",
         "        Get IsCommentLineOrBlank sLine to bFound",
         "        If (TokenizerData.bLineIsReady = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Get IsKeywordInLine CS_Trim TokenizerData.asLineTokens to bFound",
         "        If (bFound = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move False to bChanged",
         "        Move CS_Trim              to sKeyword",
         "        Move (Lowercase(CS_Trim)) to sKeywordLC",
         "        Move (Lowercase(sLine))   to sLineLC",
         "        Move (SearchArray(sKeywordLC, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        Move TokenizerData.asLineTokens[iItem + 1] to sVarName",
         "        If (sVarName = \"\") Begin",
         "            Function_Return False",
         "        End",
         "        Move (Pos(sKeywordLC, sLineLC)) to iPos",
         "        If (iPos <> 0) Begin",
         "            Move (Replace(sKeyword, sLine, \"\")) to sLine",
         "            Move (Replace(CS_S + sVarName + CS_S, sLine, \"\")) to sLine",
         "            Move (Insert(CS_Move + \" (\" + CS_Trim + \"(\" + String(sVarName) + \")) \", sLine, iPos)) to sLine",
         "            Move True to bChanged",
         "        End",
         "",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeUClassToRefClass",
       "iSourceLines": 40,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy Get Create U_Class to: Get Create (RefClass(Class))",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: 'Create U_Class' to 'Create (RefClass(Class))' }",
         "        \"\"\" }",
         "    Function ChangeUClassToRefClass String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged bValid bIgnore",
         "        String sTest sClassName sOldStyle sNewStyle",
         "        Integer iPos",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        Move False to bChanged",
         "        Move \"\" to sClassName",
         "        Move (Lowercase(sLine)) to sTest",
         "        Move (Replaces(Character(9), sTest, CS_S)) to sTest \/\/ tab",
         "        Get TrimInsideSpaces sTest to sTest",
         "        \/\/ Two lines which are mostly for protection when running DfRefactor on the DfRefactor code itself",
         "        Get RemoveComments (&sTest)     to bIgnore \/\/ Don't rewrite this in a comment",
         "        Get RemoveStringsFromLine sTest to sTest   \/\/ If this is in a string then obviously leave it alone too",
         "        If (Pos(\" create u_\", sTest)) Begin",
         "            Move (Lowercase(sLine)) to sTest",
         "            Move (Pos(\"u_\", sTest)) to iPos",
         "            Get IsValidClassCharacter sTest iPos to bValid",
         "            While (bValid)",
         "                Move (sClassName + Mid(sLine, 1, iPos)) to sClassName",
         "                Increment iPos",
         "                Get IsValidClassCharacter sTest iPos to bValid",
         "            Loop",
         "        End",
         "        If (sClassName <> \"\") Begin",
         "            Move True to bChanged",
         "            Move sClassName to sOldStyle",
         "            Move (Right(sClassName, Length(sClassName) - 2)) to sClassName \/\/ strip away the \"U_\"",
         "            Move (\"(RefClass(\" + sClassName + \"))\") to sNewStyle",
         "            Move (Replace(sOldStyle, sLine, sNewStyle)) to sLine",
         "        End",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ChangeZeroStringCommandToFunction",
       "iSourceLines": 12,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Changes legacy ZeroString command with function ZeroString.",
         "        Example: ZeroString iLength to sParameter --> Move (ZeroString(iLength)) to sParameter",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: ZeroString command to function }",
         "        \"\"\" }",
         "    Function ChangeZeroStringCommandToFunction String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged",
         "        Get SingleCommandSyntaxToFunction (&sLine) CS_ZeroString to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "EditorNormalizeCase",
       "iSourceLines": 28,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Adjusts the casing of all scopes and keywords to match the casing as defined in the language configuration.",
         "        This is a wrapper function for the cScintillaEdit editor.",
         "        A visible (paged) instantiation of the cScintillaEdit class is needed for this function to operate properly.",
         "        The DFRefactor program's 'Editor' view is used for this.",
         "        { MethodType = eEditorFunction }",
         "        { SummaryText = Changed: Proper Upper and lowercasing }",
         "        \"\"\" }",
         "    Function EditorNormalizeCase String[] ByRef asCode String sParameter Returns Boolean",
         "        Handle hoEditor",
         "        Boolean bOK bChanged",
         "        String[] asRefactoredCode",
         "        tRefactorSettings RefactorSettings",
         "",
         "        Get phoEditor to hoEditor",
         "        If (hoEditor = 0) Begin",
         "            Error \"phoEditor = 0 (Function: EditorNormalizeCase)\"",
         "            Function_Return 0",
         "        End",
         "",
         "        Set Changed_State of hoEditor to False",
         "        Send RefactorNormalizeCase of hoEditor",
         "        Send PumpMsgQueue of Desktop",
         "        Get Changed_State of hoEditor to bChanged",
         "",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "EditorReIndent",
       "iSourceLines": 39,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Reindents the source code with the number of spaces specified in the sParameter variable.",
         "        This is a wrapper function for the cScintillaEdit editor.",
         "        A visible (paged) instantiation of the cScintillaEdit class is needed for this function to operate properly.",
         "        The DFRefactor program's 'Editor' view is used for this.",
         "        { MethodType = eEditorFunction }",
         "        { SummaryText = Reindented code }",
         "        { EnumList = 1,2,3,4,5,6,7,8}",
         "        { InitialValue = 4}",
         "        { HelpTopic = Select the indent size you want to use for spaces when indenting code",
         "        \\nand when breaking a line on rewriting a single line to multiple lines.",
         "        \\nIt is the same value that can be set on the Editor Settings dialog tab size.",
         "        \"\"\" }",
         "    Function EditorReIndent String[] ByRef asCode String sParameter Returns Boolean",
         "        Handle hoEditor",
         "        Boolean bOK bChanged",
         "        String[] asRefactoredCode",
         "        tRefactorSettings RefactorSettings",
         "",
         "        Get phoEditor to hoEditor",
         "        If (hoEditor = 0) Begin",
         "            Error \"phoEditor = 0 (Function: EditorReIndent)\"",
         "            Function_Return 0",
         "        End",
         "        \/\/ This is automatically set by the _InitTabSize message in cBaseFuncLib",
         "        \/\/ when the program is started.",
         "        If (num_arguments > 1) Begin",
         "            Set piTabSize of hoEditor to sParameter",
         "        End",
         "",
         "        Set Changed_State of hoEditor to False",
         "        Send RefactorReIndent of hoEditor",
         "        Send GotoLine of hoEditor 0",
         "        Send PumpMsgQueue of Desktop",
         "        Get Changed_State of hoEditor to bChanged",
         "",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "NormalizeArrayNotation",
       "iSourceLines": 12,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "         A array variable declaration like e.g. \"String [] asAddress\", is changed to: \"String[] asAddress\"",
         "         (Note the removed SPACE between \"String\" and \"[]\".",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Changed: NormalizeArrayNotation }",
         "        \"\"\" }",
         "    Function NormalizeArrayNotation String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged",
         "        Get _NormalizeArrayNotation (&sLine) to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemoveEndComments",
       "iSourceLines": 22,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes end of line comments for: End_Class, End_Object, End_Function & End_Procedure.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Removed: End comments }",
         "        \"\"\" }",
         "    Function RemoveEndComments String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bFound bChanged",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bIsBlank = True or TokenizerData.bIsComment = True or TokenizerData.sEndComment = \"\") Begin",
         "            Function_Return False",
         "        End",
         "        Get IsValidRemoveEndCommentsLine sLine to bFound",
         "        If (bFound = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Get RemoveComments (&sLine) to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemoveLocalKeyWord",
       "iSourceLines": 46,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes 'Local' keyword if present from procedures and functions variable declaration lines.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Removed: 'Local' key word }",
         "        \"\"\" }",
         "    Function RemoveLocalKeyWord String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged bFound bVariableDeclaration bLocalVariableArrayDeclaration",
         "        String sText",
         "        Integer iPos",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        Move sLine to sText",
         "        Get IsCommentLineOrBlank sLine to bFound",
         "        If (bFound = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        \/\/ Must be in a Procedure or Function:",
         "        If (pbInProcedure(Self) = False and pbInFunction(Self) = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Get IsVariableDeclarationLine  of ghoRefactorFuncLib TokenizerData.sOverstrikeLine  to bVariableDeclaration",
         "        Get IsVariableArrayDeclaration of ghoRefactorFuncLib TokenizerData.sOverstrikeLine to bLocalVariableArrayDeclaration",
         "        If (bVariableDeclaration = False and bLocalVariableArrayDeclaration = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move False to bChanged",
         "        Move (LTrim(sLine)) to sText",
         "        Move (Left(sText, 6)) to sText",
         "        Move (Lowercase(sText)) to sText",
         "        If (sText = (Lowercase(CS_Local) + CS_S)) Begin",
         "            \/\/ local must be the first word on the line.",
         "            \/\/ Now find the local statement and remove it.",
         "            Move (Lowercase(sLine)) to sText",
         "            Move (Pos((Lowercase(CS_Local) + CS_S), sText)) to iPos",
         "            If (iPos > 0) Begin",
         "                Move (Remove(sLine, iPos, 6)) to sLine",
         "                Move True to bChanged",
         "            End",
         "        End",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemoveMultipleBlankLines",
       "iSourceLines": 65,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes blank lines if more than xx 'Max blank lines'",
         "        Removes consecutive empty blank lines if more than sParameter value.",
         "        Takes a source file as a string array as a parameter.",
         "        Returns the passed string array with removed duplicated empty lines.",
         "        { MethodType = eOtherFunction }",
         "        { SummaryText = Removed: Consecutive blank Lines }",
         "        { EnumList = 1,2,3,4,5,6}",
         "        { InitialValue = 2 }",
         "        { HelpTopic = Select max number of consecutive blank lines allowed in source files. }",
         "        \"\"\" }",
         "    Function RemoveMultipleBlankLines String[] ByRef asCode String sParameter Returns Integer",
         "        String[] asCodeOut",
         "        Integer iCount iSize iCurrentNoOfEmptyLines iEmptyLines iMaxNoOfEmptyLines",
         "        String sLine",
         "        Boolean bImageStart bImageEnd bMakeImageTest",
         "",
         "        Move False to bImageStart",
         "        Move False to bImageEnd",
         "        Move True  to bMakeImageTest",
         "        Move 0 to iCurrentNoOfEmptyLines",
         "        Move sParameter to iMaxNoOfEmptyLines",
         "",
         "        Move (SizeOfArray(asCode)) to iSize",
         "        Decrement iSize",
         "",
         "        For iCount from 0 to iSize",
         "            Move (Trim(asCode[iCount])) to sLine",
         "",
         "            If (bMakeImageTest = True) Begin",
         "                If (bImageStart = False and bImageEnd = False) Begin",
         "                    Get IsImageStart sLine to bImageStart",
         "                End",
         "            End",
         "",
         "            If (bImageStart = False and bImageEnd = False) Begin",
         "                If (sLine = \"\") Begin",
         "                    Increment iCurrentNoOfEmptyLines",
         "                End",
         "                Else Begin",
         "                    Move 0 to iCurrentNoOfEmptyLines",
         "                End",
         "            End",
         "            If (iCurrentNoOfEmptyLines <= iMaxNoOfEmptyLines) Begin",
         "                Move asCode[iCount] to asCodeOut[SizeOfArray(asCodeOut)]",
         "            End",
         "",
         "            If (bMakeImageTest = True) Begin",
         "                If (bImageStart = True) Begin",
         "                    Get IsImageEnd sLine to bImageEnd",
         "                    If (bImageEnd = True) Begin",
         "                        Move False to bImageStart",
         "                        Move False to bImageEnd",
         "                        Move False to bMakeImageTest",
         "                    End",
         "                End",
         "            End",
         "        Loop",
         "",
         "        Move (SizeOfArray(asCode) - SizeOfArray(asCodeOut)) to iEmptyLines",
         "        Move asCodeOut to asCode",
         "",
         "        Function_Return iEmptyLines",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemoveOldStudioMarkers",
       "iSourceLines": 92,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes legacy IDE markers '\/\/AB-Store' etc.",
         "        Returns True if at least one legacy IDE (Studio) source code marker was found.",
         "        { MethodType = eRemoveFunction }",
         "        { SummaryText = Removed: Legacy IDE markers }",
         "        \"\"\" }",
         "    Function RemoveOldStudioMarkers String sLine Returns Boolean",
         "        Boolean bFound",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        Move False to bFound",
         "        Move (Trim(sLine)) to sLine",
         "",
         "        Case Begin",
         "            Case (sLine = \"\/\/AB-IgnoreStart\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-IgnoreEnd\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-StoreStart\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-StoreEnd\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-StoreTopStart\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-StoreTopEnd\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-PanelStoreTopStart\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-PanelStoreTopEnd\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-PanelStoreStart\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-PanelStoreEnd\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-ClientStoreTopStart\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-ClientStoreTopEnd\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-ClientStoreStart\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-ClientStoreEnd\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-DDOStart\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-DDOEnd\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (Left(sLine, 6) = \"\/\/AB\/ \")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-MenuPackage\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-End\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-ToolbarPackage\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-ViewStart\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-ViewEnd\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/AB-StatusBarPackage\")",
         "                Move True to bFound",
         "                Case Break",
         "            Case (sLine = \"\/\/IDE-FileType=ftApplication\")",
         "                Move True to bFound",
         "                Case Break",
         "        Case End",
         "",
         "        Function_Return bFound",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemoveProjectObjectStructure",
       "iSourceLines": 57,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes legacy Register_Object structures on top of e.g. view files.",
         "        It removes old style Studio 'Project Object Structures\"",
         "        It does not do so for WebApp (*.wo) files.",
         "        { MethodType = eRemoveFunction }",
         "        { SummaryText = Removed: Register_Object structures }",
         "        \"\"\" }",
         "    Function RemoveProjectObjectStructure String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bWriteLine bRegisterAllObjectsStart bRegisterAllObjectsEnd",
         "        Boolean bProjectObjectStructureStart bProjectObjectStructureEnd",
         "        String[] asObjectNames",
         "        tTokenizer TokenizerData",
         "",
         "        Move True to bWriteLine",
         "        Get pTokenizer to TokenizerData",
         "        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsVariableDeclaration = True or TokenizerData.bIsInCommand = True or ;",
         "            TokenizerData.bIsInClass = True or TokenizerData.bIsInImage = True or TokenizerData.bIsInFunction = True or ;",
         "            TokenizerData.bIsInProcedure = True or TokenizerData.bIsInDF23MultiLineString = True) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Get pbRegisterAllObjectsStart     to bRegisterAllObjectsStart",
         "        Get pbRegisterAllObjectsEnd       to bRegisterAllObjectsEnd",
         "        Get pbProjectObjectStructureStart to bProjectObjectStructureStart",
         "        Get pbProjectObjectStructureEnd   to bProjectObjectStructureEnd",
         "        Get pasObjectNames                to asObjectNames",
         "",
         "        If (bRegisterAllObjectsEnd = False) Begin",
         "            If (bRegisterAllObjectsStart = False) Begin",
         "                Get IsRegisterAllObjectsStart sLine to bRegisterAllObjectsStart",
         "                Set pbRegisterAllObjectsStart        to bRegisterAllObjectsStart",
         "            End",
         "            If (bRegisterAllObjectsStart = True) Begin",
         "                Get IsRegisterObjectInArray sLine asObjectNames to bWriteLine",
         "                Move False to bProjectObjectStructureStart",
         "                Set           pbProjectObjectStructureStart to False",
         "            End",
         "            If (bRegisterAllObjectsStart = False and bProjectObjectStructureEnd = False and bProjectObjectStructureStart = False) Begin",
         "                Get IsProjectObjectStructureStart sLine to bProjectObjectStructureStart",
         "                Set pbProjectObjectStructureStart       to bProjectObjectStructureStart",
         "            End",
         "            If (bProjectObjectStructureStart = True) Begin",
         "                Get IsProjectObjectStructureLine sLine (&asObjectNames) to bWriteLine",
         "            End",
         "            Get IsRegisterAllObjectsEnd sLine to bRegisterAllObjectsEnd",
         "            If (bRegisterAllObjectsEnd = True) Begin",
         "                Send ClearProjectObjectStructureProperties",
         "                \/\/ This means that we won't bother with the rest of the file.",
         "                Set pbRegisterAllObjectsEnd to True",
         "            End",
         "        End",
         "        If (bWriteLine = False) Begin",
         "            Move \"\" to sLine",
         "        End",
         "        Function_Return (bWriteLine = False)",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemovePropertyPrivate",
       "iSourceLines": 11,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes 'Private' keyword from Property declaration lines.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Removed: 'Private' property key word }",
         "        \"\"\" }",
         "    Function RemovePropertyPrivate String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged",
         "        Get RemovePropertyPublicPrivate (&sLine) \"private\" to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemovePropertyPublic",
       "iSourceLines": 11,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes 'Public' property members from property declaration lines.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Removed: 'Puplic' property key word }",
         "        \"\"\" }",
         "    Function RemovePropertyPublic String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bChanged",
         "        Get RemovePropertyPublicPrivate (&sLine) \"public\" to bChanged",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemoveSansSerif",
       "iSourceLines": 20,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes \"MS Sans Serif\" font source lines.",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Removed: 'MS Sans Serif' lines }",
         "        \"\"\" }",
         "    Function RemoveSansSerif String sLine Returns Boolean",
         "        String sTest",
         "        Boolean bWriteLine",
         "",
         "        Move False to bWriteLine",
         "        Move (Lowercase(Trim(sLine))) to sTest",
         "        Move (Replaces(CS_S, sTest, \"\"))  to sTest",
         "        Move (Replaces(\"'\", sTest, \"*\")) to sTest",
         "        Move (Replaces('\"', sTest, \"*\")) to sTest",
         "        If (sTest contains 'settypefaceto*mssansserif*') Begin",
         "            Move True to bWriteLine",
         "        End",
         "        Function_Return bWriteLine",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemoveStudioGeneratedComments",
       "iSourceLines": 77,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes old Studio generated comments lines.",
         "        Examples:",
         "        \/\/ fires when the button is clicked",
         "        \/\/OnChange is called on every changed character",
         "        \/\/ Visual DataFlex xx.x Client Size Adjuster",
         "        \/\/ Visual DataFlex xx.x Migration Utility",
         "        ...and so on",
         "        { MethodType = eRemoveFunction }",
         "        { SummaryText = Removed: Studio generated comments }",
         "        \"\"\" }",
         "    Function RemoveStudioGeneratedComments String ByRef sLine Returns Boolean",
         "        String sText sComment sComment2",
         "        Boolean bFound bChanged",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        Move False to bChanged",
         "        Move (Trim(sLine)) to sText",
         "        If (sText = \"\" or sText = CS_CommentSymbol or sText contains (CS_CommentSymbol + \"AB\") or TokenizerData.bIsComment = False) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move \"fires when the button is clicked\" to sComment",
         "        Get IsStudioGeneratedComment sLine sComment to bFound",
         "        If (bFound = True) Begin",
         "            Move \"\" to sLine",
         "            Function_Return True",
         "        End",
         "",
         "        Move \"onchange is called on every changed character\" to sComment",
         "        Get IsStudioGeneratedComment sLine sComment to bFound",
         "        If (bFound = True) Begin",
         "            Move \"\" to sLine",
         "            Function_Return True",
         "        End",
         "",
         "        Move \"visual dataflex\"      to sComment",
         "        Move \"client size adjuster\" to sComment2",
         "        Get IsStudioGeneratedComment sLine sComment sComment2 to bFound",
         "        If (bFound = True) Begin",
         "            Move \"\" to sLine",
         "            Function_Return True",
         "        End",
         "",
         "        Move \"visual dataflex\"    to sComment",
         "        Move \"migration utility,\" to sComment2",
         "        Get IsStudioGeneratedComment sLine sComment sComment2 to bFound",
         "        If (bFound = True) Begin",
         "            Move \"\" to sLine",
         "            Function_Return True",
         "        End",
         "",
         "        Move \"If you set Current_radio you must set this after the\" to sComment",
         "        Get IsStudioGeneratedComment sLine sComment to bFound",
         "        If (bFound = True) Begin",
         "            Move \"\" to sLine",
         "            Function_Return True",
         "        End",
         "",
         "        Move \"radio objects have been created AND after Notify_select_State has been\" to sComment",
         "        Get IsStudioGeneratedComment sLine sComment to bFound",
         "        If (bFound = True) Begin",
         "            Move \"\" to sLine",
         "            Function_Return True",
         "        End",
         "",
         "        Move \"created. i.e. Set in bottom-code at end!!\" to sComment",
         "        Get IsStudioGeneratedComment sLine sComment to bFound",
         "        If (bFound = True) Begin",
         "            Move \"\" to sLine",
         "            Function_Return True",
         "        End",
         "",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemoveTrailingSpaces",
       "iSourceLines": 18,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes spaces at the end of lines (trailing spaces).",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Removed: Spaces at end of line }",
         "        \"\"\" }",
         "    Function RemoveTrailingSpaces String ByRef sLine Returns Boolean",
         "        Integer iBefore iAfter",
         "        Boolean bChanged",
         "        tTokenizer TokenizerData",
         "",
         "        Move (Length(sLine))     to iBefore",
         "        Move (RTrim(sLine))      to sLine",
         "        Move (Length(sLine))     to iAfter",
         "        Move (iBefore <> iAfter) to bChanged",
         "",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RemoveUnusedLocals",
       "iSourceLines": 26,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Removes variables from functions and procedures that aren't used.",
         "        A limitation is that it does not remove unused *struct* variables.",
         "        Pass a source file as a string array.",
         "        Removes all unusad locally defined, in Procedures & Functions, for the",
         "        passed string array. Returns number of removed unused local variables.",
         "        { MethodType = eOtherFunction }",
         "        { SummaryText = Removed: Unused local variables }",
         "        \"\"\" }",
         "    Function RemoveUnusedLocals String[] ByRef asCode String sParameter Returns Integer",
         "        Handle ho",
         "        Integer iRetval",
         "",
         "        Get Create (RefClass(cRemoveUnusedLocals)) to ho",
         "        If (ho = 0) Begin",
         "            Error \"Could not create cRemoveUnusedLocals object.\"",
         "            Function_Return 0",
         "        End",
         "",
         "        Set piNoOfUnusedLocalVariables of ho to 0",
         "        Get RemoveUnusedLocals of ho (&asCode) to iRetval",
         "        Send Destroy of ho",
         "",
         "        Function_Return iRetval",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "ReportUnusedSourceFiles",
       "iSourceLines": 33,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "      Reports Only! Makes no changes to the source code.",
         "      Check all files in the current workspace to see if they are used, else list them in a report.",
         "      Pass an array with *all source files*",
         "      Returns a list of unused files. See the DFRefactor programs: 'Other Log Files' toolbar button for results.",
         "      { MethodType = eReportFunction }",
         "      { SummaryText = Report created: Files that are never used }",
         "      \"\"\" }",
         "    Function ReportUnusedSourceFiles String[] ByRef asFiles String sParameter Returns Integer",
         "        Handle ho",
         "        Integer iRetval",
         "        String sLogFile",
         "        String[] asOtherLogFiles",
         "        tRefactorSettings RefactorSettings",
         "",
         "        Get Create (RefClass(cUnusedSourceFiles)) to ho",
         "        If (ho = 0) Begin",
         "            Error \"Could not create cUnusedSourceFiles object.\"",
         "            Function_Return 0",
         "        End",
         "",
         "        Get pRefactorSettings to RefactorSettings",
         "        Get FindUnusedSourceFiles of ho RefactorSettings.FileData.asFullFileNames to iRetval",
         "",
         "        If (iRetval <> 0) Begin",
         "            Get pasOtherLogFiles to asOtherLogFiles",
         "            Get psLogFile of ho to asOtherLogFiles[SizeOfArray(asOtherLogFiles)]",
         "            Set pasOtherLogFiles to asOtherLogFiles",
         "        End",
         "        Send Destroy of ho",
         "        Function_Return iRetval",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "RestyleDDOs",
       "iSourceLines": 65,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "      The naming style of data-dictionaries *objects* over time has changed.",
         "      The new style is:",
         "       Object o<tablename>_DD is a c<TableName>Datadictionary",
         "      They also have a switch so you can keep on using the legacy style name which is:",
         "       Object o<tablename>_DD is a <tablename>_Datadictionary",
         "",
         "      However before VDF12, this is how it looked:",
         "       Object <tableName>_DD is a <tablename>_Datadictionary",
         "",
         "      This caused tremendous headaches as due to the extra \"o\" we ended up with name clashes",
         "      all over the place. Copying old code into new views\/dialogs simply breaks and if your",
         "      codebase has mixed styles then the compiler will not catch that.",
         "      A code nightmare.",
         "",
         "      Examples:",
         "       <TableName>_DD - o<TableName>DD (eDDStudioStyle)",
         "       <TableName>_DD - o<TableName>_dd (neDDNewStyle)",
         "      { MethodType = eOtherFunctionAll }",
         "      { SummaryText = Renamed DataDictionary objects }",
         "      { EnumList = \"eDDStudioStyle, eDDNewStyle, eDDOldStyle\" }",
         "      { InitialValue = eDDNewStyle }",
         "      { HelpTopic = Valid values;",
         "      \\neDDStudioStyle - o<TableName>DD",
         "      \\neDDNewStyle - o<TableName>_dd",
         "      \\noDDOldStyle - <TableName>_DD }",
         "      \"\"\" }",
         "    Function RestyleDDOs String[] ByRef asFiles String sParameter Returns Integer",
         "        String sHomePath",
         "        Handle ho",
         "        Integer iRetval iSize iCount eDDOStyle",
         "        tRefactorSettings RefactorSettings",
         "",
         "        If (SizeOfArray(asFiles) <= 0) Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Get Create (RefClass(cDDOReStyler)) to ho",
         "        If (ho = 0) Begin",
         "            Error \"Could not create cDDORestyler object (Function: RestyleDDOs)\"",
         "            Function_Return 0",
         "        End",
         "",
         "        If (num_arguments > 1) Begin",
         "            Move sParameter to eDDOStyle",
         "        End",
         "",
         "        \/\/ Path for the workspace we are refactoring:",
         "",
         "        \/\/ ToDo: Check e.g. this code on how to set a temp filelist path etc:",
         "        \/\/  Procedure LoadTablesList Integer iSortBy String sFilter",
         "        \/\/ Or perhaps do that in a \"Procedure Set psHomePath\" of the class??",
         "        Get psHomePath of ghoApplication to sHomePath",
         "        If (sHomePath = \"\") Begin",
         "            Get psHome of (phoWorkspace(ghoApplication)) to sHomePath",
         "        End",
         "        Set psHomePath  of ho to sHomePath",
         "        Set peDDOStyle  of ho to eDDOStyle",
         "        Set pasAllFiles of ho to asFiles",
         "        Get StartDDORestyler of ho to iRetval",
         "        Send Destroy of ho",
         "",
         "        Function_Return iRetval",
         "    End_Function"
       ]
     },
     {
       "sFunctionName": "SplitInlineIfElseLine",
       "iSourceLines": 76,
       "CodeArray": [
         "    { Published = True }",
         "    { Description = \"\"\"",
         "        Splits If\/Else single lines to If\/Else - Begin constructs.",
         "        It does *not* split if the last word is = \"Break\", as that could",
         "        change the program logic.",
         "        The function accepts a parameter controlling the If\/Else or Begin\/End block constructs.",
         "        Valid sParameters, See: EnumList;",
         "        { MethodType = eStandardFunction }",
         "        { SummaryText = Split If\/Else line }",
         "        { EnumList = \"eSplitBySpaceAndSemicolon, eSplitBySemicolon, eSplitToBeginEndBlock\" }",
         "        { InitialValue = eSplitToBeginEndBlock }",
         "        { HelpTopic = Valid values;",
         "        \\neSplitBySpaceAndSemicolon - Split line with space and semicolon",
         "        \\neSplitBySemicolon - Split line with semicolon",
         "        \\neSplitToBeginEndBlock - Use a Begin\/End block }",
         "        \"\"\" }",
         "    Function SplitInlineIfElseLine String ByRef sLine String sParameter Returns Boolean",
         "        Boolean bStop bChanged bFound",
         "        Integer iIndent eSplitBy iTabSize iItem",
         "        String  sText sToken",
         "        tTokenizer TokenizerData",
         "",
         "        Get pTokenizer to TokenizerData",
         "        Move (SearchArray(CS_If, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "        If (iItem = -1) Begin",
         "            Move (Trim(sLine)) to sText",
         "            Move (Left(sText, 3)) to sText",
         "            Move (Lowercase(sText) = Lowercase(CS_If)) to bFound",
         "            If (bFound = False) Begin",
         "                Function_Return False",
         "            End",
         "        End",
         "",
         "        \/\/ Note: We do *not* change the line if it ends with a \"Break\",",
         "        \/\/       because that would change the logic of the program.",
         "        Move (TokenizerData.iTokenCount) to iItem",
         "        Move TokenizerData.asLineTokens[iItem -1] to sToken",
         "        If (Lowercase(sToken) = \"break\") Begin",
         "            Function_Return False",
         "        End",
         "",
         "        Move False to bChanged",
         "        Move sParameter to eSplitBy",
         "        Get piTabSize to iTabSize",
         "        If (eSplitBy = eSplitToBeginEndBlock) Begin",
         "            Move (SearchArray(CS_Begin, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem",
         "            If (iItem <> -1) Begin",
         "                Function_Return False",
         "            End",
         "        End",
         "",
         "        Move (LTrim(sLine))     to sText",
         "        Move (Pos(sText,sLine) - 1) to iIndent",
         "        Move (Left(sText, 3))   to sText",
         "        Move (Lowercase(sText)) to sText",
         "        If (sText = (Lowercase(CS_If) + CS_S)) Begin",
         "            Get IsLineEndSemiColonOrBegin TokenizerData.sOverstrikeLine to bStop",
         "            If (bStop = False) Begin",
         "                \/\/ It's one of those single line if statements, break it up",
         "                Move (Lowercase(sLine)) to sText",
         "                Get BreakupCompoundStatement iIndent (&sLine) eSplitBy iTabSize to bChanged",
         "            End",
         "        End",
         "        Else Begin",
         "            Move (LTrim(sLine))     to sText",
         "            Move (Left(sText, 5))   to sText",
         "            Move (Lowercase(sText)) to sText",
         "            If (sText = (Lowercase(CS_Else) + CS_S)) Begin",
         "                Get IsLineEndSemiColonOrBegin TokenizerData.sOverstrikeLine to bStop",
         "                If (bStop = False) Begin",
         "                    Get BreakupCompoundStatement iIndent (&sLine) eSplitBy iTabSize to bChanged",
         "                End",
         "            End",
         "        End",
         "        Function_Return bChanged",
         "    End_Function"
       ]
     }
   ],
   "Unit": [
     {
       "sFunctionName": "Tokenizer",
       "iSourceLines": 696,
       "UnitArray": [
         "    Object oTokenizer is a cTestFixture",
         "        Set psFunctionName to \"Tokenizer\"",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move \"This is a quoted string\" to sVal' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bHasOverstrikeChars = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"Move 'Single quoted string' to sVal\" to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bHasOverstrikeChars = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"Move 'Single quoted string' to sVal\" to sLine",
         "            Move (\"Move '\" + (FillString(CS_E, 20)) + \"' to sVal\") to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move \"This is a test string on multiple lines;'      to sLine",
         "            Move ('Move \"' + (FillString(CS_U, (Length(sLine) -7))) + String(\";\")) to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine       to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_5",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move \"Double quoted string\" to sVal' to sLine",
         "            Move ('Move \"' + FillString(CS_U, 20) + '\" to sVal') to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_6",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '           \/\/Move WindowIndex to FieldIndex' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsComment = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_7",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move aA to sB \/\/This is an end comment' to sLine",
         "            Move '\/\/This is an end comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sEndComment sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_8",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/* Move (iA \/ iB) to nC' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineComment = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_9",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/* Move (iA \/ iB) to nC' to sLine",
         "            Move '#######################' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_10",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '  Continuation of a DF23 multi-line comment' to sLine",
         "            Move '###########################################' to sExpected",
         "            Set pbIsInDF23MultiLineComment of ghoRefactorFuncLib to True",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_11",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move (iA \/ iB) to nC *\/' to sLine",
         "            Set pbIsInDF23MultiLineComment of ghoRefactorFuncLib to True",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineComment = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_12",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/* Move (iA \/ iB) to nC' to sLine",
         "            Move '#######################' to sExpected",
         "            Set pbIsInDF23MultiLineComment of ghoRefactorFuncLib to True",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_13",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move (iA \/ iB) to nC *\/' to sLine",
         "            Move '#######################' to sExpected",
         "            Set pbIsInDF23MultiLineComment of ghoRefactorFuncLib to True",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_14",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move (iA \/ iB) to nD' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineComment = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_15",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move CS_CRLF to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsBlank = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_16",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"\" to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsBlank = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_17",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/MyPageName' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInImage = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_18",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/*' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bLineIsReady = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_19",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/\/  \/*' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInImage = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_20",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Send Info_Box \"This is a text string with an embedded semi-colon ;\"' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bHasEndSemiColon = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_21",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move \"This is a source line with an ending semi-colon\" ;' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bHasEndSemiColon = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_22",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If bOK ;  \/\/ Expand vDataType in the debugger' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bHasEndSemiColon = True)",
         "        End_Procedure",
         "",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_23",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '@\"Hello World' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineString = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_24",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '@\"Hello World' to sLine",
         "            Move ('@\"' + FillString(CS_U, 11))  to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_241",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If \"Support Classes\" in sShow Set pbDontShowMNS of (VDFCLS_DD(Self)) to True' to sLine",
         "            Move ('If \"' + FillString(CS_U, 15) + '\" in sShow Set pbDontShowMNS of (VDFCLS_DD(Self)) to True') to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineString = False)",
         "        End_Procedure",
         "",
         "        \/\/ The pbIsInDF23MultiLineString property should now be = True (after the Tokenizer_IsMultiLineStringStart_1_1 test)",
         "        {Published = True}",
         "        Procedure Tokenizer_25",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    we will MOVE our warehouse to Lincoln next month.' to sLine",
         "            Move (FillString(CS_U, Length(Trim(sline)))) to sExpected",
         "            Set piMultiLineStringType of ghoRefactorFuncLib to MLS_AtQuoteOpen",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOverstrikeLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_26",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    we will MOVE our warehouse to Lincoln next month;' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineString = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_27",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"'    we will MOVE our warehouse to Lincoln next month;' ;\" to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bHasEndSemiColon = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_28",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Get SQLExecDirect of ghoSQLExecutor @SQL\"\"\"' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineString = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_29",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move @SQL\"\"\" SELECT * FROM Customer WHERE Customer.Name = \"John Doe\" \"\"\" to sSQL \/\/ End comment' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineString = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_30",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move \"@SQL\" to sString \/\/ And an end comment' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineString = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_31",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move \"This is a string\" to sText' to sLine",
         "            Set piMultiLineStringType of ghoRefactorFuncLib to MLS_None",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineString = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_32",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/\/ This is a comment' to sLine",
         "            Set piMultiLineStringType of ghoRefactorFuncLib to MLS_AtQuote",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInDF23MultiLineString = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_33",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/\/ Function MyFunction String sA Returns Boolean ' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInFunction = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_34",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Function MyFunction String sA Returns Boolean ' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInFunction = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_35",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move \"Function MyFunction String sA Returns Boolean\" to sMyString' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInFunction = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_36",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/\/ Procedure MyProc String sLine' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInProcedure = False)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_37",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Procedure MyProc String sLine' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInProcedure = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_38",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '#COMMAND WebPublishProcedure R .' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsInCommand = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_39",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '         Move aA to sB \/\/This is an end comment' to sLine",
         "            Move '         ' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sIndentation sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_40",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move ('      \/\/Move Windowindex to FieldIndex') to sLine",
         "            Move '       ' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bLineIsReady = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_41",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Indicate [Found] as (True = bTrue)' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.BooleanIndicator.bHasIndicateCommand = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_42",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If [Found] Indicate Err as (True = bTrue)' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.BooleanIndicator.bHasIndicateCommand = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_43",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Indicate [Found] as (True = bTrue)' to sLine",
         "            Move 'Found' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.BooleanIndicator.FirstBoolean.sCode = sExpected)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_44",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '[Found] Move [Not Seqeof] to [Select]' to sLine",
         "            Move 'Found' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.BooleanIndicator.FirstBoolean.sCode = sExpected)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_45",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move [Not Select] to [Found]' to sLine",
         "            Move 'Found' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.BooleanIndicator.ToBoolean.sCode = sExpected)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_46",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Get phoHandle of (oMyObject(Current_Object)) to Found' to sLine",
         "            Move '(oMyObject(Current_Object))' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.OfStatement.sCode sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_47",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Get psString of ghoApplication to sString' to sLine",
         "            Move 'ghoApplication' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.OfStatement.sCode sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_48",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move (iA * iB) to iC' to sLine",
         "            Move 'iC' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.ToStatement.sCode sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_49",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move \"New Label\" to (Label(phoMainPanel(ghoApplication)))' to sLine",
         "            Move '(Label(phoMainPanel(ghoApplication)))' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.ToStatement.sCode sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_50",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move \"New Label\" to (Label(phoMainPanel(ghoApplication))) \/\/ Some comment' to sLine",
         "            Move '(Label(phoMainPanel(ghoApplication)))' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.ToStatement.sCode sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_51",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If ((iA * iB > 10) + (iD + iE) > 100) Move (iA \/ iB) to nNumber \/\/ Some comment' to sLine",
         "            Move 'If' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.FirstLeftCommand.sCode sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_52",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If ((iA * iB > 10) + (iD + iE) > 100) Move (iA \/ iB) to nNumber \/\/ Some comment' to sLine",
         "            Move 'Move' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.SecondLeftCommand.sCode sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_55",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Get psAppSrcPath of (phoWorkspace(ghoApplication)) to sPath \/\/ Some comment' to sLine",
         "            Move '(phoWorkspace(ghoApplication))' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sOfExpression sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_56",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'For iChar from 1 to (iPos - 1) \/\/ Some comment' to sLine",
         "            Move '(iPos - 1)' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual TokenizerData.sToExpression sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_57",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    If iA eq iB Move (Trim (FlexErrs.Error_Descr) * Trim (Flexerrs.Note)) to vData[iRow][2] \/\/ Name: ZipCode_City, Length: 100, Datatype: String' to sLine",
         "            Move 'Move' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.SecondLeftCommand.sCode = sExpected)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_58",
         "            String sLine sExpected",
         "            Boolean bSame",
         "            tTokenizer TokenizerData",
         "            tExpression[] aExpected",
         "",
         "            Move 'If ((iA * iB > 10) + (iD + iE) > 100) Move (iA \/ iB) to nNumber \/\/ Some comment' to sLine",
         "            Move 0  to aExpected[0].eExpressionMode",
         "            Move 4  to aExpected[0].iStartPos",
         "            Move 34 to aExpected[0].iLength",
         "            Move \"((iA * iB > 10) + (iD + iE) > 100)\" to aExpected[0].sExpression",
         "            Move \"((iA * iB > 10) + (iD + iE) > 100)\" to aExpected[0].sExpressionOS",
         "            Move \"(iA * iB > 10) + (iD + iE) > 100\"   to aExpected[0].sExpressionNP",
         "            Move \"((iA * iB > 10) + (iD + iE) > 100)\" to aExpected[0].sExpressionWS",
         "",
         "            Move 1  to aExpected[1].eExpressionMode",
         "            Move 44 to aExpected[1].iStartPos",
         "            Move 9  to aExpected[1].iLength",
         "            Move \"(iA \/ iB)\" to aExpected[1].sExpression",
         "            Move \"(iA \/ iB)\" to aExpected[1].sExpressionOS",
         "            Move \"iA \/ iB\"   to aExpected[1].sExpressionNP",
         "            Move \"(iA \/ iB)\" to aExpected[1].sExpressionWS",
         "",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Move (IsSameArray(TokenizerData.aExpressions, aExpected)) to bSame",
         "            Send Assert (bSame = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_59",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    If iA eq iB Move (Trim (FlexErrs.Error_Descr) * Trim (Flexerrs.Note)) to vData[iRow][2] \/\/ Name: ZipCode_City, Length: 100, Datatype: String' to sLine",
         "            Move '    If iA eq iB Move (Trim (FlexErrs.Error_Descr) * Trim (Flexerrs.Note)) to vData[iRow][2] \/\/ Name: ZipCode_City, Length: 100, Datatype: String' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.sLine = sExpected)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_60",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If iLV Ne 0 Mid sFAKT  to sFAKT (iLV+1) 1' to sLine",
         "            Move 'If iLV Ne 0 Mid sFAKT  to sFAKT (iLV+1) 1' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertSAreEqual sLine sExpected",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_61",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'tTokenizer TokenizerData' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (TokenizerData.bIsVariableDeclaration = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_62",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Kalle Oskar' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send AssertFalse (TokenizerData.bIsVariableDeclaration = True)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_63",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If code# eq 0 If tmp# ge 0 Begin' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Send Assert (SizeOfArray(TokenizerData.aExpressions) = 2)",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure Tokenizer_64",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If code# eq 0 If tmp# ge 0 Begin' to sLine",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            If (SizeOfArray(TokenizerData.aExpressions) = 1) Begin",
         "                Send AssertSAreEqual (TokenizerData.aExpressions[0].sExpression <> \"(code# eq 0)\")",
         "            End",
         "            Else Begin",
         "                Send AssertSAreEqual (TokenizerData.aExpressions[0].sExpression <> \"(code# eq 0)\" or TokenizerData.aExpressions[1].sExpression <> \"(tmp# ge 0)\")",
         "            End",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeCalcToMoveStatement",
       "iSourceLines": 65,
       "UnitArray": [
         "    Object oChangeCalcToMoveStatement is a cTestFixture",
         "        Set psFunctionName to \"ChangeCalcToMoveStatement\"",
         "",
         "        {Published = True}",
         "        { Description = \"Changes: 'Calc (iA * iB) to iC' to 'Move (iA * iB) to iC'\" }",
         "        Procedure ChangeCalcToMoveStatement_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '  Calc (iA * iB) to iC' to sLine",
         "            Move '  Move (iA * iB) to iC' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeCalcToMoveStatement of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeCalcToMoveStatement_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    MoveInt (iA * iB) to iC' to sLine",
         "            Move '    Move (iA * iB) to iC' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeCalcToMoveStatement of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeCalcToMoveStatement_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    MoveNum (nA * nB) to nC' to sLine",
         "            Move '    Move (nA * nB) to nC' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeCalcToMoveStatement of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeCalcToMoveStatement_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    MoveReal (rA * rB) to rC' to sLine",
         "            Move '    Move (rA * rB) to rC' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeCalcToMoveStatement of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeCalcToMoveStatement_5",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    MoveStr (\"Yes\" * \"and\") to sC' to sLine",
         "            Move '    Move (\"Yes\" * \"and\") to sC' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeCalcToMoveStatement of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeCurrent_ObjectToSelf",
       "iSourceLines": 40,
       "UnitArray": [
         "    Object oChangeCurrent_ObjectToSelf is a cTestFixture",
         "        Set psFunctionName to \"ChangeCurrent_ObjectToSelf\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeCurrent_ObjectToSelf_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move (piCurrentRow(Current_Object)) to iRow' to sLine",
         "            Move 'Move (piCurrentRow(Self)) to iRow' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeCurrent_ObjectToSelf of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeCurrent_ObjectToSelf_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move (piCurrentRow(Current_Object)) to (phoTestHandle(Current_Object))' to sLine",
         "            Move 'Move (piCurrentRow(Self)) to (phoTestHandle(Self))' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeCurrent_ObjectToSelf of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeCurrent_ObjectToSelf_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    Move OG_Current_Object to WindowIndex \/\/ not current_object' to sLine",
         "            Move '    Move OG_Current_Object to WindowIndex \/\/ not current_object' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeCurrent_ObjectToSelf of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeDfTrueDfFalse",
       "iSourceLines": 28,
       "UnitArray": [
         "    Object oChangeDfTrueDfFalse is a cTestFixture",
         "        Set psFunctionName to \"ChangeDfTrueDfFalse\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeDfTrueDfFalse_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move DFTrue to Found' to sLine",
         "            Move 'Move True to Found' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeDfTrueDfFalse of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeDfTrueDfFalse_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If ((Left(sRow,1)) ne \"#\") Move dfFalse to bRename' to sLine",
         "            Move 'If ((Left(sRow,1)) ne \"#\") Move False to bRename' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeDfTrueDfFalse of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeGetAddress",
       "iSourceLines": 52,
       "UnitArray": [
         "    Object oChangeGetAddress is a cTestFixture",
         "        Set psFunctionName to \"ChangeGetAddress\"",
         "",
         "        {Published = True}",
         "        Procedure GetAddress_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"    GetAddress of sString to pMyPointer\" to sLine",
         "            Move \"    Move (AddressOf(sString)) to pMyPointer\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeGetAddress of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure GetAddress_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \" Function GetAddress Returns String\" to sLine",
         "            Move \" Function GetAddress Returns String\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeGetAddress of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure GetAddress_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \" Entry_Item (GetAddress(oCustomer_DD))\" to sLine",
         "            Move \" Entry_Item (GetAddress(oCustomer_DD))\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeGetAddress of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure GetAddress_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"String structBytesRead      \/\/Actual bytes read - Should be integer but getAddress cannot find \" to sLine",
         "            Move \"String structBytesRead      \/\/Actual bytes read - Should be integer but getAddress cannot find \" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeGetAddress of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeIfNotCommandToExpression",
       "iSourceLines": 16,
       "UnitArray": [
         "    Object oChangeIfNotCommandtoExpression is a cTestFixture",
         "        Set psFunctionName to \"ChangeIfNotCommandToExpression\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeIfNotCommandToExpression_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    IFNOT Found Begin' to sLine",
         "            Move '    If (Not(Found)) Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeIfNotCommandToExpression of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeInsertCommandToFunction",
       "iSourceLines": 52,
       "UnitArray": [
         "    Object oChangeInsertCommandToFunction is a cTestFixture",
         "        Set psFunctionName to \"ChangeInsertCommandToFunction\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeInsertCommandToFunction_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move ' If sOne Eq \"A\" Insert \"_\" in sOne at 2' to sLine",
         "            Move ' If sOne Eq \"A\" Move (Insert(\"_\",sOne,2)) to sOne' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInsertCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInsertCommandToFunction_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   Insert \"   \" in sVar at 2' to sLine",
         "            Move '   Move (Insert(\"   \",sVar,2)) to sVar' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInsertCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInsertCommandToFunction_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   Replace sChr In sTag with (uppercase(sChr))' to sLine",
         "            Move '   Replace sChr In sTag with (uppercase(sChr))' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInsertCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInsertCommandToFunction_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"INSERT 'chmod 777 ' IN WK_CHAIN_ARG AT 1\" to sLine",
         "            Move \"Move (Insert('chmod 777 ',WK_CHAIN_ARG,1)) to WK_CHAIN_ARG\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInsertCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeInToContains",
       "iSourceLines": 162,
       "UnitArray": [
         "    Object oChangeInToContains is a cTestFixture",
         "        Set psFunctionName to \"ChangeInToContains\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    indicate Select as sSubString in sHostString \/\/ Comment' to sLine",
         "            Move '    indicate Select as (sHostString contains sSubString) \/\/ Comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    if sSubString in sHostString RunProgram' to sLine",
         "            Move '    if (sHostString contains sSubString) RunProgram' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Until sSubString in sHostString' to sLine",
         "            Move 'Until (sHostString contains sSubString)' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'While sSubString in sHostString' to sLine",
         "            Move 'While (sHostString contains sSubString)' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        \/\/ This test will fail because the logic assumes the source line to be of proper syntax,",
         "        \/\/ e.g. it needs to start with a command (or indicator + command).",
         "        {Published = True}",
         "        Procedure ChangeInToContains_5",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    If sSubString    in     sHostString Move True to bFound' to sLine",
         "            Move '    If (sHostString contains sSubString) Move True to bFound' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_6",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'if \".\" in a_number Move \"A\" to \"B\"' to sLine",
         "            Move 'if (a_number contains \".\") Move \"A\" to \"B\"' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_7",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'if \".\" in \"12.12\"' to sLine",
         "            Move 'if (\"12.12\" contains \".\")' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_8",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move (Replaces('`', 'if \"`\" in \"I`m okay\"', \"'\")) to sLine",
         "            Move (Replaces('`', 'if (\"I`m okay\" contains \"`\")', \"'\")) to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_9",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move (Replaces('`', 'if \"`\" in \"I`m okay\"', \"'\")) to sLine",
         "            Move (Replaces('`', 'if (\"I`m okay\" contains \"`\")', \"'\")) to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_10",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"If (Character(10)) in sValue RunProgram\" to sLine",
         "            Move \"If (sValue contains (Character(10))) RunProgram\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_11",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If \"Support Classes\" in sShow Set pbDontShowMNS of (VDFCLS_DD(Self)) to True' to sLine",
         "            Move 'If (sShow contains \"Support Classes\") Set pbDontShowMNS of (VDFCLS_DD(Self)) to True' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_12",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"IF NOT APM.BALANCE_TYPE IN 'BIP' MOVE 'I' TO APM.BALANCE_TYPE\" to sLine",
         "            Move \"IF NOT ('BIP' contains APM.BALANCE_TYPE) MOVE 'I' TO APM.BALANCE_TYPE\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeInToContains_13",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"[SELECT] INDICATE SELECT as BATCH.TRAN IN 'APINV,APCDT'\" to sLine",
         "            Move \"[SELECT] INDICATE SELECT as ('APINV,APCDT' contains BATCH.TRAN)\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeInToContains of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeLeftCommandToFunction",
       "iSourceLines": 16,
       "UnitArray": [
         "    Object oChangeLeftCommandToFunction is a cTestFixture",
         "        Set psFunctionName to \"ChangeLeftCommandToFunction\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeLeftCommandToFunction_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Left sPath  to sDir (iSepPos - 1)' to sLine",
         "            Move 'Move (Left(sPath, (iSepPos - 1))) to sDir' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLeftCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeLegacyIndicators",
       "iSourceLines": 582,
       "UnitArray": [
         "    Object oChangeLegacyIndicators is a cTestFixture",
         "        Set psFunctionName to \"ChangeLegacyIndicators\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Indicate Found as True' to sLine",
         "            Move 'Move (True) to Found' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Indicate [Found] as True' to sLine",
         "            Move 'Move (True) to Found' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [Select] Indicate Select as WindowIndex Eq FieldIndex' to sLine",
         "            Move '   If (Select) Move (WindowIndex Eq FieldIndex) to Select' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [Not Found] Indicate Select as WindowIndex Eq FieldIndex' to sLine",
         "            Move '   If (Not(Found)) Move (WindowIndex Eq FieldIndex) to Select' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_5",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"    Indicate Select as Windowindex Eq Fieldindex \/\/ Comment\" to sLine",
         "            Move \"    Move (Windowindex Eq Fieldindex) to Select \/\/ Comment\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_6",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"    If [False] Indicate Select as Windowindex Eq Fieldindex \/\/ Comment\" to sLine",
         "            Move \"    If (False) Move (Windowindex Eq Fieldindex) to Select \/\/ Comment\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_7",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"    If [False] Move (Windowindex Eq Fieldindex) to Select \/\/ Comment\" to sLine",
         "            Move \"    If (False) Move (Windowindex Eq Fieldindex) to Select \/\/ Comment\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_8",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [Found] Reread \/\/ End comment' to sLine",
         "            Move '   If (Found) Reread \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_9",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [not found]   reread' to sLine",
         "            Move '   If (not(found)) reread' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_10",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [Not Found] Move iA to iB \/\/ End comment' to sLine",
         "            Move '   If (Not(Found)) Move (iA) to iB \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_11",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [Found] Repeat \/\/ End comment' to sLine",
         "            Move '   While (Found) \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_13",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [not Seqeof] Repeat \/\/ End comment' to sLine",
         "            Move '   While (not(Seqeof)) \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_14",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [not Found] Repeat \/\/ End comment' to sLine",
         "            Move '   While (not(Found)) \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_15",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [Found] Loop \/\/ End comment' to sLine",
         "            Move '   Loop \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_16",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [not Seqeof] Loop \/\/ End comment' to sLine",
         "            Move '   Loop \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_17",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [Select] Until [Found] \/\/ End comment' to sLine",
         "            Move '   Until (Found) \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_18",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [not Found] While \/\/ End comment' to sLine",
         "            Move '   While (not(Found)) \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_19",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   While [not Found] \/\/ End comment' to sLine",
         "            Move '   While (not(Found)) \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_20",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   [not Found] Reread \/\/ End comment' to sLine",
         "            Move '   If (not(Found)) Reread \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_21",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   Constrain FlexErrs.Recnum gt 10 \/\/ End comment' to sLine",
         "            Move '   Constrain FlexErrs.Recnum gt 10 \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_22",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    [Found] Delete hTable \/\/ End comment' to sLine",
         "            Move '    If (Found) Delete hTable \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_23",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    [Not MyBoolean] Begin' to sLine",
         "            Move '    If (Not(MyBoolean)) Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_24",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    [Found ~Found] Begin' to sLine",
         "            Move '    If (Found and (Not(Found))) Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_25",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    [FindErr]  Move ( _(\"Lösenordet måste uppfylla följande villkor\") + \":\\n\\n\" + ;' to sLine",
         "            Move '    If (FindErr) Move ( _(\"Lösenordet måste uppfylla följande villkor\") + \":\\n\\n\" + ;' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_26",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    [~Debits] Begin' to sLine",
         "            Move '    If (Not(Debits)) Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_27",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"[SELECT] INDICATE SELECT as 'APINV,APCDT' IN BATCH.TRAN\" to sLine",
         "            Move \"If (SELECT) Move (BATCH.TRAN contains 'APINV,APCDT') to SELECT\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_28",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"[CLEAR_TR] DISPLAY (SYS.APDATE + 1) TO FREQ_DATE        \/\/ MOD 18 START\" to sLine",
         "            Move \"If (CLEAR_TR) DISPLAY (SYS.APDATE + 1) TO FREQ_DATE \/\/ MOD 18 START\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_29",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"[NOT CLEAR_TR] BLANKFORM SACLD\" to sLine",
         "            Move \"If (NOT(CLEAR_TR)) BLANKFORM SACLD\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_30",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"INDICATE IN_JOBSTREAM as REP_JOBSTREAM EQ 888888\" to sLine",
         "            Move \"Move (REP_JOBSTREAM EQ 888888) to IN_JOBSTREAM\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_31",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"INDICATE GST AS SYS.USE_GST EQ 'Y'\" to sLine",
         "            Move \"Move (SYS.USE_GST EQ 'Y') to GST\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_32",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"[GST] DISPLAY CTRLGST.END_DATE TO SAOTD\" to sLine",
         "            Move \"If (GST) DISPLAY CTRLGST.END_DATE TO SAOTD\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_33",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"[not GST] BLANKFORM SATEN THRU SAOTD\" to sLine",
         "            Move \"If (not(GST)) BLANKFORM SATEN THRU SAOTD\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_34",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '[FINDERR] SHOW_ERROR \"CTRLGST is not set up properly\"' to sLine",
         "            Move 'If (FINDERR) SHOW_ERROR \"CTRLGST is not set up properly\"' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_35",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"INDICATE TAX_YEND False\" to sLine",
         "            Move \"Move (False) to TAX_YEND\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_36",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"INDICATE USE_PO as SYS.PO_USED EQ 'Y'\" to sLine",
         "            Move \"Move (SYS.PO_USED EQ 'Y') to USE_PO\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_37",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"If SANPD LE '01\/01\/1984' INDICATE ERROR_DATE True       \/\/ V2.01\" to sLine",
         "            Move \"If (SANPD LE '01\/01\/1984') Move True to ERROR_DATE \/\/ V2.01\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_38",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"[P_END] If SANPD GT (SYS.APDATE + 31) Error 107\" to sLine",
         "            Move \"If (P_END and (SANPD GT (SYS.APDATE + 31))) Error 107\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_39",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"INDICATE NO_PROCESS GROUP All [not P_END not M_END not Y_END] and All [not T_END not CLEAR_TR]  \/\/ MOD 19 START\" to sLine",
         "            \/\/ ToDo: How should this work??",
         "            \/\/ The function now ignores lines with \"GROUP\" and\/or \"ALL\" in them.",
         "            Move \"INDICATE NO_PROCESS GROUP All [not P_END not M_END not Y_END] and All [not T_END not CLEAR_TR]  \/\/ MOD 19 START\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_40",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"[Found] Set Field_Changed_Value Field Artiklar.karaktarstyp to (Trim(Karlista.karaktartyp))\" to sLine",
         "            Move \"If (Found) Set Field_Changed_Value Field Artiklar.karaktarstyp to (Trim(Karlista.karaktartyp))\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_41",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Indicate select as sysfil.auto_avtal    Eq \"J\"' to sLine",
         "            Move 'Move (sysfil.auto_avtal Eq \"J\") to select' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_42",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '[Select] Indicate select as servdat           Ne \"\"' to sLine",
         "            Move 'If (Select) Move (servdat Ne \"\") to select' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_43",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '[Found  ] Set Field_Changed_Value Field maskiner.rad1art to (Trim(Artiklar.Artnr))' to sLine",
         "            Move 'If (Found) Set Field_Changed_Value Field maskiner.rad1art to (Trim(Artiklar.Artnr))' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_44",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If (Mid(\"Jensen\",1,6)) Eq \"n\" Begin' to sLine",
         "            Move 'If (Mid(\"Jensen\",1,6)) Eq \"n\" Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_45",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If (Mid(\"Jensen\", 1, 3)) Eq \"J\" Begin' to sLine",
         "            Move 'If (Mid(\"Jensen\", 1, 3)) Eq \"J\" Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_46",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '[select] Indicate select as (from_datum = daPeriodDates[0])' to sLine",
         "            Move 'If (select) Move (from_datum = daPeriodDates[0]) to select' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_47",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '[Select] Indicate Select as (Uppercase(sVal1)) Eq (Uppercase(sVal2))' to sLine",
         "            Move 'If (Select) Move ((Uppercase(sVal1)) Eq (Uppercase(sVal2))) to Select' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_48",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Set Label to \"Create log file with booking, ÅÅÅÅMMDD-Order.txt\"' to sLine",
         "            Move 'Set Label to \"Create log file with booking, ÅÅÅÅMMDD-Order.txt\"' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyIndicators_49",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"INDICATE NO_PROCESS as [Not P_END Not M_END Not Y_END] and [Not T_END Not CLEAR_TR]  \/\/ MOD 19 START\" to sLine",
         "            Move \"Move ((Not(P_END) and Not(M_END) and Not(Y_END)) and (Not(T_END) and Not(CLEAR_TR))) to NO_PROCESS \/\/ MOD 19 START\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeLegacyOperators",
       "iSourceLines": 280,
       "UnitArray": [
         "    Object oChangeLegacyOperators is a cTestFixture",
         "        Set psFunctionName to \"ChangeLegacyOperators\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"    While ((Found eq True) and (iA Eq iB))\" to sLine",
         "            Move \"    While ((Found = True) and (iA = iB))\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"    While  iL  lt  13\" to sLine",
         "            Move \"    While (iL < 13)\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"    Send Find to Self EQ 1\" to sLine",
         "            Move \"    Send Find to Self EQ 1\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If  iParXt_Next   Eq   0   Move   \"to\"   to sLabel' to sLine",
         "            Move 'If (iParXt_Next = 0) Move \"to\" to sLabel' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_5",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If  iA  eq  iB Move (Trim (FlexErrs.Error_Descr) * Trim (Flexerrs.Note)) to vData[iRow][2] \/\/ Name: ZipCode_City, Length: 100, Datatype: String' to sLine",
         "            Move 'If (iA = iB) Move (Trim (FlexErrs.Error_Descr) * Trim (Flexerrs.Note)) to vData[iRow][2] \/\/ Name: ZipCode_City, Length: 100, Datatype: String' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_6",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Constrain FlexErrs.Recnum gt 10' to sLine",
         "            Move 'Constrain FlexErrs.Recnum gt 10' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_7",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    If d Gt  2 Begin' to sLine",
         "            Move '    If (d > 2) Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_8",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    If d Eq   1 Begin' to sLine",
         "            Move '    If (d = 1) Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_9",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '     If (Found) Move (WindowIndex eq FieldIndex) to Found' to sLine",
         "            Move '     If (Found) Move (WindowIndex = FieldIndex) to Found' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_10",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '     If (MyFunction(self,iRow)) eq sValue Function_Return iRow' to sLine",
         "            Move '     If ((MyFunction(self,iRow)) = sValue) Function_Return iRow' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_11",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '     If lsDriver eq \"ODBC_DRV\" Function_Return \"\"' to sLine",
         "            Move '     If (lsDriver = \"ODBC_DRV\") Function_Return \"\"' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_12",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '     If row# eq -1 Move \"Unknown\" to value# \/\/ This one is ok' to sLine",
         "            Move '     If (row# = -1) Move \"Unknown\" to value# \/\/ This one is ok' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_13",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '     If ((Current_Radio(Self)) eq 0) Move (Append(\"W\",(Value(oWorkspace(Self),0)))) to retval' to sLine",
         "            Move '     If ((Current_Radio(Self)) = 0) Move (Append(\"W\",(Value(oWorkspace(Self),0)))) to retval' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_14",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '         If iArg eq 1 Send Anything' to sLine",
         "            Move '         If (iArg = 1) Send Anything' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_15",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    If code# eq 0 If tmp# ge 0 Move (rval#+tmp#) to rval#' to sLine",
         "            Move '    If (code# = 0) If (tmp# >= 0) Move (rval#+tmp#) to rval#' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_16",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"INDICATE IN_JOBSTREAM as REP_JOBSTREAM EQ 888888\" to sLine",
         "            Move \"INDICATE IN_JOBSTREAM as (REP_JOBSTREAM = 888888)\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_17",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If servtyp.rk     Eq \"J\" Begin' to sLine",
         "            Move 'If (servtyp.rk = \"J\") Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_18",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If Fdel Eq 1 Begin \/\/ skapa fil om delar finns****************************************' to sLine",
         "            Move 'If (Fdel = 1) Begin \/\/ skapa fil om delar finns****************************************' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_19",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If sysfil.adm_system Eq \"1\" Begin \/\/ Comment ' to sLine",
         "            Move 'If (sysfil.adm_system = \"1\") Begin \/\/ Comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_20",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If sysfil.modnr_ord   Eq \"J\" Trim maskiner.mtyp   to Modellnr' to sLine",
         "            Move 'If (sysfil.modnr_ord = \"J\") Trim maskiner.mtyp to Modellnr' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_21",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If (Trim(kontakt.namn))  Eq (Trim(namn)) Begin' to sLine",
         "            Move 'If ((Trim(kontakt.namn)) = (Trim(namn))) Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_22",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If sOne Eq \"A\" Insert \"B\" in sOne At 2' to sLine",
         "            Move 'If (sOne = \"A\") Insert \"B\" in sOne At 2' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyOperators_23",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    If (Number(Val(Kunder_DD, \"KUNDER.SALDO\"))) Gt (Number(Val(Kunder_DD, \"KUNDER.LIMIT\"))) Begin' to sLine",
         "            Move '    If (Number(Val(Kunder_DD, \"KUNDER.SALDO\")) > (Number(Val(Kunder_DD, \"KUNDER.LIMIT\")))) Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyOperators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeLegacyShadow_State",
       "iSourceLines": 112,
       "UnitArray": [
         "    Object oChangeLegacyShadow_State is a cTestFixture",
         "        Set psFunctionName to \"ChangeLegacyShadow_State\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyShadow_State_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   Set Shadow_State of (oApplication(Self)) to False  \/\/ Comment here' to sLine",
         "            Move '   Set Enabled_State of (oApplication(Self)) to True  \/\/ Comment here' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyShadow_State of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyShadow_State_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   Get Shadow_State to bState   \/\/ Other comment' to sLine",
         "            Move '   Get Enabled_State to (Not(bState))   \/\/ Other comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyShadow_State of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyShadow_State_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   Set Shadow_State of oButton to (not(bState))' to sLine",
         "            Move '   Set Enabled_State of oButton to bState' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyShadow_State of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyShadow_State_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   Set Object_Shadow_state to True' to sLine",
         "            Move '   Set Enabled_State to False' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyShadow_State of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyShadow_State_5",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   Set Shadow_State of oButton to (not(bState))   \/\/ End comment' to sLine",
         "            Move '   Set Enabled_State of oButton to bState   \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyShadow_State of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyShadow_State_6",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '        Set Shadow_State of oButton to (not(bState))' to sLine",
         "            Move '        Set Enabled_State of oButton to bState' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyShadow_State of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyShadow_State_7",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '        Set object_shadow_state of (oBtn1(self)) to (not(liLogImage))' to sLine",
         "            Move '        Set Enabled_State of (oBtn1(self)) to liLogImage' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyShadow_State of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyShadow_State_8",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '        If sUserAccessHigh ne \"Y\" Set Shadow_state Item 0 to True' to sLine",
         "            Move '        If sUserAccessHigh ne \"Y\" Set Enabled_State Item 0 to False' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyShadow_State of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLegacyShadow_State_9",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '                Set Label to \"Skapa loggfil vid avbokning, ÅÅÅÅMMDD-Order.txt\"' to sLine",
         "            Move '                Set Label to \"Skapa loggfil vid avbokning, ÅÅÅÅMMDD-Order.txt\"' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLegacyIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeLengthCommandToFunction",
       "iSourceLines": 40,
       "UnitArray": [
         "    Object oChangeLengthCommandToFunction is a cTestFixture",
         "        Set psFunctionName to \"ChangeLengthCommandToFunction\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeLengthCommandToFunction_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Length sVar to iLength' to sLine",
         "            Move 'Move (Length(sVar)) to iLength' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLengthCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLengthCommandToFunction_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   If iA EQ iB Length sVar to iLength' to sLine",
         "            Move '   If iA EQ iB Move (Length(sVar)) to iLength' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLengthCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeLengthCommandToFunction_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   If (Found) Length sVar to iLength \/\/ End comment' to sLine",
         "            Move '   If (Found) Move (Length(sVar)) to iLength \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeLengthCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangePosCommandToFunction",
       "iSourceLines": 28,
       "UnitArray": [
         "    Object oChangePosCommandToFunction is a cTestFixture",
         "        Set psFunctionName to \"ChangePosCommandToFunction\"",
         "",
         "        {Published = True}",
         "        Procedure ChangePosCommandToFunction_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Pos \"-\"  in sIns to iPos' to sLine",
         "            Move 'Move (Pos(\"-\",sIns)) to iPos' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangePosCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangePosCommandToFunction_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '   If (iA <> iB) Pos \"   \"  in sIns to iPos \/\/ End comment' to sLine",
         "            Move '   If (iA <> iB) Move (Pos(\"   \",sIns)) to iPos \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangePosCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeReplaceCommandToFunction",
       "iSourceLines": 28,
       "UnitArray": [
         "    Object oChangeReplaceCommandToFunction is a cTestFixture",
         "        Set psFunctionName to \"ChangeReplaceCommandToFunction\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeReplaceCommandToFunction_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '  Replace  \"A\"  In  sNameX  With \"B\" \/\/ End comment' to sLine",
         "            Move '  Move (Replace(\"A\",sNameX,\"B\")) to sNameX \/\/ End comment' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeReplaceCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeReplaceCommandToFunction_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '  Replace \".txt\" In sVal1 With (\"_\" + (Trim(sVal2)))' to sLine",
         "            Move '  Move (Replace(\".txt\",sVal1,(\"_\" + (Trim(sVal2))))) to sVal1' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeReplaceCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeRightCommandToFunction",
       "iSourceLines": 16,
       "UnitArray": [
         "    Object oChangeRightCommandToFunction is a cTestFixture",
         "        Set psFunctionName to \"ChangeRightCommandToFunction\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeRightCommandToFunction_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Right sPath to sPath (Length(sPath) - iSepPos)' to sLine",
         "            Move 'Move (Right(sPath, (Length(sPath) - iSepPos))) to sPath' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeRightCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeSquareBracketsIndicators",
       "iSourceLines": 16,
       "UnitArray": [
         "    Object oChangeSquareBracketsIndicators is a cTestFixture",
         "        Set psFunctionName to \"ChangeSquareBracketsIndicators\"",
         "",
         "        { Published = True }",
         "        Procedure ChangeSquareBracketsIndicators_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '    [Found ~Found] Begin' to sLine",
         "            Move '    If (Found and Not(Found)) Begin' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeSquareBracketsIndicators of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeSysdate4",
       "iSourceLines": 16,
       "UnitArray": [
         "    Object oChangeSysdate4 is a cTestFixture",
         "        Set psFunctionName to \"ChangeSysdate4\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeSysdate4_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Sysdate4 dToday' to sLine",
         "            Move 'Sysdate dToday' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeSysdate4 of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeTrimCommandToFunction",
       "iSourceLines": 40,
       "UnitArray": [
         "    Object oChangeTrimCommandToFunction is a cTestFixture",
         "        Set psFunctionName to \"ChangeTrimCommandToFunction\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeTrimCommandToFunction_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \" Trim sTmp to sValue\" to sLine",
         "            Move \" Move (Trim(sTmp)) to sValue\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeTrimCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeTrimCommandToFunction_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \" Move sTmp to sValue \/\/ That's mighty trim of you\" to sLine",
         "            Move \" Move sTmp to sValue \/\/ That's mighty trim of you\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeTrimCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeTrimCommandToFunction_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \" If iA gt iB Trim sTmp to sValue\" to sLine",
         "            Move \" If iA gt iB Move (Trim(sTmp)) to sValue\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeTrimCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeUClassToRefClass",
       "iSourceLines": 28,
       "UnitArray": [
         "    Object oChangeUClassToRefClass_Fixture is a cTestFixture",
         "        Set psFunctionName to \"ChangeUClassToRefClass\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeUClassToRefClass_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"    Get Create U_Array to hArray\" to sLine",
         "            Move \"    Get Create (RefClass(Array)) to hArray\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeUClassToRefClass of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure ChangeUClassToRefClass_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"    Get    Create   U_Array    to     hArray\" to sLine",
         "            Move \"    Get    Create   (RefClass(Array))    to     hArray\" to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeUClassToRefClass of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ChangeZeroStringCommandToFunction",
       "iSourceLines": 16,
       "UnitArray": [
         "    Object oChangeZeroStringCommandToFunction is a cTestFixture",
         "        Set psFunctionName to \"ChangeZeroStringCommandToFunction\"",
         "",
         "        {Published = True}",
         "        Procedure ChangeZeroStringCommandToFunction_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'ZeroString iLength to sParameter' to sLine",
         "            Move 'Move (ZeroString(iLength)) to sParameter' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ChangeZeroStringCommandToFunction of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "EditorNormalizeCase",
       "iSourceLines": 27,
       "UnitArray": [
         "    Object oEditorNormalizeCase is a cTestFixture",
         "        Set psFunctionName to \"EditorNormalizeCase\"",
         "",
         "        {Published = True}",
         "        Procedure EditorNormalizeCase_1",
         "            String sLine sExpected",
         "            String[] asData",
         "            Boolean bChanged bOK",
         "            Handle hoEditor",
         "",
         "            Get phoEditor of ghoRefactorFuncLib to hoEditor",
         "            Move 'move iA TO iB' to asData[0]",
         "            Move 'Move iA to iB' to sExpected",
         "            Get WriteDataToEditor of hoEditor asData to bOK",
         "            Get EditorNormalizeCase of ghoRefactorFuncLib (&asData) to bChanged",
         "",
         "            If (bChanged = True) Begin",
         "                \/\/ We need this because of an optimization in the cRefactoringEngine,",
         "                \/\/ where we only want to call EditorDataAsStringArray once after all",
         "                \/\/ calls to eEditor_Function type(s).",
         "                Get EditorDataAsStringArray of hoEditor to asData",
         "                Move asData[0] to sLine",
         "            End",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "EditorReIndent",
       "iSourceLines": 31,
       "UnitArray": [
         "    Object oEditorReIndent is a cTestFixture",
         "        Set psFunctionName to \"EditorReIndent\"",
         "",
         "        {Published = True}",
         "        Procedure EditorReIndent_1",
         "            String sLine sExpected sParam",
         "            Boolean bChanged bOK",
         "            String[] asData",
         "            Handle hoEditor",
         "",
         "            Get phoEditor of ghoRefactorFuncLib to hoEditor",
         "            Move \"    If (Found) Begin\"     to asData[0]",
         "            Move \"    Move False to Found\"  to asData[1]",
         "            Move \"    End\"                  to asData[2]",
         "            Get WriteDataToEditor of hoEditor asData to bOK",
         "            Get EditorReIndent of ghoRefactorFuncLib (&asData) to bChanged",
         "            If (bChanged = True) Begin",
         "                \/\/ See oEditorNormalizeCase above for comment:",
         "                Get EditorDataAsStringArray of hoEditor to asData",
         "                Move (asData[0] = \"If (Found) Begin\") to bOK",
         "                If (bOK) Begin",
         "                    Move (asData[1] = \"    Move False to Found\") to bOK",
         "                End",
         "                If (bOK) Begin",
         "                    Move (asData[2] = \"End\") to bOK",
         "                End",
         "            End",
         "            Send Assert (bChanged and bOK)",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "NormalizeArrayNotation",
       "iSourceLines": 14,
       "UnitArray": [
         "    Object oNormalizeArrayNotation is a cTestFixture",
         "        Set psFunctionName to \"NormalizeArrayNotation\"",
         "",
         "        {Published = True}",
         "        Procedure NormalizeArrayNotation_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            Move 'String [] asAddress' to sLine",
         "            Move 'String[] asAddress'  to sExpected",
         "            Get NormalizeArrayNotation of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemoveEndComments",
       "iSourceLines": 52,
       "UnitArray": [
         "    Object oRemoveEndComments is a cTestFixture",
         "        Set psFunctionName to \"RemoveEndComments\"",
         "",
         "        {Published = True}",
         "        Procedure RemoveEndComments_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'End_Procedure   \/\/ This is a bla bla procedure' to sLine",
         "            Move 'End_Procedure' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveEndComments of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveEndComments_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'End_Function   \/\/ This is an end function' to sLine",
         "            Move 'End_Function' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveEndComments of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveEndComments_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'End_Class   \/\/ This class does bla bla bla' to sLine",
         "            Move 'End_Class' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveEndComments of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveEndComments_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'End_Object   \/\/ This object does bla bla bla' to sLine",
         "            Move 'End_Object' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveEndComments of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemoveLocalKeyWord",
       "iSourceLines": 54,
       "UnitArray": [
         "    Object oRemoveLocalKeyWord is a cTestFixture",
         "        Set psFunctionName to \"RemoveLocalKeyWord\"",
         "",
         "        {Published = True}",
         "        Procedure RemoveLocalKeyWord_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Set pbInFunction of ghoRefactorFuncLib to True",
         "            Move '  Local Integer iRename' to sLine",
         "            Move '  Integer iRename' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveLocalKeyWord of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveLocalKeyWord_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '  \/\/ Local Integer iRename' to sLine",
         "            Move '  \/\/ Local Integer iRename' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveLocalKeyWord of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveLocalKeyWord_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '  \"Local Integer iRename\"' to sLine",
         "            Move '  \"Local Integer iRename\"' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveLocalKeyWord of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveLocalKeyWord_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Set pbInFunction of ghoRefactorFuncLib to True",
         "            Move '  Local String[] asData' to sLine",
         "            Move '  String[] asData' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveLocalKeyWord of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemoveMultipleBlankLines",
       "iSourceLines": 43,
       "UnitArray": [
         "    Object oRemoveMultipleBlankLines is a cTestFixture",
         "        Set psFunctionName to \"RemoveMultipleBlankLines\"",
         "",
         "        {Published = True}",
         "        Procedure RemoveMultipleBlankLines_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            Integer iItem",
         "            String[] asCode asExpected",
         "",
         "            Move 0 to iItem",
         "            Move \"    Use SQL.pkg\" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"    \" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"    \" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"    \" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"    \" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"    \" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"    \" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"    \" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"    \" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"Set Border_Style to Border_Thick\" to asCode[iItem]",
         "",
         "            Move 0 to iItem",
         "            Move \"    Use SQL.pkg\" to asExpected[iItem]",
         "            Increment iItem",
         "            Move \"\" to asCode[iItem]",
         "            Increment iItem",
         "            Move \"Set Border_Style to Border_Thick\" to asExpected[iItem]",
         "",
         "            Get RemoveMultipleBlankLines of ghoRefactorFuncLib (&asCode) 1 to bChanged",
         "            Send AssertArrayAreEqual asExpected asCode",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemoveOldStudioMarkers",
       "iSourceLines": 81,
       "UnitArray": [
         "    Object oRemoveOldStudioMarkers is a cTestFixture",
         "        Set psFunctionName to \"RemoveOldStudioMarkers\"",
         "",
         "        {Published = True}",
         "        Procedure RemoveOldStudioMarkers_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/\/AB-IgnoreStart' to sLine",
         "            Move '\/\/AB-IgnoreStart' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            \/\/ Returns True if a legacy IDE (Studio) source code marker is found, and",
         "            \/\/ in case the source line should be removed.",
         "            Get RemoveOldStudioMarkers of ghoRefactorFuncLib (&sLine) to bChanged",
         "            If (bChanged = False) Begin",
         "                Move \"\" to sLine",
         "            End",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveOldStudioMarkers_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/\/AB-DDOEnd' to sLine",
         "            Move '\/\/AB-DDOEnd' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveOldStudioMarkers of ghoRefactorFuncLib (&sLine) to bChanged",
         "            If (bChanged = False) Begin",
         "                Move \"\" to sLine",
         "            End",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveOldStudioMarkers_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '  \/\/AB-PanelStoreTopStart' to sLine",
         "            Move '  \/\/AB-PanelStoreTopStart' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveOldStudioMarkers of ghoRefactorFuncLib (&sLine) to bChanged",
         "            If (bChanged = False) Begin",
         "                Move \"\" to sLine",
         "            End",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveOldStudioMarkers_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '  \/\/AB\/ ' to sLine",
         "            Move '  \/\/AB\/ ' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveOldStudioMarkers of ghoRefactorFuncLib (&sLine) to bChanged",
         "            If (bChanged = False) Begin",
         "                Move \"\" to sLine",
         "            End",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure RemoveOldStudioMarkers_5",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '\/\/IDE-FileType=ftApplication' to sLine",
         "            Move '\/\/IDE-FileType=ftApplication' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveOldStudioMarkers of ghoRefactorFuncLib (&sLine) to bChanged",
         "            If (bChanged = False) Begin",
         "                Move \"\" to sLine",
         "            End",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemoveProjectObjectStructure",
       "iSourceLines": 17,
       "UnitArray": [
         "    Object oRemoveProjectObjectStructure is a cTestFixture",
         "        Set psFunctionName to \"RemoveProjectObjectStructure\"",
         "",
         "        \/\/ ToDo: Don't know if and how this should\/could be tested?",
         "        {Published=False}",
         "        Procedure RemoveProjectObjectStructure_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '' to sLine",
         "            Move ' ' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveProjectObjectStructure of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemovePropertyPrivate",
       "iSourceLines": 16,
       "UnitArray": [
         "    Object oRemovePropertyPrivate is a cTestFixture",
         "        Set psFunctionName to \"RemovePropertyPrivate\"",
         "",
         "        {Published = True}",
         "        Procedure RemovePropertyPrivate_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Property Boolean pbState Private' to sLine",
         "            Move 'Property Boolean pbState' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemovePropertyPrivate of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemovePropertyPublic",
       "iSourceLines": 16,
       "UnitArray": [
         "    Object oRemovePropertyPublic is a cTestFixture",
         "        Set psFunctionName to \"RemovePropertyPublic\"",
         "",
         "        {Published = True}",
         "        Procedure RemovePropertyPublic_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Property Boolean pbState Public' to sLine",
         "            Move 'Property Boolean pbState' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemovePropertyPublic of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemoveSansSerif",
       "iSourceLines": 19,
       "UnitArray": [
         "    Object oRemoveSansSerif is a cTestFixture",
         "        Set psFunctionName to \"RemoveSansSerif\"",
         "",
         "        {Published = True}",
         "        Procedure RemoveSansSerif_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Set TypeFace to \"MS Sans serif\"' to sLine",
         "            Move '' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveSansSerif of ghoRefactorFuncLib (&sLine) to bChanged",
         "            If (bChanged = True) Begin",
         "                Move \"\" to sLine",
         "            End",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemoveStudioGeneratedComments",
       "iSourceLines": 50,
       "UnitArray": [
         "    Object oRemoveStudioGeneratedComments is a cTestFixture",
         "        Set psFunctionName to \"RemoveStudioGeneratedComments\"",
         "",
         "        \/\/ ToDo: Don't know how we could test this.",
         "        {Published = True}",
         "        Procedure RemoveStudioGeneratedComments_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"\/\/ fires when the button is clicked\" to sLine",
         "            Move '' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveStudioGeneratedComments of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        Procedure RemoveStudioGeneratedComments_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"\/\/OnChange is called on every changed character to sLine\" to sLine",
         "            Move '' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveStudioGeneratedComments of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        Procedure RemoveStudioGeneratedComments_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"\/\/ Visual DataFlex xx.x Client Size Adjuster\" to sLine",
         "            Move '' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveStudioGeneratedComments of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        Procedure RemoveStudioGeneratedComments_4",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move \"\/\/ Visual DataFlex xx.x Migration Utility,\" to sLine",
         "            Move '' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveStudioGeneratedComments of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemoveTrailingSpaces",
       "iSourceLines": 16,
       "UnitArray": [
         "    Object oRemoveTrailingSpaces is a cTestFixture",
         "        Set psFunctionName to \"RemoveTrailingSpaces\"",
         "",
         "        {Published = True}",
         "        Procedure RemoveTrailingSpaces_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'Move True to Seqeof     ' to sLine",
         "            Move 'Move True to Seqeof' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RemoveTrailingSpaces of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RemoveUnusedLocals",
       "iSourceLines": 41,
       "UnitArray": [
         "    Object oRemoveUnusedLocals is a cTestFixture",
         "        Set psFunctionName to \"RemoveUnusedLocals\"",
         "",
         "        {Published = True}",
         "        \/\/ Not sure how we should test this?",
         "        Procedure RemoveUnusedLocals_1",
         "            String[] asCode asExpected",
         "            Boolean bChanged",
         "            Integer iItem",
         "",
         "            Move 0 to iItem",
         "            Move \"Procedure Test\"                       to asCode[iItem]",
         "            Increment iItem",
         "            Move     \"Date dToday\"                      to asCode[iItem]",
         "            Increment iItem",
         "            Move     \"String sVal\"                      to asCode[iItem]",
         "            Increment iItem",
         "            Move     \"Integer iVal\"                     to asCode[iItem]",
         "            Increment iItem",
         "            Move     \"Sysdate4 dToday\"                  to asCode[iItem]",
         "            Increment iItem",
         "            Move     \"Move (dToday + 23) to dToday\"     to asCode[iItem]",
         "            Increment iItem",
         "            Move \"End_Procedure\"                        to asCode[iItem]",
         "",
         "            Move 0 to iItem",
         "            Move \"Procedure Test\"                       to asExpected[iItem]",
         "            Increment iItem",
         "            Move     \"Date dToday\"                      to asExpected[iItem]",
         "            Increment iItem",
         "            Move     \"Sysdate4 dToday\"                  to asExpected[iItem]",
         "            Increment iItem",
         "            Move     \"Move (dToday + 23) to dToday\"     to asExpected[iItem]",
         "            Increment iItem",
         "            Move \"End_Procedure\"                        to asExpected[iItem]",
         "",
         "            Get RemoveUnusedLocals of ghoRefactorFuncLib (&asCode) to bChanged",
         "            Send AssertArrayAreEqual asExpected asCode",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "ReportUnusedSourceFiles",
       "iSourceLines": 19,
       "UnitArray": [
         "    Object oReportUnusedSourceFiles is a cTestFixture",
         "        Set psFunctionName to \"ReportUnusedSourceFiles\"",
         "",
         "        {Published = True}",
         "        Procedure ReportUnusedSourceFiles_1",
         "            String sLine sExpected sPath",
         "            String[] asFiles",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '' to sLine",
         "            Move ' ' to sExpected",
         "            Get psHome of (phoWorkspace(ghoApplication)) to sPath",
         "            Move (sPath + CS_LegacyCode) to asFiles[0]",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get ReportUnusedSourceFiles of ghoRefactorFuncLib (&asFiles) to bChanged",
         "            Send AssertFalse bChanged \"\"",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "RestyleDDOs",
       "iSourceLines": 17,
       "UnitArray": [
         "    Object oRestyleDDOs is a cTestFixture",
         "        Set psFunctionName to \"RestyleDDOs\"",
         "",
         "        {Published=False}",
         "        \/\/ ToDo: Dummy procedure. You need to fill it with a meaningful test and change 'Published=False' to 'Published=True'",
         "        Procedure RestyleDDOs_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move '' to sLine",
         "            Move ' ' to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get RestyleDDOs of ghoRefactorFuncLib (&sLine) to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     },
     {
       "sFunctionName": "SplitInlineIfElseLine",
       "iSourceLines": 40,
       "UnitArray": [
         "    Object oSplitInlineIfElseLine is a cTestFixture",
         "        Set psFunctionName to \"SplitInlineIfElseLine\"",
         "",
         "        {Published = True}",
         "        Procedure SplitInlineIfElseLine_1",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If (WindowIndex = 0) Move \"Go\"   to sLabel' to sLine",
         "            Move ('If (WindowIndex = 0) Begin' + CS_CRLF + '    Move \"Go\"   to sLabel' + CS_CRLF + 'End') to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get SplitInlineIfElseLine of ghoRefactorFuncLib (&sLine) eSplitToBeginEndBlock to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure SplitInlineIfElseLine_2",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If (WindowIndex = 0) Move \"Go\"   to sLabel' to sLine",
         "            Move ('If (WindowIndex = 0);' + CS_CRLF + '    Move \"Go\"   to sLabel') to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get SplitInlineIfElseLine of ghoRefactorFuncLib (&sLine) eSplitBySemicolon to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "        {Published = True}",
         "        Procedure SplitInlineIfElseLine_3",
         "            String sLine sExpected",
         "            Boolean bChanged",
         "            tTokenizer TokenizerData",
         "            Move 'If (WindowIndex = 0) Move \"Go\"   to sLabel' to sLine",
         "            Move ('If (WindowIndex = 0) ;' + CS_CRLF + '    Move \"Go\"   to sLabel') to sExpected",
         "            Get Tokenizer of ghoRefactorFuncLib sLine to TokenizerData",
         "            Get SplitInlineIfElseLine of ghoRefactorFuncLib (&sLine) eSplitBySpaceAndSemicolon to bChanged",
         "            Send AssertSAreEqual sExpected sLine",
         "        End_Procedure",
         "",
         "    End_Object"
       ]
     }
   ]
 }