Testing Automation 
767 
Syntax errors in a script or expression: Writing scripts in HotDocs requires you 
to use a specific "language" that HotDocs can recognize and then process. If you 
use the language incorrectly, or if you use words that are not part of the language, 
you will receive an error when you try to save your work. 
HotDocs reports syntax errors when you try to test assemble a document and when you 
try to save a script that contains syntactical errors:  
When a syntax error occurs in a template, HotDocs displays a warning message 
that describes the error and displays the processing stack for the error. The stack 
shows, starting from the bottom, the components HotDocs was processing when it 
found the error. The Field denotes the variable or instruction field in the template 
where the error occurred, while Position denotes the character position within the 
field or script. 
To resolve such a syntax error, select an entry in the processing stack and click 
Go To Error. (Usually, you should select the topmost entry in the stack.) HotDocs 
takes you to the reference point so you can make the change. (When you click Go 
To Error, HotDocs continues to display the error message in a pop-up window, 
which you can leave open until you have corrected the error. When finished, click 
Close at the message box.) 
You can click the 
Go to Field button in the HotDocs toolbar to quickly 
move to a variable or instruction field containing an error.  
When a syntax error occurs in a script, HotDocs displays an error message and 
then moves the cursor as close to the error in the script as it can.  
For more information on writing scripts, see Understand the HotDocs Scripting 
LanguageIntroduction: Instruction and Expression Models, and Customize a 
Computation Variable
Using HotDocs Debugger 
Introduction: Debugging Templates 
When test assembling templates, you may find that some scripting or automation in your 
template isn’t producing the result you expect. Perhaps you have created a computation 
script that is producing an answer you think is wrong. To help you troubleshoot situations 
like this, you can test your templates or scripts in Debug mode. You do this by inserting a 
DEBUG instruction in the template or script you think may be causing the unexpected 
result. Then, you test the template or script using an answer file. When HotDocs 
processes the DEBUG instruction, it brings up the HotDocs Debugger so you can step 
through the script line by line, examining the components and any answers that may be 
causing the problem. The Debugger allows you to observe how a script is being 
processed or how a document is being assembled. 
While debugging your templates or scripts, there are several options you can use to help 
you diagnose the problem. For example, you can add variables to a “watch list,” which 
Pdf text replace tool - extract text content from PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Feel Free to Extract Text from PDF Page, Page Region or the Whole PDF File
get text from pdf c#; export text from pdf
Pdf text replace tool - VB.NET PDF Text Extract Library: extract text content from PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
How to Extract Text from PDF with VB.NET Sample Codes in .NET Application
find and replace text in pdf file; copy text from protected pdf
HotDocs Developer Help File 
768 
allows you to track how answers to certain variables change depending on how other 
questions are answered in the interview. 
The Debugger also displays the processing stack which shows, starting from the bottom, 
the templates and components HotDocs is processing at the field or line you are currently 
examining. For example, if you are debugging a computation script in an inserted 
template, the processing stack would include the name of the parent template, the name 
of the inserted template, and the name of the Computation variable. Viewing the stack can 
help you understand what part of the interview you’re viewing as well as provide the path 
for how you got to it. 
You can use the information you gather from debugging to correct problems with 
automation. 
At a Glance: The Debugger Window 
At a Glance Debugger Window 
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
provides a user-friendly interface, which is helpful to VB programmers to install and use the PDF page(s) extraction tool. VB.NET: Copy and Replace PDF Pages.
extract text from pdf c#; copying text from pdf into word
C# WPF PDF Viewer SDK to view, annotate, convert and print PDF in
Text: Replace Text in PDF. Image: Insert Image to PDF. Image: Remove Image from PDF Users can add various annotations to PDF, such as text, text box, note
how to copy and paste pdf text; copy text from protected pdf to word
Testing Automation 
769 
D
After inserting a DEBUG instruction in your template or script you can view the Debugger 
Window by clicking the 
Test Assemble button on the HotDocs ribbon and then the 
Debug button at the Assembly Window toolbar. 
At the top of the Debugger Window is the Debugger toolbar 
A
where you can find the 
following options: 
Step Into: Causes the Debugger to step into the current field or line of script to 
show how HotDocs has processed it using the answers you have provided. 
Step Over: Causes the HotDocs Debugger to not step through any 
computation or subtemplate referenced in the field unless it encounters another 
DEBUG instruction. 
Step Out: Causes the HotDocs Debugger to move you out of the current level 
of debugging and move you to the next item on the processing stack. 
Continue: Instructs HotDocs to continue processing the interview until it either 
finds another explicit DEBUG instruction (which will cause the Debugger to appear 
again) or it finishes processing. 
Stop: Causes the HotDocs Debugger to close and returns you to the test 
assembly window. Also causes HotDocs to disable the Debugger. To enable it 
again, click the Enable Debugging button. 
Help: Opens the relevant page of the HotDocs Help File. 
Below that is the preview pane 
B
where you can see HotDocs Step through the template 
or script and highlight in red the variable you are currently viewing. The bottom half of the 
window 
C
can display the Default Watch List, Custom Watch List, or Processing 
Stack depending on which tab 
D
is selected. 
To learn more about using the debugger window follow the links below: 
Introduction: Debugging Templates 
Insert Debugging Instructions in Templates and Scripts 
Step Through a Template or Script 
Insert Debugging Instructions in Templates and Scripts 
To debug your template or script, you must first insert a DEBUG instruction in the 
template or script. Then, you must test assemble the template (or test the script). Finally, 
you must enable debugging in the test assembly window. 
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Text: Replace Text in PDF. Image: Insert Image to PDF. Image: Remove Image from PDF Page. 1. Select tool. Select text and image on PDF document. 2. Hand tool.
get text from pdf file c#; copy text from pdf online
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
PDF Write. Text: Insert Text to PDF. Text: Delete Text from PDF. Text: Replace Text in PDF. 1. Select tool. Select text and image on PDF document. 2. Hand tool.
extract text from pdf image; c# get text from pdf
HotDocs Developer Help File 
770 
To debug your template or script using a certain set of answers, first test assemble the 
template using those answers and then save your answers in a test answer file. (See Use 
a Test Answer File.) Once you have done this, then complete the steps below. 
You can insert a DEBUG instruction: 
In a text template. 
In a form template. 
In a script. 
In a resource. 
To insert a DEBUG instruction  
1.  Open the text or form template for editing. (See Edit a Template.) 
2.  Complete the following steps, depending on where you need to insert the DEBUG 
instruction: 
If you are inserting a DEBUG instruction in a text template, place your 
cursor where you want to begin debugging. Click the HotDocs menu and 
choose Other Field  from the list of options. Choose DEBUG from the Field 
type drop-down menu. Click OK
For WordPerfect Users: The HotDocs menu does not appear in 
WordPerfect. To insert a debug statement, manually type «DEBUG» 
into the template.  
If you are inserting a DEBUG instruction in a form template, create a field 
on the form where you want to begin debugging. Select the field and click 
the 
Field Properties button. In the Variable field, type DEBUG. (Close 
the Field Properties dialog box when you are finished.) 
If you are inserting a DEBUG instruction in a script, edit the computation or 
dialog whose script you want to debug. Insert the DEBUG instruction at the 
place in the script where you want to begin debugging. 
3.  Click the 
Test Assemble button. (If debugging a script, click the Test button.) 
The test assembly window appears, along with the HotDocs Debugger window, 
which stops at the field following the DEBUG instruction. (If the Debugger window 
does not appear, make sure debugging is enabled by clicking the 
Enable 
Debugging button in the assembly window toolbar.) 
4.  Step through the template or script using the Debugger. (See Step Through a 
Template or Script.) 
Step Through a Template or Script 
Once you have inserted a DEBUG instruction in a script or in the template, you can begin 
stepping through the template or script to determine where your automation is causing 
unexpected results. The HotDocs Debugger includes several options for doing this. 
C# WPF PDF Viewer SDK to annotate PDF document in C#.NET
An advanced PDF annotating tool, which is compatible with all Windows systems and supports .NET Framework Support to replace PDF text with a note annotation.
can't copy and paste text from pdf; delete text from pdf preview
VB.NET PDF - Annotate PDF Online with VB.NET HTML5 PDF Viewer
An advanced PDF annotating tool, which is compatible with all Windows systems and supports .NET Framework Support to insert note annotation to replace PDF text.
extract formatted text from pdf; extract text from scanned pdf
Testing Automation 
771 
Before debugging, however, you should understand how HotDocs processes the template 
or script: 
When you first test assemble a template or script, HotDocs processes (or runs through) 
the entire template or script to create the interview, which it displays in the test assembly 
window. As you answer questions in the interview, some answers may cause HotDocs to 
reprocess the script so it can update the interview. (For example, answering a true/false 
question may gray or ungray other variables in a dialog. In order for these changes to 
happen, HotDocs must reprocess the template.) Depending on the complexity of your 
template, HotDocs may reprocess the template or script many times during a test 
assembly. 
During a test, if HotDocs encounters a DEBUG instruction, it displays the HotDocs 
Debugger, which simply shows you how the template or script is being processed at that 
specific field or line using any answers that have been entered. This allows you to see 
how variables and instructions are being used to manipulate text in the document or data 
in the script. Such analysis will help you understand why you may be seeing unexpected 
results in your test. 
At any time, you can close the Debugger and return to the test assembly window. 
However, as long as you are in debugging mode, any time HotDocs processes a DEBUG 
instruction, the HotDocs Debugger will be redisplayed. This will happen each time you 
make a change to answers in the interview that cause it to be reprocessed. 
Debugging mode happens when you have a DEBUG instruction in your script or 
template and the 
Enable Debugging button is selected (pressed down) at the 
test assembly window.  
To debug your template or script using a certain set of answers, first test assemble and 
then save your answers in a test answer file. (See Use a Test Answer File.) Then debug 
your template. (See Insert Debugging Instructions in Templates and Scripts.)  
To step through a template or script 
1.  Insert a DEBUG instruction in the script, resource or template and then test 
assemble the template. (See Insert Debugging Instructions in Templates and 
Scripts.) 
2.  When the HotDocs Debugger window appears, complete any of the following 
tasks: 
To 
Do This 
Understand why 
the Debugger 
window is 
showing  
Read the explanation at the top of the tabbed pane.  
Examine either 
each field in the 
template or each 
line in the script  
Click 
Step Into. The Debugger steps into that field or line 
to show how HotDocs has processed it using the answers you 
have provided, specifically:  
If you are in an INSERT instruction, the Debugger will 
step into the inserted clause, clause library, or 
template and show you how that file is being 
C# HTML5 PDF Viewer SDK to annotate PDF document online in C#.NET
An advanced PDF annotating tool, which is compatible with all Windows systems and supports .NET Framework Support to insert note annotation to replace PDF text.
.net extract pdf text; erase text from pdf
VB.NET PDF - Annotate PDF with WPF PDF Viewer for VB.NET
An advanced PDF annotating tool, which is compatible with all Windows systems and supports .NET Framework Support to replace PDF text with a note annotation.
extract text from pdf online; copy text from pdf without formatting
HotDocs Developer Help File 
772 
processed. 
If you are in a Computation variable field, the 
Debugger will step into the computation and show you 
how the script is being processed. 
If you are in a regular (non-computed) variable field, 
the Debugger will move you to the next field or line. 
As you step into components and instructions, you will notice 
that you are adding these levels of processing to the 
processing stack (which is a sequential list of templates and 
components you are processing). 
Ignore a field or 
line in a script  
Click 
Step Over. The Debugger will not step through any 
computations or subtemplates referenced in the field unless it 
encounters another explicit DEBUG instruction.  
For example, if you step over a computation field but the 
computation script includes a DEBUG instruction, HotDocs will 
stop at the DEBUG instruction in the computation script. 
Move to the next 
item on the 
processing stack  
Click 
Step Out. The Debugger will move you out of the 
current level of debugging and move you to the next item 
down on the processing stack (which is a sequential list of 
templates and components you are processing).  
For example, if you are debugging a computation in an 
inserted template, clicking 
Step Out will move you out of 
the computation and back to the inserted template. If you click 
Step Out again, the Debugger will return you to the parent 
template. 
Stop processing 
any current 
DEBUG 
instructions  
Click 
Continue. HotDocs continues processing the 
interview until it either finds another explicit DEBUG 
instruction (which will cause the Debugger to appear again) or 
it finishes processing the template.  
Changing answers in the interview may cause HotDocs to 
reprocess the interview, thus triggering another debug 
session. To keep this from happening, close the Debugger 
window and either remove the DEBUG instruction from the 
template or script, or disable the Debugger. (To do this, click 
the 
Enable Debugging button in the test assembly window 
toolbar.)  
Cancel the 
debugging 
session  
Click 
Stop. HotDocs closes the Debugger window and 
disables the Debugger. You are returned to the test assembly 
window.  
You can start the Debugger again by clicking the 
Enable 
Debugging button in the test assembly window toolbar.  
C# PDF Markup Drawing Library: add, delete, edit PDF markups in C#
A web based markup tool able to annotate PDF annotations, trikethrough text, underline text, insert and replace text. Since RasterEdge XDoc.PDF SDK is based on
copy pdf text to word with formatting; pdf text replace tool
VB.NET PDF - WPF PDF Viewer for VB.NET Program
PDF. Text: Delete Text from PDF. Text: Replace Text in PDF. for VB.NET is a PDF utility annotation Annotations such as text, text box, note, underline, rectangle
copy formatted text from pdf; copy text from pdf without formatting
Testing Automation 
773 
View the current 
field or line of 
script and any 
answers used in 
processing it  
Click the Default Watch List tab, which shows a list of 
of 
variables referenced in the field or script as well as any 
answers for the variables.  
As HotDocs processes REPEAT instructions, it displays the 
value for the current iteration (or index) in the Answer column. 
As you step through the REPEAT instruction, you can watch 
the Debugger increment this index. The Debugger also 
displays the REPEAT COUNTER. 
Track the answers 
for specific 
variables as the 
Debugger steps 
through the 
interview or script  
Click the Custom Watch List tab. See Add Variables to the 
the 
Debugger Watch List for details.  
View the 
processing stack, 
or path of 
execution  
Click the Processing Stack tab.  
The processing stack shows the sequential list of templates 
and components you are processing as well as the reason 
why a certain template or component was added to the stack. 
This can help you determine how HotDocs came to be 
processing the current field or line. As you step into 
components, those components are added to the top of the 
stack. 
Keep HotDocs 
from debugging 
the template or 
script without 
removing the 
DEBUG 
instruction  
Click 
Stop at the Debugger window. This closes and 
disables the Debugger window. (To start another debugging 
session, click the 
Enable Debugging button. HotDocs 
reprocesses the interview or script, which forces HotDocs to 
process the DEBUG instruction, thus causing the Debugger to 
open again.)  
At a Glance: The Add or Remove Variables dialog box 
HotDocs Developer Help File 
774 
D
E
After clicking the Custom Watch List tab at the Debugger window, right click and select 
Add or Remove Variables, then the Add or Remove Variables dialog box appear. 
Using this dialog you can edit which variables are on your watch list. 
At the top of the left hand side of the dialog is a drop-down menu 
A
, from this you can 
select the type of variables that will appear in the variable list 
B
below.  
To add a variable to the watch list you first click on it in the variable list then click the 
arrow button 
C
in the center. To remove a variable from the watch list you click on it in the 
watch list 
D
and click the arrow in the center to move it back. 
You can also search the variable list using the Find field 
E
at the bottom of the dialog. 
To learn more about using the watch list follow the links below: 
Testing Automation 
775 
Add Variables to the Debugger Watch List 
Add Variables to the Debugger Watch List 
You can have the Debugger monitor how answers to specific variables change as you 
step through the interview or script. You do this by adding variables to a custom watch list. 
When you add variables to the watch list, they will be associated with the list until you 
manually remove them. Also, the custom watch list contains variables for only the current 
component file. In other words, if you are debugging a template that has an inserted 
template, you can actually have two watch lists—one for variables in the parent template 
and one for variables in the inserted template. 
To add variables to a watch list  
1.  At the Debugger window, click the Custom Watch List tab. The tab changes to 
show the list of specific variables you want to watch. 
2.  In the Watch pane, right-click and choose Add or Remove Variables from the 
shortcut menu. The Add or Remove Variables dialog box appears, showing a list 
of all the variables in the current component file. (You can filter this list by clicking 
the Variables drop-down button and choosing a variable type.) 
3.  Select a variable and click the 
Add Variables button. The variable is added to 
the Variables to watch list. 
4.  Add as many variables as you want to monitor and click OK when you are 
finished. The variables are added to the Custom Watch List tab. 
To remove a variable from the custom watch list, select the variable and click the 
Remove Variables button. You can also select a variable at the Watch pane, 
right-click, and choose Remove Selected Variable from the shortcut menu.  
Using the Text Panel 
Introduction: Use the Test Panel 
You can display logistical information about the template you are testing in the Test Panel. 
This includes viewing a list of variables that are asked in the interview but not used in the 
document (and vice versa), and identifying situations where you've improperly asked or 
set variable values. Finally, it includes linking from the Document Preview tab of the 
assembly window back to a specific place in a Microsoft Word template. 
Once you open the Test Panel, you can leave it displayed as you work in the test 
assembly window. Changes you make in the interview are automatically reflected in the 
Test Panel. 
HotDocs Developer Help File 
776 
Validate Variable Usage in a Template 
One key to good template automation is making sure the variables asked in the interview 
are both relevant to the interview and to the document. Specifically, you must ensure 
you're not asking questions in the interview that aren't used in the document, and vice 
versa. If such a situation exists, the interview and/or document may be incorrect. 
You can use the Test Panel to examine which variables are asked in the interview (but not 
used in the document) as well as see which variables are not asked in the interview but 
are used in the document. 
Variables listed in these tables appear based on the current answer set. For example, if a 
variable is included in conditional text and the condition has not yet been resolved, that 
variable will appear in the Variables asked in interview but not referred to in 
document list. Additionally, if a variable is merged in the document but it is set to Don't 
ask automatically and it's not specifically asked in a dialog, it will appear in the Variables 
referred to in document but not asked in interview list. 
You can use this tool with both text and form templates. 
To view variable usage  
1.  Test assemble the document. (See Test Assemble a Document.) 
2.  At the test assembly window, click the 
Test Panel button. The Test Panel 
window appears. 
3.  Click the Variable Usage tab. The view changes to show the validation options. 
4.  Select Enable variable usage tracking. This generates the variable lists. 
5.  Review the usage lists and make any necessary corrections to the template or 
interview script. 
6.  Optionally, to review the variable's properties, including seeing which dialog links 
to it, double-click the variable. 
At a Glance: The Test Panel Window 
Documents you may be interested
Documents you may be interested