```show "doc/tst_suite/tst_var_syn.gri ..." ...
rpnfunction same - abs 1e-10 >          # Are numbers virtually same?

# New and delete (variables)
.v. = 1
new .v.
.v. = 2
assert {rpn .v. 2 same}                 " failed test 1.1"
assert {rpn ".v." defined}              " failed test 1.2"
delete .v.
assert {rpn .v. 1 same}                 " failed test 1.3"
assert {rpn ".v." defined}              " failed test 1.4"
delete .v.
assert {rpn ".v." defined !}            " failed test 1.4"

# New and delete (synonyms)
\v = "hi"
new \v
\v = "hello"
assert {rpn "\v" "hello" ==}            " failed test 2.1"
assert {rpn "\\v" defined}              " failed test 2.2"
delete \v
assert {rpn "\v" "hi" ==}               " failed test 2.3"
assert {rpn "\\v" defined}              " failed test 2.4"
delete \v
assert {rpn "\\v" defined !}            " failed test 2.5"

# Multi-word synonyms
\h = "Hi there buddy"
assert {rpn  \[]h    3      ==}         " failed test 3.1"
.i. = \[]h
assert {rpn  .i.     3      ==}         " failed test 3.2"
assert {rpn "\[0]h" "Hi"    ==}         " failed test 3.3"
assert {rpn "\[1]h" "there" ==}         " failed test 3.4"
assert {rpn "\[2]h" "buddy" ==}         " failed test 3.5"
\h = "Hi means \"hello\""
assert {rpn "\[0]h" "Hi"        ==}     " failed test 3.6"
assert {rpn "\[1]h" "means"     ==}     " failed test 3.7"
assert {rpn "\[2]h" "\"hello\"" ==}     " failed test 3.8"
.i. = 1
assert {rpn "\[.i.]h" "means"   ==}     " failed test 3.9"
\i = "1"
assert {rpn "\[\i]h"  "means"   ==}     " failed test 3.10"

# Setting by quoted name
set ".var." to 10
assert {rpn .var. 10 ==}                " failed test 4.1"
set "\\syn" to "hi"
assert {rpn "\syn" "hi" ==}             " failed test 4.2"

# Setting by quoted name, in a new command
`hi pi "\\Greeting" ".Pi."'
{
set "\.word2." to "hi"
set "\.word3." to 3.14
}
hi pi "\\g" ".p."
assert {rpn "\g" "hi" ==}                       " failed test 5.1"
assert {rpn .p.  3.14 ==}                       " failed test 5.2"

# Execution of synonyms
\ret = "\string = \"Hello\""
\ret
assert {rpn "\string" "Hello" ==}               " failed test 6.1"

# Parsing of individual words in synonyms (tests SourceForge bug 114983)
`Newcommand "\pat"''
{
\t = "A .2"
assert {rpn "\[0].word1." "\[0]t" ==}       " failed test 7.1"
}
Newcommand "A .2"

# Test aliased synonyms

# Part 1. check to see if can delete without either a
# single or a double backslash, and either with
# enclosing double-quotes, or not.
\a = "HI"
assert {rpn "\\a"    defined   }                " failed test 8.1"
delete \a
assert {rpn "\\a"    defined ! }                " failed test 8.2"
\a = "HI"
delete \a
assert {rpn "\\a"    defined ! }                " failed test 8.3"

new \a
assert {rpn "\\a"     defined   }               " failed test 9.1"
\a = "greeting"
assert {rpn "\\a"     defined   }               " failed test 9.2"
delete \a
assert {rpn "\\a"     defined ! }               " failed test 9.3"

# Part 5. sprintf
sprintf \a "%.1f" 10
assert {rpn "\a" "10.0" == }                    " failed test 10.1"
\alias_for_a = "\\a"
sprintf \@alias_for_a "%.1f" 20
assert {rpn "\a" "20.0" == }                    " failed test 10.2"

# Part 6. Environment variables (SF bug 117415)
\alias_for_a = "\\a"
get env \@alias_for_a "SHELL"
get env \b "SHELL"
assert {rpn "\a" "\b" ==}                       " failed test 11.1"

# Part 7 'read' (SF bug 117412)
system echo "Hello" > test.dat
open "test.dat"
read \a
assert {rpn "\a" "Hello" ==}                    " failed test 12.1"
\a = "JUNK"
\alias_for_a = "\\a"
rewind
read \\a
assert {rpn "\a" "Hello" ==}                    " failed test 12.2"
\a = "JUNK"
\alias_for_a = "\\a"
rewind
read \@alias_for_a
close
assert {rpn "\a" "Hello" ==}                    " failed test 12.3"
system rm -f test.dat

# Part 8 -- ensure not trying to evaluate inside 'false' if parts.
\str = "Hello"
\t = {rpn "\s" "tr" strcat}	# construct a name
if {rpn "\\t" defined}		# test if defined
.val. = 1
end if
if {rpn "\\x" defined}		# this one is not defined
.val. = 2
end if
assert {rpn .val. 1 ==}                         " failed test 12.4"

#
\a1 = "1"
\b1 = "2"
\a2 = "10"
\b2 = "20"
read columns x y
\a1 \b1
\a2 \b2

assert {rpn x 0 @  1 ==}                        " failed test 13.1"
assert {rpn x 1 @ 10 ==}                        " failed test 13.2"
assert {rpn y 0 @  2 ==}                        " failed test 13.3"
assert {rpn y 1 @ 20 ==}                        " failed test 13.4"

`NC ...'
{
read columns x y
\.word1 \.word2.

}
NC 1 10
assert {rpn x 0 @  1 ==}                        " failed test 14.1"
assert {rpn y 0 @ 10 ==}                        " failed test 14.2"

\a = "1  2"
\b = "10 20"
\index = "0"
read columns x y
\[\index]a \[1]b

assert {rpn x 0 @  1 ==}                        " failed test 15.1"
assert {rpn y 0 @ 20 ==}                        " failed test 15.2"

`NC2 ...'
{
read columns x y
\[0].word1. \[0].word2.
\[1].word1. \[1].word2.

}
NC2 "1 2" "100 200"
assert {rpn x 0 @   1 ==}                        " failed test 16.1"
assert {rpn x 1 @   2 ==}                        " failed test 16.2"
assert {rpn y 0 @ 100 ==}                        " failed test 16.3"
assert {rpn y 1 @ 200 ==}                        " failed test 16.4"

# Part 9. New commands with variables

# Rvalue: synonyms/variables
`ampersand_rvalue &.v. &\s'
{
new \syn
\syn = "Shadow"
new .a.
.a. = 0
assert {rpn \.word1. 1 ==}                   " failed test 17.1"
assert {rpn "\.word2." "Brightness" ==}      " failed test 17.2"
delete \syn
delete .a.
}
.a. = 1
\syn = "Brightness"
ampersand_rvalue &.a. &\syn

# Rvalue + Lvalue: synonym
`append &\s'
{
\.word1. = "\.word1. and bye"
}
\a = "hi"
append &\a
assert {rpn "\a" "hi and bye" ==}                "failed test 18.3"

# Rvalue + Lvalue: variable in the = form of assignment
`double &.var.'
{
\.word1. = {rpn \.word1. 2 *}
}
.a. = 10
double &.a.
assert {rpn .a. 20 ==}                           "failed test 18.4"

`Double &.var.'
{
\.word1. *= 2
}
.a. = 10
Double &.a.
assert {rpn .a. 20 ==}                          " failed test 18.5"

`halve &.var.'
{
\.word1. = {rpn \.word1. 2 /}
}
halve &.a.
assert {rpn .a. 10 ==}                          " failed test 18.6"

`NC3 &\friendly'
{
\.word1. = "Howdy"
}
\greeting = "Hi"
NC3 &\greeting
assert {rpn "\greeting" "Howdy" ==}             " failed test 18.7"

`postpend_dat &\filename'
{
\.word1. = {rpn "\.word1." ".dat" strcat}
}
\filename = "test"
postpend_dat &\filename
assert {rpn "\filename" "test.dat" ==}          " failed test 18.8"

# new
`test_new &\s'
{
new \.word1.
new \a
\a = "This will dissapear"
\.word1. = "Think locally"
delete \a
}
\a = "Act globally"
test_new &\a
assert {rpn "\a" "Think locally" ==}             " failed test 18.9"
delete \a
assert {rpn "\a" "Act globally" ==}              " failed test 18.10"

`test_new_delete &\s'
{
new \a
\a = "Insurrection"
assert {rpn "\.word1." "Act globally" ==}    " failed test 18.11"
delete \.word1.
assert {rpn "\.word1." "Or else" ==}         " failed test 18.12"
delete \a
}
\a = "Or else"
new \a
\a = "Act globally"
test_new_delete &\a

# Nexting
`nest2 &.v. &\s'
{
assert {rpn "\.word1." "HI" ==}              " failed test 18.13"
assert {rpn \.word2. 0.5 ==}                 " failed test 18.14"
}
`nest1 &.v. &\s'
{
nest2 &\.word2. &\.word1.	# reversed
}
.a. = 0.5
\s = "HI"
nest1 &.a. &\s
# defined
`check_defined &.v.'
{
assert {rpn "\\.word1." defined}             " failed test 18.15"
delete .a.
assert {rpn "\\.word1." defined !}           " failed test 18.16"
}
.a. = 100
check_defined &.a.

# System
\t = system perl <<"EOF"
{print "Hi"};
EOF
assert {rpn "\t" "Hi" ==}                       " failed test 19.1"
\t = system perl <<"EOF"
{print "Hello"};
EOF
assert {rpn "\t" "Hello" ==}                    " failed test 19.2"
`NC4'
{
\t = system perl <<"EOF"
{print "Howdie"};
EOF
}
NC4
assert {rpn "\t" "Howdie" ==}                   " failed test 19.3"
`NC5'
{
\t = system perl <<"EOF"
{print "G'day"};
EOF
}
NC5
assert {rpn "\t" "G'day" ==}                    " failed test 19.4"

### BLOCK 20 ###
# Alias as lvalue (e.g. \@ptr = ...)
# (1) lvalue synonyms
\greeting = "You say goodbye"
\alias = "\\greeting"
\@alias = "And I say hello"
assert {rpn "\greeting" "And I say hello" ==}   " failed test 20.1"
# (2) lvalue variables
.b. = 1
\bptr = ".b."
\@bptr *= 2
assert {rpn .b. 2 ==}                           " failed test 20.2"
\@bptr = 10
assert {rpn .b. 10 ==}                          " failed test 20.3"

# Alias as rvalue (e.g. show "\@ptr")
# (1) rvalue synonyms
\a = "HI"
\aptr = "\\a"
assert {rpn "\@aptr" "HI" ==}                   " failed test 20.4"
\@aptr = "BYE"
assert {rpn "\@aptr" "BYE" ==}                  " failed test 20.5"
\aa = "\@aptr"
assert {rpn "\@aptr" "BYE" ==}                  " failed test 20.6"
# (2) rvalue variables
.a. = 1
\aptr = ".a."
assert {rpn \@aptr 1 ==}                        " failed test 20.7"
.aa. = {rpn .a. 1 +}
assert {rpn .aa. 2 ==}                          " failed test 20.8"

# Missing values
set missing value 0
.x. = 0
assert {rpn .x. ismissing}                      " failed test 21.1"
assert {rpn .x. 1 + ismissing}                  " failed test 21.2"
set missing value 1e33

show " passed"
```