1831 lines
22 KiB
Markdown
1831 lines
22 KiB
Markdown
# 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
|
|
```
|