expect-lite

List of Features

• Simplicity using one character for send and expect '>' '<'
  This creates many lines of expect with minimal "code" (table of interpreted characters)
• Fuzzy Expect '~<' expect an approximate value 
• Scripts can be executable with the standard #!/usr/bin/env expect-lite line
• Include mechanism to read other script files (sourcing)
• Pass var=values to include scripts
• Color enhances output, differentiates log messages
• Automatic login to remote host (supporting telnet, ssh with password, and ssh with keys)
• Examples  showing complex actions easily scripted
• IPv6 Full Support
  
• Logging to a file, native support for saving output to a file
  
• Sleep, native support for sleeping with micro-second resolution new in 4.9.0

• Static and Dynamic Variables with math functions and pseudo arrays
• String Math allows manipulation of strings: search/replace, +, - 
• Constants, passed on the command line or set as environment variables, which override variables in the script. Powerful feature allows any variable to be passed on the command line
  
• Leverages Bash shell passing unknown variables to the shell
  

• Regular expression (regex) evaluation in expected results
• Non-Regex evaluation also available in expected results 
• Conditional Branching a if/then/else with a c-like syntax
• Testing undefined variables useful for setting default variable values
  
• Simple looping using conditional branching, a repeat loop can be constructed with infinite loop protection
• Code Blocks group lines of script for while loops and conditionals with then and else blocks 
• Foreach loops Iterate through a list 

• Multiple Sessions enabling interaction with a client and a server in one script
  
• Not Expect - a feature to look for unexpected text/strings
• Directives controls behaviour of expect-lite, enabling/disabling logging, shell, fail-script...
• User defined prompt allows interaction with a wider range of hosts (routers, switches, etc)
  
• Embedded Expect - using native expect embedded in an expect-lite script
• Library mode use expect-lite as a TCL package 
  
• User Defined Script Help makes your script more user-friendly 
• Simple Regression Support enables combining scripts for faster testing

• Instant-Interact empowers on the spot debugging without having to set breakpoints
• Powerful Integrated Debugger set breakpoints, step/skip, copy/paste lines into running script
  
• Debugger improvements show environment, improved paste support, and expect timeout operations  

Introduction

Automatic Login

• telnet
• ssh with password
• ssh with keys (no password)

./setup_local_ssh.sh

• Automatically log into the remote host via telnet or ssh (if ssh keys have been previously setup)
• Change directory to the passed directory (if included)

./expect-lite remote_host=remote-host-018 cmd_file=basic_ping_test.elt user_dir=/etc

./expect-lite r=remote-host-018 c=basic_ping_test.elt d=/etc

./expect-lite -r remote-host-018 -c basic_ping_test.elt -d /etc

Env Var	Description
EL_REMOTE_HOST	Name or IP of remote host
EL_CMD_FILE	Name of expect-lite script to run
EL_USER_DIR	Change to this directory upon login before executing script
EL_CONNECT_METHOD	The method expect-lite uses to connect to remote host. Valid options are: none|telnet|ssh|ssh_key Default is none
EL_CONNECT_USER	User name to use for login on remote host (telnet|ssh)
EL_CONNECT_PASS	Password to use for login on remote host (telnet|ssh)
EL_LOG_EXT	The log file name extension string, default=".log" (see *LOG)
EL_INFINITE_LOOP=N	Infinite Loop protection value, set N to user's default value (default=5000) (see *INFINITE_LOOP)
EL_DELAY_WAIT_FOR_HOST	Delay (in ms) to wait for host in Not Expect, and Dynamic Var Capture. 100 ms is a good value for a local LAN, 200 ms if running across high speed internet
EL_SHELL	Start this shell (default=bash) when using EL_CONNECT_METHOD=none
EL_DYN_VAR_PROMPT	Set the Dynamic Variable capture method to require a prompt (default=1). Disable by setting to 0.
EL_*	Any other shell environment variables starting with EL_ will become constants

Special Character Sequences

>pwd
</home/user

Char	Action
>	send string to the remote host
>>	send string to remote host, without waiting for prompt (see implementation details)
<	string/regex MUST be received from the remote host in the alloted timeout or the script will FAIL! (see test failure)
<<	literal string MUST be received (similar to '<' without regex evaluation)
-<	if string/regex IS received from the remote host the script will FAIL! (see Not Expect)
~<	expect an approximate number (see Fuzzy Expect)
#	used to indicate comment lines, and have no effect
;	are also used to indicate comment lines, but are printed to stdout (for logging)
;<colour>	add custom colour comment lines, colour may be blue,  ltblue,  gray,  ltgray,  cyan,  black, pink, purple, red, green, yellow
;;	similar to above, but no extra newlines are printed (useful for printing script help)
;;;	Marks the beginning and end of user defined script help (see script help)
@num	changes the expect timeout to num of seconds
:num	sleeps for num seconds. Mili-seconds also supported e.g.  :1.005 is 1005 mili-seconds (see sleep)
$var=	static variable assignment at script invocation (see variables for details)
+$var=	dynamic variable assignment  (see variables)
+$var	increment value of $var by 1 decimal (see repeat loop)
-$var	decrement value of $var by 1 decimal
=$var	math functions, perform bitwise and arithmetic operations:  << >> & | ^ * / % + - (see math functions)
=$string	string math functions, maniuplate strings: + - / // (see string math functions)
!	indicates an embedded expect line (see embedded expect)
?	c-style if/then/else in the format ?cond?action::else_action (see conditionals and code blocks)
[ <test> ]	while loop (see code blocks)
[ $var=list ]	foreach loop (see code blocks)
%	label - used for jumping to labels (see conditionals)
~filename var=value	includes a expect-lite automation file, useful for creation of common variable files, or 'subprograms/subroutines' (see include files)

• ^C or break, when it is desired to stop a running program e.g. >^C or >>^C
• ^] or escape from telnet, e.g. >^] This will bring the script to the telnet prompt, then use: >quit
• ^<any char> will send a control character to the remote-host, such as ^D to logout

	Expect-lite Directives
*~filename	Include a fail script, which expect-lite runs only if the main script fails (see fail script)
*/prompt/	Set a user defined prompt (see user defined prompt)
*TERM <N>	Immediately terminates script, but returns 0 (pass), or if N is specified returns the value of N (0..255)  (see stopping execution early)
*FAIL	Immediately fails script, and returns 1 (fail) (see stopping execution early)
*NOFAIL	Script will run to completion, and returns 1, if failure occurred during execution, or 0, if pass
*NOINTERACT	Will ignore breakpoints (*INTERACT), good for regression testing (see directives)
**SHELL=<shell>	Configuration directive which sets the shell immediately after automatic login to remote host (see setting the shell)
*INTERACT	Sets a breakpoint and places user in interact mode, which pauses the script and turns control of the keyboard over to the user (see Tips & Techniques: Interact)
*FORK <session>	Multiple session support. Directs expect-lite to open a new session and spawns a newshell (see multiple sessions)
*SHOW VARS	Debug information, displays all expect-lite variables. Can be used in interact mode.
*EOLS LF *EOLS CRLF	Controls end of line sequence sent to remote host, either line feed, or carriage return & line feed.
*DVPROMPT *NODVPROMPT	Enable/disable the Dynamic Variable capture method to require a prompt (default=*DVPROMPT).  (see Dynamic Variable capture method)
*INFINITE_LOOP <N>	Sets/resets the infinite loop protection value, which is a total count of all loops in script. Default is 5000
*NOINCLUDE	Ignore include files (was default behavour in library mode)
	Logging Directives
*LOG *NOLOG	Enable/disable logging to a file. Will create file <script_name>.log (same as $arg0.log) if no path/file_name is supplied.(see managing logging)
*LOG  <file_name> *LOGAPPEND <file_name>	Enable  logging to a user specified path/file_name. When invoked on the CLI, the specified file_name must end in ".log" to  avoid ambiguity
*INFO *NOINFO	Enable/disable informational messages
*WARN *NOWARN	Enable/disable warning messages
*DEBUG *NODEBUG	Enable/disable debug messages
*NOCOLOR	Disables color output, best when logging output
*TIMESTAMP <ISO|YMD|DMY|MDY>	Prints Date and Timestamp for each command sent, ISO is default
*NOTIMESTAMP	Disables timestamp printing

IPv6 Support

General Tips for writing scripts

• Use reasonable timeouts, if 30 seconds is needed to get a response, set the timeout at 45 or 60 seconds, not 600.
• There is no cost to changing the timeout, timeout values can also be variables
  
• Beware of expect-lite using regex, when creating lines like: <0.005 secs (5 micro secs)
• The parentheses is used by the regex engine, instead escape these characters: <0.005 secs \(5 micro secs\) (see Use of Regex in expect-lite)
• or use '<<' which does not use regex, and does not require escaping: <<0.005 secs (5 micro secs) (see using non-regex evaluation)
• Use the expect character '<' or '<<' often. Check for valid results when possible. A script which expects nothing will never fail! (see Test Failure)
• Use printable comments ';'  and ';;' often. Think of it as writing a note to oneself, it will make reading log files much easier. As of version 3.7.0 printable comments will be coloured blue (this is user configurable).
• Variable assignments use no spaces e.g. $var=value. Note no spaces around the equals sign, this permits leading spaces in the value such as $var=  myvalue

Debugging Expect-lite Scripts

Reference

Use of Regex in expect-lite

1. Support of regex in standard expect (e.g. including anchors, char-classes and repeats)
   
2. Support of regex meta characters (e.g. \t \n \d)
3. Expect-lite only evaluates lines using regex which begin with '<'  '-<'  '~<' and '+' (dynamic variables)
   

> /sbin/ifconfig eth0
<inet addr:10\.29\.200\.\d\d\s

Using << for non-regex evaluation

>grep body my_html_file.html
<<body.+>

>grep body my_html_file.html
<[<]body.+>

Using Variables

• Static, which are bound at invocation
  
• Dynamic, which are bound during execution of the script
  

$myvar=myvalue

$myvar=

Dynamic Variables

+$somevar=text that is not put into the var (text which is put into the var)

> command
+$myvar=command output (capture value) more command output

Assigned Var:somevar=sometext which is put into the var

Assigned Var:somevar=__NO_STRING_CAPTURED__

> command
+$myvar=\n(.*)

> echo $PWD
+$mypwd=\n(/[a-zA-Z0-9/\-_]+)

Math Functions with Variables

$myvar=1
=$myvar + 2 * 10

$myvar=1
=$myvar + 2 * (10 + 1)

=$myvar + 2 * 10

Warning: Expect-lite: Unable to interpret =$answer1 / 2 * (10 + 1) 
syntax error in expression " / 2 * (10 + 1)": unexpected operator /

$five=5
=$myvar + $five / 2.0

$five=5
=$myvar + $five / 2

String Math Functions with Variables

• Concatenation using +
• Removal using -
• Search and Replace using / or //
  

$mylist=abc,def,hig
$lmnvar=,lmn
=$mylist + $lmnvar

$mylist=abc,def,hig
$lmnvar=,def
=$mylist - $lmnvar

=$myvar /search/replace/

$mylist=abc,def,hig
=$mylist //,/ /

$myip=192.168.0.50
=$myip /\d+\.\d+\.\d+\.(\d+)/\1/

Pseudo Arrays

$myarray$count=some $value

Constants

./expect-lite remote_host=remote-host-018 cmd_file=basic_ping_test.elt \
user_dir=/etc local_eth=eth2

Shell Variables

> PWD=`pwd`
> echo $PWD

> PWD=`pwd`
>pwd
< $PWD

> echo $PWD
+$mypwd=\n(/[a-zA-Z0-9/\-_]+)

Undefined Variables

Environment Variables starting with EL_

>sudo tcpdump -i eth0
<<[sudo] password
>>$EL_sudopass

Using Conditionals & Labels

$age=56
? $age >= 55 ? >echo "freedom at 55!" :: > echo "keep working!"

$platform=ppc
? $platform == i386 ? ~connect_i386.inc :: ~connect_ppc.inc

If: expr { "ppc" == "i386" } |then ~connect_i386.inc|else ~connect_ppc.inc|result0

$platform=ppc
? $platform == i386 ? $my_addr=2001:db8::f00d :: $my_addr=2001:db8::feed

$blank=
?if $TEST ==$blank? ; === echo this :: ; === echo that
?if $TEST !=  ? ; === echo this :: ; === echo that

$kmodules_inserted=true
? $kmodules_inserted == false ? %SKIP_CHECK_KMODS
>lsmod | grep nfs
<nfsd
<exportfs
<sunrpc
%SKIP_CHECK_KMODS

; === Test conditional jump to label
? $jump == true ?%move along, nothing to see
>echo "1"
>echo "2"
>echo "3"
%move along, nothing to see

Jumping to label:%move along, nothing to see

Looping with Conditionals & Labels

; ======== Incrementing Loop ========
$max=5
$count=3
%REPEAT_INC_LOOP
	>echo $count
	# increment variable
	+$count
?if $count <= $max ?%REPEAT_INC_LOOP

Using Code Blocks with Conditionals, While Loops and Foreach Loops

; === Conditional using code block
? $case == true ? [
	>echo "1"
	>echo "2"
	>echo "3"
]

; === Conditional using code block as else statement
? $case == true ? >echo "true" :: [
	>echo "false 1"
	>echo "false 2"
	>echo "false 3"
]
      

; === Conditional using code block then and another code block else statement
? $case == true ? [
	>echo " 1"
	>echo " 2"
	>echo " 3"
]::[
	; else code block
	>echo " 4"
	>echo " 5"
	>echo " 6"
]

; === NOT SUPPORTED Conditional using code block then and else statement
? $case == true ? [ :: [
	>echo " 1"
] 

$test=3
; === nested ifs using code blocks
?if 1 < $test ? [ :: >echo "else 1"
	?if 2 < $test ? [ :: >echo "else 2"
		>echo "if 2"
	]
]

; === while loop
$i=0
[ $i < 3
	>echo "hello $i"
	<hello $i
	+$i
]     

;; == Nested while loops, should repeat "hello ken" 3 times
;; == with 2 "bye now's inside each outer loop
>
$i=0
[ $i < 3
	>echo "hello ken"
	<ken
	$j=0
	[ $j < 2 
		>echo "bye now"
		>
		+$j
	]
	+$i
]

; === foreach loop
[ $planet=mercury venus earth mars jupiter  saturn  uranus     neptune
	>ping -c1 $planet
]

*INFINITE_LOOP 20

Slowing Loops with sleep

; === while loop with sleep
$eth_status=DOWN
[ $eth_status == DOWN 
	>ip link show dev eth0
        +$eth_status=(DOWN|UP)
	:5
]  

$ ip link show dev eth0
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000

Assigned Var:eth_status=UP

Sleeping: 5 
....+ 

Sleeping: ....+....10....+....20.... 

#sleep 1/10th of a second
:.1

#sleep using a variable
$sleeper=5.5
:$sleeper

Script Help with --help -h

;;;
Test: 	Test bash here doc
		
Assumptions:	bash
Platforms: 	anywhere bash runs
;;;

$ ./test_bash_here_doc.txt -h
Help for: ./test_bash_here_doc.txt

        Test:   Test bash here doc

        Assumptions:    bash
        Platforms:      anywhere bash runs

Displaying assigned variables, which can be overridden with 
a Constant on command line e.g var=value
        tempfile=junk

$ ./test_bash_here_doc.txt tempfile=/tmp/mydata.txt
      

Expect-lite & Bash

$set=1 2 3 4 5
>for i in $set #expanded by expect-lite
>{
>echo $i #expanded by bash
>}

$max=5
>i=0
>while [ $i -lt $max ]
>do
>echo $i
>let i+=1
>done

$max=4
>if [ $max -ne 5 ]; then
>echo "max is not equal to 5"
>else
>echo "we have a winner"
>fi

>PROC=`uname -i`
>if [ "$PROC" == "i386" ]; then
>echo proc20
>else
>echo proc100
>fi
+$loop_counter=\nproc([0-9]+)

#!/usr/bin/env expect-lite

chmod 775 my_expect-lite_script.elt

$ ./my_expect-lite_script.elt -r host-15 -u craig max_loop_count=100

Include Files

# Source common variable file
~asic_vars.inc

; === Connect to DUT 
~dut_connect.inc user=root

# Source Var file to be used
$asic_include=asic_vars.inc
...
~$asic_include

##Include Result: FAILED: dns_connect.inc    

Embedded Expect

# Preserve old timeout using embedded expect
!set user_namespace(TIMEOUT) $timeout
# set timeout to 15 seconds - max time to wait for login prompts
@15
>telnet $dut_ip
<login
>>root
<assword
>>my_secret
>
# Set the timeout back to old timeout
@$TIMEOUT

!if { $arch == "ppc" } { 
! puts "\narch is $arch\n"
!} 
>

!for {set j 1} {$j<6} {incr j} {
! if {$j == 1} {set type "abc" } 
! if {$j == 2} {set type "def" }
! if {$j == 3} {set type "hij" }
! if {$j == 4} {set type "lmn" }
! if {$j == 5} {set type "qrs" }
! 
! puts "$j>$type"
!}
>

!send "ls\n"
!expect -re "test" { puts "got test"} timeout {puts "got nothing"}

!if { $arch == "ppc" } { 
! puts "\narch IS $arch\n" 
! } else { 
! puts "\narch is NOT ppc, but $arch\n" 
! _el_fail_test 
! } 
>

• Limited support of expect global variables. To declare a variable at the top level as global use "set ::<var> <value>" The double colon '::' makes var global (this is a TCL standard)
• tcl/expect switch command not supported
• expect statements must be on one line (as in the example above)
  

Expect-lite Directives '*'

• fail script - run when the script fails *~include_fail_script
• user defined prompt - for those non-unix/linux remote hosts */regex/
• stopping the script - *TERM & * FAIL
• setting the default shell - **SHELL
• multiple sessions - for hard to script environments *FORK
• managing logging - *INFO, *NOINFO, *WARN, *NOWARN, *DEBUG, *NODEBUG, *NOCOLOR
• debugging aid - *INTERACT (see debugging tips)
• print all expect-lite variables - *SHOW VARS
• control end of line character(s) - *EOLS LF, *EOLS CRLF
• control dynamic variable capture method to require a prompt or not *DVPROMPT, *NODVPROMPT
  
• allow script to run to completion regardless of failure status *NOFAIL
• ignore breakpoints (used for regression) *NOINTERACT
  

Fail Script    *~include_fail_script

*~clean_up.inc

User Defined Prompt   */prompt/

*/my_prompt /

*/\(gdb\) /

*/\(gdb\) |my_prompt /

*/login: |.+ssword: /
>telnet remote-host-018
<Connected to
>$username
>$password
>

*//

(gdb) Warning:Prompt Timed Out!
DEBUG: User Defined Prompt:<<\(gbb\) >>
 Not Found in<<
(gdb) 
>>

Setting the default shell with **SHELL=<shell>

Stopping the script early with *TERM, *PASS & *FAIL

No stopping the script with *NOFAIL

More no stopping with *NOINTERACT

Debugging by examining expect-lite variables with *SHOW VARS

Multiple Sessions *FORK

*FORK Server
INFO: FORK session is: Server

*FORK default
INFO: FORK session is: default

*FORK
INFO: FORK session is: Server

$my_session=Client
*FORK $my_session
INFO: FORK session is: Client

expect-lite directive: *INTERACT 

 Press '+++' to end interact session & return to script 

% *FORK CONSOLE

INFO: FORK session is: CONSOLE, Active sessions are: default CONSOLE
# 

Managing Logging *LOG, *LOGAPPEND, *NOLOG, *INFO, *NOINFO, *EXP_INFO, *NOEXP_INFO, *WARN, *NOWARN, *DEBUG, *NODEBUG, *NOCOLOR

• *LOG: with no file name, will automatically create a log file with the script name + ".log" in the same directory as the script. If a path/file name is supplied, expect-lite will write standard out and additional info (INFO, WARN, DEBUG) to the path/file name file. Because parameters can be entered in any order on the CLI, the path/file_name must end in ".log" to prevent ambiguity.
  
• *NOLOG: closes any open logging files, and disables any additional output from be saved to a file. When used on the CLI, all logging to a file will be disabled.
  
• *LOGAPPEND: Will cause output to be appended to an existing file, or create a new file if existing file doesn't exist. Output will be appended to path/file_name, when using *LOGAPPEND <path/file_name>.
  

• INFO: Entering FORK sessions, Constant substitution, Conditional Statement Results, Jumping to labels, Including files, Dynamic Variable Assignments, User Defined Prompt assignments, Sleep progress dots and ##Overal Result.
  
• EXP_INFO: prints "expected" text (lines with < or <<). Also enabled with -V flag on the command line.
• WARN: Instant-Interact feature disabled, Wait-for-prompt timeouts, Using localhost (r=none), Unable to parse Conditional, Dynamic Variable Capture timeouts, Unable to parse math variable statement, Unable to parse FORK session name, Unable to parse Conditional Statement
• DEBUG: Additional debugging information for: User Defined Prompt, FORK session instantiation/switching, '<' searching, Dynamic Variable capture

Controlling End of Line Sequence with *EOLS

Controlling Dynamic Variable capture method with *DVPROMPT/*NODVPROMPT

$ date
Sat Jul 19 18:19:58 EDT 2014
$ 

>date
+$month=\n\w+ (\w+)

Examples of Expect-lite

$local_eth=eth1
$ip_addr=192\.168\.10\.2
# change timeout value to 10 sec
@10
>ifconfig $local_eth $ip_addr
#check to ensure that we set the right IP address
>ifconfig
<$ip_addr

@2
>telnet remote-host-018
<Connected to
<login
>>root
<assword
>>secret_password
# issue a command once logged in
>pwd
>^]
>quit

>ssh root@host-021
<assword:
>>secret_password
# issue a command once logged in
>ls
>exit

; ==== Use Screen command for to keep application running ====
>screen 
> $pmm 
# Check that HW is alive
>ping
<Successfully pinged the PM H/W
; ==== Keep pmm application active, and detach from this screen
>>^A
>>^D
<detached
>

>uname -a
+$host=Linux ([a-z\-0-9]+)
Assigned Var:host=remote-host-008
>

>env | sort
+$home=\nHOME=([a-z/]+)
+$shell=\nSHELL=([a-z/]+)
<TERM=xterm
Assigned Var:home=/home/joe
Assigned Var:shell=/bin/bash
>

#prompt is $ and space after $
$prompt=\$ 
>env | sort
+$env_list=((.|\n|\r)*)$prompt

>id
# allow either groups users or wheel
<(users|wheel)

# date stamp of script run time
>echo `date +_%Y_%m_%d_%H-%M-%S`
+$DATE=\n(_[0-9_-]+)

$temp_file=$arg0$DATE
; === Create a temp file using bash "here doc" method
>cat > $temp_file <<'+++'
>line 1
>line 2
>+++
>

./upgrade_script.elt sw_build=0015

$sw_build=0000
; === Check passed parameters
>
*NOINFO
?if $sw_build != 0000 ? %CONTINUE
	;; ##############################
	;;	$arg0 Requires parameters: sw_build, IP
	;;	e.g. $arg0 sw_build=0015 IP=10.3.5.4
	;; ##############################
	# quit the script without continuing
	*FAIL
%CONTINUE
*INFO

./upgrade_script.elt

 === Check passed parameters

expect-lite directive: *NOINFO 
 ##############################
 upgrade_script.elt Requires parameters: sw_build, IP
 e.g. upgrade_script.elt sw_build=0015 IP=10.3.5.4
 ##############################

expect-lite directive: *FAIL 

;;;
Test: 	Test bash here doc
		
Assumptions:	bash
Platforms: 	anywhere bash runs
;;;

$ ./test_bash_here_doc.txt -h
Help for: ./test_bash_here_doc.txt

        Test:   Test bash here doc

        Assumptions:    bash
        Platforms:      anywhere bash runs

Displaying assigned variables, which can be overridden with 
a Constant on command line e.g var=value
        tempfile=junk

# ignore breakpoints in include files
*NOINTERACT
# do not stop on failures
*NOFAIL

######### List of tests to run in regression
$blank=
$tc0=ipv6_telnet.elt
$tc1=ipv6_ndp.elt
$tc2=ipv6_self_syslog.elt mode=ipv4
$tc3=ipv6_self_syslog.elt mode=ipv6
$tc4=

$start=0
$count=$start

[ $tc$count != $blank
	; ============== starting $tc$count
	~$tc$count
	; ============== end $tc$count

	# increment variable
	+$count
]

./regression.elt start=1 *LOG

Test Failure?!?

$ip_addr=192.168.10.99
>/sbin/ifconfig eth0 $ip_addr
>/sbin/ifconfig eth0 
< $ip_addr

>ls -l /dev/linux
-<No such file

; === fail if today is 'Monday'
>date +%A
-<Monday

>ls -1 /dev/ttyS*
-<ttyX
<ttyS2

>ip link show
<eth4
-<state DOWN

; set the fuzzy expect range to 7
~=7

; Check the date/day of the month
>date "+the day is: %d"
~<the day is: (7)

How can it help?

Limitations

Implementation Details

Variables

$bell=For whom the bell tolls
>echo $bell
For whom the bell tolls

Implied "wait for prompt"

> $some_long_command
<critical value
# wait for prompt
>

; ==== Create Test File on the fly
> cat > $regex_test_file << '+++'
>T00001/a(?$XL.*)/tag=0x08000001
>T00002/b(?$XR.*)/tag=0x08000002
>T00003/c(?$XO[0-7]*)/tag=0x08000003
>T00004/d(?$XH[0-9A-F]*)/tag=0x08000004
>T00005/e(?$XD[0-9]*)/tag=0x08000005
>+++
>

Predefined variables

Timeouts

Expect Input Buffer

; === set expect buffer big
!match_max -d 20000

Timing is everything: delay_wait_for_host

Unsynchronized messages disclaimer

; === starting long command
>
>start_long_command

Instant-Interact: More than just a pretty prompt

$MYVAR=today

*SHOW VARS
Var:0 Value:0
Var:MYVAR Value:today
Var:TEST Value:/proc/cpuinfo

>>pwd
pwd
/home/user

# clump 1
>ls /etc/
<group
<passwd

#clump 2
>date "+TIME: %H:%M:%S"
+$time=\nTIME: ([0-9:]+)

*FORK: what happens behind the scenes

Localhost Remote Host
 +----New_Session1--->Client App
 +----New_Session2--->Server App

What's missing

Why Expect-lite