Skip to content

Commit eee19ce

Browse files
sinclairzx81sinclairzx81
committed
Tests
1 parent 66c7ee3 commit eee19ce

2 files changed

Lines changed: 131 additions & 0 deletions

File tree

‎test/parsebox/token/unsigned_integer.ts‎

Lines changed: 69 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
import { Token } from '@sinclair/parsebox'
2+
import { Assert } from 'test'
3+
4+
const Test = Assert.Context('Token.UnsignedInteger')
5+
6+
// ------------------------------------------------------------------
7+
// Unsigned
8+
// ------------------------------------------------------------------
9+
Test('Should Integer 1', () => Assert.IsExact(Token.UnsignedInteger('0'), ['0', '']))
10+
Test('Should Integer 2', () => Assert.IsExact(Token.UnsignedInteger('00'), ['0', '0']))
11+
Test('Should Integer 3', () => Assert.IsExact(Token.UnsignedInteger('10'), ['10', '']))
12+
Test('Should Integer 4', () => Assert.IsExact(Token.UnsignedInteger(' 0'), ['0', '']))
13+
Test('Should Integer 5', () => Assert.IsExact(Token.UnsignedInteger('0 '), ['0', ' ']))
14+
Test('Should Integer 6', () => Assert.IsExact(Token.UnsignedInteger(' 0 '), ['0', ' ']))
15+
Test('Should Integer 7', () => Assert.IsExact(Token.UnsignedInteger(' 00'), ['0', '0']))
16+
Test('Should Integer 8', () => Assert.IsExact(Token.UnsignedInteger('00 '), ['0', '0 ']))
17+
Test('Should Integer 9', () => Assert.IsExact(Token.UnsignedInteger(' 00 '), ['0', '0 ']))
18+
Test('Should Integer 10', () => Assert.IsExact(Token.UnsignedInteger(' 10'), ['10', '']))
19+
Test('Should Integer 11', () => Assert.IsExact(Token.UnsignedInteger('10 '), ['10', ' ']))
20+
Test('Should Integer 12', () => Assert.IsExact(Token.UnsignedInteger(' 10 '), ['10', ' ']))
21+
22+
// ------------------------------------------------------------------
23+
// Digits
24+
// ------------------------------------------------------------------
25+
Test('Should Integer 13', () => Assert.IsExact(Token.UnsignedInteger('0'), ['0', '']))
26+
Test('Should Integer 14', () => Assert.IsExact(Token.UnsignedInteger('1'), ['1', '']))
27+
Test('Should Integer 15', () => Assert.IsExact(Token.UnsignedInteger('2'), ['2', '']))
28+
Test('Should Integer 16', () => Assert.IsExact(Token.UnsignedInteger('3'), ['3', '']))
29+
Test('Should Integer 17', () => Assert.IsExact(Token.UnsignedInteger('4'), ['4', '']))
30+
Test('Should Integer 18', () => Assert.IsExact(Token.UnsignedInteger('5'), ['5', '']))
31+
Test('Should Integer 19', () => Assert.IsExact(Token.UnsignedInteger('6'), ['6', '']))
32+
Test('Should Integer 20', () => Assert.IsExact(Token.UnsignedInteger('7'), ['7', '']))
33+
Test('Should Integer 21', () => Assert.IsExact(Token.UnsignedInteger('8'), ['8', '']))
34+
Test('Should Integer 22', () => Assert.IsExact(Token.UnsignedInteger('9'), ['9', '']))
35+
36+
Test('Should Integer 23', () => Assert.IsExact(Token.UnsignedInteger('10'), ['10', '']))
37+
Test('Should Integer 24', () => Assert.IsExact(Token.UnsignedInteger('11'), ['11', '']))
38+
Test('Should Integer 25', () => Assert.IsExact(Token.UnsignedInteger('12'), ['12', '']))
39+
Test('Should Integer 26', () => Assert.IsExact(Token.UnsignedInteger('13'), ['13', '']))
40+
Test('Should Integer 27', () => Assert.IsExact(Token.UnsignedInteger('14'), ['14', '']))
41+
Test('Should Integer 28', () => Assert.IsExact(Token.UnsignedInteger('15'), ['15', '']))
42+
Test('Should Integer 29', () => Assert.IsExact(Token.UnsignedInteger('16'), ['16', '']))
43+
Test('Should Integer 30', () => Assert.IsExact(Token.UnsignedInteger('17'), ['17', '']))
44+
Test('Should Integer 31', () => Assert.IsExact(Token.UnsignedInteger('18'), ['18', '']))
45+
Test('Should Integer 32', () => Assert.IsExact(Token.UnsignedInteger('19'), ['19', '']))
46+
47+
// ------------------------------------------------------------------
48+
// Invariant
49+
// ------------------------------------------------------------------
50+
Test('Should Integer 33', () => Assert.IsExact(Token.UnsignedInteger('x'), []))
51+
Test('Should Integer 34', () => Assert.IsExact(Token.UnsignedInteger(''), []))
52+
53+
// ------------------------------------------------------------------
54+
// Additional
55+
// ------------------------------------------------------------------
56+
Test('Should Integer 35', () => Assert.IsExact(Token.UnsignedInteger('000'), ['0', '00']))
57+
Test('Should Integer 36', () => Assert.IsExact(Token.UnsignedInteger('0000'), ['0', '000']))
58+
Test('Should Integer 37', () => Assert.IsExact(Token.UnsignedInteger('1000'), ['1000', '']))
59+
Test('Should Integer 38', () => Assert.IsExact(Token.UnsignedInteger('1000x'), ['1000', 'x']))
60+
61+
// ------------------------------------------------------------------
62+
// Underscore: We support multiple underscore (should we?)
63+
// ------------------------------------------------------------------
64+
Test('Should Integer 39', () => Assert.IsExact(Token.UnsignedInteger('10_000_000'), ['10000000', '']))
65+
Test('Should Integer 40', () => Assert.IsExact(Token.UnsignedInteger('10_000 _000'), ['10000', ' _000']))
66+
Test('Should Integer 41', () => Assert.IsExact(Token.UnsignedInteger('10_000_ 000'), ['10000', ' 000']))
67+
Test('Should Integer 42', () => Assert.IsExact(Token.UnsignedInteger('10__000 000'), ['10000', ' 000']))
68+
Test('Should Integer 43', () => Assert.IsExact(Token.UnsignedInteger('10__000__ 000'), ['10000', ' 000']))
69+
Test('Should Integer 44', () => Assert.IsExact(Token.UnsignedInteger('10__000 __000'), ['10000', ' __000']))

‎test/parsebox/token/unsigned_number.ts‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
import { Token } from '@sinclair/parsebox'
2+
import { Assert } from 'test'
3+
4+
const Test = Assert.Context('Token.UnsignedNumber')
5+
6+
Test('Should Number 1', () => Assert.IsExact(Token.UnsignedNumber(''), []))
7+
Test('Should Number 2', () => Assert.IsExact(Token.UnsignedNumber('01'), ['0', '1']))
8+
Test('Should Number 3', () => Assert.IsExact(Token.UnsignedNumber(' 01'), ['0', '1']))
9+
Test('Should Number 4', () => Assert.IsExact(Token.UnsignedNumber('01 '), ['0', '1 ']))
10+
Test('Should Number 5', () => Assert.IsExact(Token.UnsignedNumber(' 01 '), ['0', '1 ']))
11+
Test('Should Number 6', () => Assert.IsExact(Token.UnsignedNumber('0'), ['0', '']))
12+
Test('Should Number 7', () => Assert.IsExact(Token.UnsignedNumber('0 '), ['0', ' ']))
13+
Test('Should Number 8', () => Assert.IsExact(Token.UnsignedNumber(' 0'), ['0', '']))
14+
Test('Should Number 9', () => Assert.IsExact(Token.UnsignedNumber(' 0 '), ['0', ' ']))
15+
Test('Should Number 10', () => Assert.IsExact(Token.UnsignedNumber('100'), ['100', '']))
16+
Test('Should Number 11', () => Assert.IsExact(Token.UnsignedNumber('100 '), ['100', ' ']))
17+
Test('Should Number 12', () => Assert.IsExact(Token.UnsignedNumber(' 100'), ['100', '']))
18+
Test('Should Number 13', () => Assert.IsExact(Token.UnsignedNumber(' 100 '), ['100', ' ']))
19+
Test('Should Number 14', () => Assert.IsExact(Token.UnsignedNumber('0.1'), ['0.1', '']))
20+
Test('Should Number 15', () => Assert.IsExact(Token.UnsignedNumber('0.1 '), ['0.1', ' ']))
21+
Test('Should Number 16', () => Assert.IsExact(Token.UnsignedNumber(' 0.1'), ['0.1', '']))
22+
Test('Should Number 17', () => Assert.IsExact(Token.UnsignedNumber(' 0.1 '), ['0.1', ' ']))
23+
Test('Should Number 18', () => Assert.IsExact(Token.UnsignedNumber('100.1'), ['100.1', '']))
24+
Test('Should Number 19', () => Assert.IsExact(Token.UnsignedNumber('100.1 '), ['100.1', ' ']))
25+
Test('Should Number 20', () => Assert.IsExact(Token.UnsignedNumber(' 100.1'), ['100.1', '']))
26+
Test('Should Number 21', () => Assert.IsExact(Token.UnsignedNumber(' 100.1 '), ['100.1', ' ']))
27+
Test('Should Number 22', () => Assert.IsExact(Token.UnsignedNumber('100.1.1'), ['100.1', '.1']))
28+
Test('Should Number 23', () => Assert.IsExact(Token.UnsignedNumber('100.1.1 '), ['100.1', '.1 ']))
29+
Test('Should Number 24', () => Assert.IsExact(Token.UnsignedNumber(' 100.1.1'), ['100.1', '.1']))
30+
Test('Should Number 25', () => Assert.IsExact(Token.UnsignedNumber(' 100.1.1 '), ['100.1', '.1 ']))
31+
32+
// ------------------------------------------------------------------
33+
// Large numbers
34+
// ------------------------------------------------------------------
35+
Test('Should Number 26', () => Assert.IsExact(Token.UnsignedNumber('1234567890'), ['1234567890', '']))
36+
37+
// ------------------------------------------------------------------
38+
// Decimal without leading zero
39+
// ------------------------------------------------------------------
40+
Test('Should Number 27', () => Assert.IsExact(Token.UnsignedNumber('.5'), ['0.5', '']))
41+
Test('Should Number 28', () => Assert.IsExact(Token.UnsignedNumber('+.5'), []))
42+
43+
// ------------------------------------------------------------------
44+
// Multiple leading zeros
45+
// ------------------------------------------------------------------
46+
Test('Should Number 29', () => Assert.IsExact(Token.UnsignedNumber('000123'), ['0', '00123']))
47+
48+
// ------------------------------------------------------------------
49+
// Numbers next to text
50+
// ------------------------------------------------------------------
51+
Test('Should Number 30', () => Assert.IsExact(Token.UnsignedNumber('100abc'), ['100', 'abc']))
52+
53+
// ------------------------------------------------------------------
54+
// Numbers with spaces inside (should stop at first space)
55+
// ------------------------------------------------------------------
56+
Test('Should Number 31', () => Assert.IsExact(Token.UnsignedNumber('123 456'), ['123', ' 456']))
57+
58+
// ------------------------------------------------------------------
59+
// Just a dot (invalid number)
60+
// ------------------------------------------------------------------
61+
Test('Should Number 32', () => Assert.IsExact(Token.UnsignedNumber('.'), []))
62+
Test('Should Number 33', () => Assert.IsExact(Token.UnsignedNumber(' . '), []))

0 commit comments

Comments
 (0)