# Test Overview

## `test01.bas`

Scalar variable assignment

### Test File

```basic
10 a=1
20 print a
30 a$="hello"
40 print a$
50 a=0.0002
60 print a
70 a=2.e-6
80 print a
90 a=.2e-6
100 print a
```

### Expected Result

```
 1
hello
 0.0002
 0.000
 0.0000020
 0.0000002
```

### Notes

Output would differ on other platforms NttX does not use scientific notation in
floating point output.

## `test02.bas`

Array variable assignment

### Test File

```basic
10 dim a(1)
20 a(0)=10
30 a(1)=11
40 a=12
50 print a(0)
60 print a(1)
70 print a
```

### Expected Result

```
 10
 11
 12
```

## `test03.bas`

`FOR` loops

### Test File

```basic
 10 for i=0 to 10
 20   print i
 30   if i=5 then exit for
 40 next
 50 for i=0 to 0
 60   print i
 70 next I
 80 for i=1 to 0 step -1
 90   print i
100 next
110 for i=1 to 0
120   print i
130 next
140 for i$="" to "aaaaaaaaaa" step "a"
150   print i$
160 next
```

### Expected Result

```
 0
 1
 2
 3
 4
 5
 0
 1
 0

a
aa
aaa
aaaa
aaaaa
aaaaaa
aaaaaaa
aaaaaaaa
aaaaaaaaa
aaaaaaaaaa
```

## `test04.bas`

`REPEAT` `UNTIL` loop

### Test File

```basic
10 a=1
20 repeat
30   print a
40   a=a+1
50 until a=10
```

### Expected Result

```
 1
 2
 3
 4
 5
 6
 7
 8
 9
```

## `test05.bas`

`GOSUB` `RETURN` subroutines

### Test File

```basic
10 gosub 100
20 gosub 100
30 end
100 gosub 200
110 gosub 200
120 return
200 print "hello, world":return
```

### Expected Result

```
hello, world
hello, world
hello, world
hello, world
```

## `test06.bas`

Recursive function without arguments

### Test File

```basic
10 def fnloop
20   if n=0.0 then
30     r=0.0
40   else
50     print n
60     n=n-1.0
70     r=fnloop()
80   end if
90 =r
100 n=10
110 print fnloop
```

### Expected Result

```
 10
 9
 8
 7
 6
 5
 4
 3
 2
 1
 0
```

## `test07.bas`

Recursive function with arguments

### Test File

```basic
10 def fna(x)
20   if x=0 then r=1 else r=x*fna(x-1)
30 =r
40 print fna(7)
```

### Expected Result

```
5040
```

## `test08.bas`

`DATA`, `READ` and `RESTORE`

### Test File

```basic
10 data "a",b
20 data "c","d
40 read j$
50 print "j=";j$
60 restore 20
70 for i=1 to 3
80 read j$,k$
90 print "j=";j$;" k=";k$
100 next
```

### Expected Result

```
j=a
j=c k=d
Error: end of `data' in line 80 at:
80 read j$,k$
        ^
```

## `test09.bas`

`LOCAL` variables

### Test File

```basic
10 def fna(a)
20   local b
30   b=a+1
40 =b
60 b=3
70 print b
80 print fna(4)
90 print b
```

### Expected Result

```
 3
 5
 3
```

## `test10.bas`

`PRINT USING`

### Test File

```basic
 10 print using "!";"abcdef"
 20 print using "\ \";"abcdef"
 30 print using "###-";-1
 40 print using "###-";0
 50 print using "###-";1
 60 print using "###+";-1
 70 print using "###+";0
 80 print using "###+";1
 90 print using "#####,";1000
100 print using "**#,##.##";1000.00
110 print using "+##.##";1
120 print using "+##.##";1.23400
130 print using "+##.##";123.456
140 print using "+##.";123.456
150 print using "+##";123.456
160 print using "abc def ###.## efg";1.3
170 print using "###.##^^^^^";5
180 print using "###.##^^^^";1000
190 print using ".##^^^^";5.0
200 print using "##^^^^";2.3e-9
210 print using ".##^^^^";2.3e-9
220 print using "#.#^^^^";2.3e-9
230 print using ".####^^^^^";-011466
240 print using "$*,***,***,***.**";3729825.24
250 print using "$**********.**";3729825.24
260 print using "$$###.##";456.78
270 print using "a!b";"S"
280 print using "a!b";"S","T"
290 print using "a!b!c";"S"
300 print using "a!b!c";"S","T"
```

### Expected Result

```
a
abc
  1-
  0
  1
  1-
  0+
  1+
 1,000
*1,000.00
 +1.00
 +1.23
+123.46
+123.
+123
abc def   1.30 efg
500.00E-002
100.00E+01
.50E+01
23E-10
.23E-08
2.3E-09
-.1147E+005
$***3,729,825.24
$**3729825.24
$456.78
aSb
aSbaTb
aSb
aSbTc
```

## `test11.bas`

`OPEN` and `LINE INPUT`

### Test File

```basic
10 open "i",1,"test.bas"
20 while not eof(1)
30 line input #1,a$
40 print a$
50 wend
```

### Expected Result

```basic
10 open "i",1,"test.bas"
20 while not eof(1)
30 line input #1,a$
40 print a$
50 wend
```

## `test12.bas`

Exception handling

### Test File

```basic
10 on error print "global handler 1 caught error in line ";erl : resume 30
20 print mid$("",-1)
30 on error print "global handler 2 caught error in line ";erl : end
40 def procx
50   on error print "local handler caught error in line";erl : goto 70
60   print 1/0
70 end proc
80 procx
90 print 1 mod 0
```

### Expected Result

```
global handler 1 caught error in line  20
local handler caught error in line 60
global handler 2 caught error in line  90
```

## `test13.bas`

Unnumbered lines

### Test File

```basic
print "a"
goto 20
print "b"
20 print "c"
```

### Expected Result

```
a
c
```

## `test14.bas`

`SELECT CASE`

### Test File

```basic
 10 for i=0 to 9
 20   for j=0 to 9
 30     print i,j
 40     select case i
 50       case 0
 60         print "i after case 0"
 70       case 1
 80         print "i after case 1"
 90         select case j
100           case 0
110             print "j after case 0"
120         end select
130       case 3 to 5,7
140         print "i after case 3 to 5, 7"
150       case is <9
160         print "is after case is <9"
170       case else
180         print "i after case else"
190     end select
200   next
210 next
```

### Expected Result

```
 0             0
i after case 0
 0             1
i after case 0
 0             2
i after case 0
 0             3
i after case 0
 0             4
i after case 0
 0             5
i after case 0
 0             6
i after case 0
 0             7
i after case 0
 0             8
i after case 0
 0             9
i after case 0
 1             0
i after case 1
j after case 0
 1             1
i after case 1
 1             2
i after case 1
 1             3
i after case 1
 1             4
i after case 1
 1             5
i after case 1
 1             6
i after case 1
 1             7
i after case 1
 1             8
i after case 1
 1             9
i after case 1
 2             0
is after case is <9
 2             1
is after case is <9
 2             2
is after case is <9
 2             3
is after case is <9
 2             4
is after case is <9
 2             5
is after case is <9
 2             6
is after case is <9
 2             7
is after case is <9
 2             8
is after case is <9
 2             9
is after case is <9
 3             0
i after case 3 to 5, 7
 3             1
i after case 3 to 5, 7
 3             2
i after case 3 to 5, 7
 3             3
i after case 3 to 5, 7
 3             4
i after case 3 to 5, 7
 3             5
i after case 3 to 5, 7
 3             6
i after case 3 to 5, 7
 3             7
i after case 3 to 5, 7
 3             8
i after case 3 to 5, 7
 3             9
i after case 3 to 5, 7
 4             0
i after case 3 to 5, 7
 4             1
i after case 3 to 5, 7
 4             2
i after case 3 to 5, 7
 4             3
i after case 3 to 5, 7
 4             4
i after case 3 to 5, 7
 4             5
i after case 3 to 5, 7
 4             6
i after case 3 to 5, 7
 4             7
i after case 3 to 5, 7
 4             8
i after case 3 to 5, 7
 4             9
i after case 3 to 5, 7
 5             0
i after case 3 to 5, 7
 5             1
i after case 3 to 5, 7
 5             2
i after case 3 to 5, 7
 5             3
i after case 3 to 5, 7
 5             4
i after case 3 to 5, 7
 5             5
i after case 3 to 5, 7
 5             6
i after case 3 to 5, 7
 5             7
i after case 3 to 5, 7
 5             8
i after case 3 to 5, 7
 5             9
i after case 3 to 5, 7
 6             0
is after case is <9
 6             1
is after case is <9
 6             2
is after case is <9
 6             3
is after case is <9
 6             4
is after case is <9
 6             5
is after case is <9
 6             6
is after case is <9
 6             7
is after case is <9
 6             8
is after case is <9
 6             9
is after case is <9
 7             0
i after case 3 to 5, 7
 7             1
i after case 3 to 5, 7
 7             2
i after case 3 to 5, 7
 7             3
i after case 3 to 5, 7
 7             4
i after case 3 to 5, 7
 7             5
i after case 3 to 5, 7
 7             6
i after case 3 to 5, 7
 7             7
i after case 3 to 5, 7
 7             8
i after case 3 to 5, 7
 7             9
i after case 3 to 5, 7
 8             0
is after case is <9
 8             1
is after case is <9
 8             2
is after case is <9
 8             3
is after case is <9
 8             4
is after case is <9
 8             5
is after case is <9
 8             6
is after case is <9
 8             7
is after case is <9
 8             8
is after case is <9
 8             9
is after case is <9
 9             0
i after case else
 9             1
i after case else
 9             2
i after case else
 9             3
i after case else
 9             4
i after case else
 9             5
i after case else
 9             6
i after case else
 9             7
i after case else
 9             8
i after case else
 9             9
i after case else
```

## `test15.bas`

`FIELD`, `PUT` and `GET`

### Test File

```basic
a$="a"
open "r",1,"test.dat",128
print "before field a$=";a$
field #1,10 as a$
field #1,5 as b$,5 as c$
lset b$="hi"
rset c$="ya"
print "a$=";a$
put #1
close #1
print "after close a$=";a$
open "r",2,"test.dat",128
field #2,10 as b$
get #2
print "after get b$=";b$
close #2
kill "test.dat"
```

### Expected Result

```
before field a$=a
a$=hi      ya
after close a$=
after get b$=hi      ya
```

## `test16.bas`

`SWAP`

### Test File

```basic
a=1 : b=2
print "a=";a;"b=";b
swap a,b
print "a=";a;"b=";b
dim a$(1,1),b$(1,1)
a$(1,0)="a" : b$(0,1)="b"
print "a$(1,0)=";a$(1,0);"b$(0,1)=";b$(0,1)
swap a$(1,0),b$(0,1)
print "a$(1,0)=";a$(1,0);"b$(0,1)=";b$(0,1)
```

### Expected Result

```
a= 1 b= 2
a= 2 b= 1
a$(1,0)=ab$(0,1)=b
a$(1,0)=bb$(0,1)=a
```

## `test17.bas`

`DO`, `EXIT DO`, `LOOP`

### Test File

```basic
print "loop started"
i=1
do
  print "i is";i
  i=i+1
  if i>10 then exit do
loop
print "loop ended"
```

### Expected Result

```
loop started
i is 1
i is 2
i is 3
i is 4
i is 5
i is 6
i is 7
i is 8
i is 9
i is 10
loop ended
```

## `test18.bas`

`DO WHILE`, `LOOP`

### Test File

```basic
print "loop started"
x$=""
do while len(x$)<3
  print "x$ is ";x$
  x$=x$+"a"
  y$=""
  do while len(y$)<2
    print "y$ is ";y$
    y$=y$+"b"
  loop
loop
print "loop ended"
```

### Expected Result

```
loop started
x$ is
y$ is
y$ is b
x$ is a
y$ is
y$ is b
x$ is aa
y$ is
y$ is b
loop ended
```

## `test19.bas`

`ELSEIF`

### Test File

```basic
for x=1 to 3
  if x=1 then
    print "1a"
  else
    if x=2 then
      print "2a"
    else
      print "3a"
    end if
  end if
next

for x=1 to 3
  if x=1 then
    print "1b"
  elseif x=2 then
    print "2b"
  elseif x=3 then print "3b"
next
```

### Expected Result

```
1a
2a
3a
1b
2b
3b
```

## `test20.bas`

Caller trace

### Test File

```basic
 10 gosub 20
 20 gosub 30
 30 procb
 40 def proca
 50   print "hi"
 60   stop
 70 end proc
 80 def procb
 90   proca
100 end proc
```

### Expected Result

```
hi
Break in line 60 at:
60 stop
   ^
Proc Called in line 90 at:
90 proca
        ^
Proc Called in line 30 at:
30 procb
        ^
Called in line 20 at:
20 gosub 30
           ^
Called in line 10 at:
10 gosub 20
           ^
```

## `test21.bas`

Matrix assignment

### Test File

```basic
dim a(3,4)
for i=0 to 3
  for j=0 to 4
    a(i,j)=i*10+j
    print a(i,j);
  next
  print
next
mat b=a
for i=0 to 3
  for j=0 to 4
    print b(i,j);
  next
  print
next
```

### Expected Result

```
 0  1  2  3  4
 10  11  12  13  14
 20  21  22  23  24
 30  31  32  33  34
 0  0  0  0  0
 0  11  12  13  14
 0  21  22  23  24
 0  31  32  33  34
```

## `test22.bas`

`MAT PRINT`

### Test File

```basic
dim a(2,2)
for i=0 to 2
  for j=0 to 2
    a(i,j)=i*10+j
  next
next
for j=1 to 2
  for i=1 to 2
    print using " ##.##";a(i,j),
  next
  print
next
mat print using " ##.##";a,a
```

### Expected Result

```
 11.00 21.00
 12.00 22.00
 11.00 12.00
 21.00 22.00

 11.00 12.00
 21.00 22.00
```

## `test23.bas`

Matrix addition and subtraction

### Test File

```basic
dim a(2,2)
a(2,2)=2.5
dim b%(2,2)
b%(2,2)=3
mat print a
mat a=a-b%
mat print a
dim c$(2,2)
c$(2,1)="hi"
mat print c$
mat c$=c$+c$
mat print c$
```

### Expected Result

```
 0             0
 0             2.5
 0             0
 0            -0.5

hi

hihi
```

## `test24.bas`

Matrix multiplication

### Test File

```basic
10 dim b(2,3),c(3,2)
20 for i=1 to 2 : for j=1 to 3 : read b(i,j) : next : next
30 for i=1 to 3 : for j=1 to 2 : read c(i,j) : next : next
40 mat a=b*c
50 mat print b,c,a
60 data 1,2,3,3,2,1
70 data 1,2,2,1,3,3
```

### Expected Result

```
 1             2             3
 3             2             1

 1             2
 2             1
 3             3

 14            13
 10            11
```

## `test25.bas`

Matrix scalar multiplication

### Test File

```basic
10 dim a(3,3)
20 for i=1 to 3 : for j=1 to 3 : read a(i,j) : next : next
30 mat print a
40 mat a=(3)*a
45 print
50 mat print a
60 data 1,2,3,4,5,6,7,8,9
80 dim inch_array(5,1),cm_array(5,1)
90 mat read inch_array
100 data 1,12,36,100,39.37
110 mat print inch_array
120 mat cm_array=(2.54)*inch_array
130 mat print cm_array
```

### Expected Result

```
 1             2             3
 4             5             6
 7             8             9

 3             6             9
 12            15            18
 21            24            27
 1
 12
 36
 100
 39.37
 2.54
 30.48
 91.44
 254
 99.9998
```

## `test26.bas`

MAT READ

### Test File

```basic
dim a(3,3)
data 5,5,5,8,8,8,3,3
mat read a(2,3)
mat print a
```

### Expected Result

```
 5             5             5
 8             8             8
```

## `test27.bas`

Matrix inversion

### Test File

```basic
data 1,2,3,4
mat read a(2,2)
mat print a
mat b=inv(a)
mat print b
mat c=a*b
mat print c
```

### Expected Result

```
 1             2
 3             4
-2             1
 1.5          -0.5
 1             0
 0             1
```

## `test28.bas`

TDL BASIC `FNRETURN`/`FNEND`

### Test File

```basic
def fnfac(n)
  if n=1 then fnreturn 1
fnend n*fnfac(n-1)

print fnfac(10)
```

### Expected Result

```
 3628800
```

## `test29.bas`

TDL INSTR

### Test File

```basic
print instr("123456789","456");" = 4?"
print INSTR("123456789","654");" = 0?"
print INSTR("1234512345","34");" = 3?"
print INSTR("1234512345","34",6);" = 8?"
print INSTR("1234512345","34",6,2);" = 0?"
print INSTR("1234512345","34",6,4);" = 8?"
```

### Expected Result

```
 4  = 4?
 0  = 0?
 3  = 3?
 8  = 8?
 0  = 0?
 8  = 8?
```

## `test30.bas`

Type mismatch check

### Test File

```basic
print 1+"a"
```

### Expected Result

```
Error: Invalid binary operand at: end of program
```

## `test31.bas`

PRINT default format

### Test File

```basic
10 for i=-8 to 8
20   x=1+1/3 : y=1 : j=i
30   for j=i to -1 : x=x/10 : y=y/10 : next
40   for j=i to 1 step -1 : x=x*10 : y=y*10 : next
50   print x,y
60 next
```

### Expected Result

```
 0.0000000     0.0000000
 0.0000001     0.0000001
 0.0000013     0.0000010
 0.0000133     0.0000100
 0.000133      0.0001
 0.001333      0.001
 0.013333      0.01
 0.133333      0.1
 1.333333      1
 13.33333      10
 133.3333      100
 1333.333      1000
 13333.33      10000
 133333.3      100000
 1333333       1000000
 13333333.3333333            10000000.0000000
 133333333.3333333           100000000.0000000
```

### Notes

Output would differ on other platforms NttX does not use scientific notation in
floating point output.

## `test32.bas`

`SUB` routines

### Test File

```basic
PUTS("abc")
END

SUB PUTS(s$)
  FOR i=1 to LEN(s$) : print mid$(s$,i,1); : NEXT
  PRINT
END SUB
```

### Expected Result

```
abc
```

## `test33.bas`

`OPEN FOR BINARY`

### Test File

```basic
open "/tmp/test.out" for binary as 1
put 1,1,"xy"
put 1,3,"z!"
put 1,10,1/3
put 1,20,9999
close 1
open "/tmp/test.out" for binary as 1
s$="    "
get 1,1,s$
get 1,10,x
get 1,20,n%
close
print s$
print x
print n%
kill "/tmp/test.out"
```

### Expected Result

```
xyz!
 0.333333
 9999
```

### Notes

The logic in this test will fail if there is no writable file system mount at
`/tmp`.

## `test34.bas`

`OPTION BASE`

### Test File

```basic
option base 3
dim a(3,5)
a(3,3)=1
a(3,5)=2

print a(3,3)
print a(3,5)

option base -2
dim b(-1,2)
b(-2,-2)=10
b(-1,2)=20

print a(3,3)
print a(3,5)
print b(-2,-2)
print b(-1,2)
```

### Expected Result

```
 1
 2
 1
 2
 10
 20
```

## `test35.bas`

Real to integer conversion

### Test File

```basic
a%=1.2
print a%
a%=1.7
print a%
a%=-0.2
print a%
a%=-0.7
print a%
```

### Expected Result

```
 1
 2
 0
-1
```

## `test36.bas`

`OPEN` file locking

### Test File

```basic
on error goto 10
print "opening file"
open "/tmp/test.out" for output lock write as #1
print "open succeeded"
if command$<>"enough" then shell "sh ./test/runbas test.bas enough"
end
10 print "open failed"
```

### Expected Result

```
opening file
open succeeded
opening file
open failed
```

### Notes

1. The logic in this test will fail opening the test.out file if there is no
   writable file system mount at `/tmp`.
2. This test will still currently fail when try to fork the shell because
   support for that feature is not implemented. The following error message
   should be received:

   ```
   Error: Forking child process failed (Unknown error) in line 5 at:
   if command$<>"enough" then shell "sh ./test/runbas test.bas enough"
                             ^
   ```

## `test37.bas`

`LINE INPUT` reaching `EOF`

### Test File

```basic
10 open "i",1,"/mnt/romfs/test37.dat"
20 while not eof(1)
30 line input #1,a$
40 if a$="abc" then print a$; else print "def"
50 wend
```

## Data file (`/mnt/romfs/test37.dat`)

```
abc
```

## Result

```
abc
```

## `test38.bas`

`MAT REDIM`

### Test File

```basic
dim x(10)
mat read x
mat print x
mat redim x(7)
mat print x
mat redim x(12)
mat print x
data 1,2,3,4,5,6,7,8,9,10
```

### Expected Result

```
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 1
 2
 3
 4
 5
 6
 7
 1
 2
 3
 4
 5
 6
 7
 0
 0
 0
 0
 0
```

## `test39.bas`

Nested function and procedure calls

### Test File

```basic
def proc_a(x)
print fn_b(1,x)
end proc

def fn_b(a,b)
= a+fn_c(b)

def fn_c(b)
= b+3

proc_a(2)
```

### Expected Result

```
 6
```

## `test40.bas`

`IMAGE`

### Test File

```basic
   d=3.1
   print using "#.#";d
   print using 10;d
10 image #.##
```

### Expected Result

```
3.1
3.10
```

## `test41.bas`

`EXIT FUNCTION`

### Test File

```basic
function f(c)
print "f running"
if (c) then f=42 : exit function
f=43
end function

print f(0)
print f(1)
```

### Expected Result

```
f running
 43
f running
 42
```

## `test42.bas`

Arithmetic

### Test File

```basic
10 print 4.7\3
20 print -2.3\1
30 print int(-2.3)
40 print int(2.3)
50 print fix(-2.3)
60 print fix(2.3)
70 print fp(-2.3)
80 print fp(2.3)
```

### Expected Result

```
 1
-2
-3
 2
-2
 2
-0.3
 0.3
```

## `test43.bas`

Matrix multiplication size checks

### Test File

```basic
DIM a(3,3),b(3,1),c(3,3)
MAT READ a
MAT READ b
MAT c=a*b
MAT PRINT c
DATA 1,2,3,4,5,6,7,8,9
DATA 5,3,2

erase b
DIM b(3)
RESTORE
MAT READ a
MAT READ b
MAT c=a*b
MAT PRINT c
```

### Expected Result

```
 17
 47
 77
Error: Dimension mismatch in line 14 at:
mat c=a*b
       ^
```

## `test44.bas`

`DELETE`

### Test File

```basic
10 print 10
20 print 20
30 print 30
40 print 40
50 print 50
60 print 60
70 print 70
```

## Usage

```basic
load "test.bas"
delete -20
delete 60-
delete 30-40
delete 15
list
```

### Expected Result

```
Error: No such line at: 15
50 print 50
```

## `test45.bas`

`MID$` on left side

### Test File

```basic
10 mid$(a$,6,4) = "ABCD"
20 print a$
30 a$="0123456789"
40 mid$(a$,6,4) = "ABCD"
50 print a$
60 a$="0123456789"
70 let mid$(a$,6,4) = "ABCD"
80 print a$
```

### Expected Result

```

01234ABCD9
01234ABCD9
```

## `test46.bas`

`END` used without program

### Test File

```basic
for i=1 to 10:print i;:next i:end
```

### Expected Result

```
 1  2  3  4  5  6  7  8  9  10
```

## `test47.bas`

`MAT WRITE`

### Test File

```basic
dim a(3,4)
for i=0 to 3
  for j=0 to 4
    a(i,j)=i*10+j
    print a(i,j);
  next
  print
next
mat write a
```

### Expected Result

```
 0  1  2  3  4
 10  11  12  13  14
 20  21  22  23  24
 30  31  32  33  34
11,12,13,14
21,22,23,24
31,32,33,34
```

## `test48.bas`

Multi assignment

### Test File

```basic
a,b = 10
print a,b
dim c(10)
a,c(a) = 2
print a,c(2),c(10)
a$,b$="test"
print a$,b$
```

### Expected Result

```
 10            10
 2             0             2
test          test
```

## `test49.bas`

Matrix determinant

### Test File

```basic
width 120
dim a(7,7),b(7,7)
mat read a
mat print a;
print
data 58,71,67,36,35,19,60
data 50,71,71,56,45,20,52
data 64,40,84,50,51,43,69
data 31,28,41,54,31,18,33
data 45,23,46,38,50,43,50
data 41,10,28,17,33,41,46
data 66,72,71,38,40,27,69
mat b=inv(a)
mat print b
print det
```

### Expected Result

```
 58  71  67  36  35  19  60
 50  71  71  56  45  20  52
 64  40  84  50  51  43  69
 31  28  41  54  31  18  33
 45  23  46  38  50  43  50
 41  10  28  17  33  41  46
 66  72  71  38  40  27  69

 9.636025e+07                320206       -537449        2323650      -1.135486e+07                3.019632e+07
              -9.650941e+07
 4480          15           -25            108          -528           1404         -4487
-39436        -131           220          -951           4647         -12358         39497
 273240        908          -1524          6589         -32198         85625        -273663
-1846174      -6135          10297        -44519         217549       -578534        1849032
 1.315035e+07                43699        -73346         317110       -1549606       4120912      -1.31707e+07

-9.636079e+07               -320208        537452       -2323663       1.135493e+07               -3.019649e+07
               9.650995e+07
 1
```

### Notes

Output will differ because NuttX does not use scientific notation in output.
Some minor rounding differences may also be expected.

## `test50.bas`

`min` and `max` function

### Test File

```basic
print min(1,2)
print min(2,1)
print min(-0.3,0.3)
print min(-0.3,4)
print max(1,2)
print max(2,1)
print max(-0.3,0.3)
print max(-0.3,4)
```

### Expected Result

```
 1
 1
-0.3
-0.3
 2
 2
 0.3
 4
```

## `test51.bas`

Print items

### Test File

```basic
PRINT "Line 1";TAB(78);1.23456789
```

### Expected Result

```
Line 1                                                                        1.234568
```

## `test52.bas`

`MAT INPUT`

### Test File

```basic
dim a(2,2)
mat input a
mat print a
mat input a
mat print a
```

### Test File

```basic
1,2,3,4,5
1
3,4
```

### Expected Result

```
?
 1             2
 3             4
? ?
 1             0
 3             4
```
