forked from GitHub/gf-core
475 lines
12 KiB
TypeScript
475 lines
12 KiB
TypeScript
import PGF, {
|
|
PGFError,
|
|
PGFGrammar,
|
|
// Type,
|
|
mkType,
|
|
// Hypo,
|
|
mkHypo,
|
|
mkDepHypo,
|
|
mkImplHypo,
|
|
// Expr,
|
|
// ExprAbs,
|
|
ExprApp,
|
|
ExprLit,
|
|
ExprMeta,
|
|
ExprFun,
|
|
ExprVar,
|
|
// ExprTyped,
|
|
ExprImplArg
|
|
// Literal
|
|
} from '../index'
|
|
import fs from 'fs'
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
describe('readPGF', () => {
|
|
test('valid', () => {
|
|
PGF.readPGF('../haskell/tests/basic.pgf')
|
|
})
|
|
|
|
test('non-existent', () => {
|
|
expect(() => {
|
|
PGF.readPGF('../haskell/tests/abc.pgf')
|
|
}).toThrow(Error)
|
|
})
|
|
|
|
test('GF', () => {
|
|
expect(() => {
|
|
PGF.readPGF('../haskell/tests/basic.gf')
|
|
}).toThrow(PGFError)
|
|
})
|
|
|
|
test('NGF', () => {
|
|
try {
|
|
fs.unlinkSync('./basic.ngf')
|
|
} catch {
|
|
// empty
|
|
}
|
|
PGF.bootNGF('../haskell/tests/basic.pgf', './basic.ngf')
|
|
expect(() => {
|
|
PGF.readPGF('./basic.ngf')
|
|
}).toThrow(PGFError)
|
|
})
|
|
})
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
describe('bootNGF', () => {
|
|
beforeAll(() => {
|
|
try {
|
|
fs.unlinkSync('./basic.ngf')
|
|
} catch {
|
|
// empty
|
|
}
|
|
})
|
|
|
|
test('valid', () => {
|
|
PGF.bootNGF('../haskell/tests/basic.pgf', './basic.ngf')
|
|
})
|
|
|
|
test('non-existent', () => {
|
|
expect(() => {
|
|
PGF.bootNGF('../haskell/tests/abc.pgf', './abc.ngf')
|
|
}).toThrow(Error)
|
|
})
|
|
|
|
test('GF', () => {
|
|
expect(() => {
|
|
PGF.bootNGF('../haskell/tests/basic.gf', './abc.ngf')
|
|
}).toThrow(PGFError)
|
|
})
|
|
|
|
test('NGF', () => {
|
|
expect(() => {
|
|
PGF.bootNGF('./basic.ngf', './abc.ngf')
|
|
}).toThrow(PGFError)
|
|
})
|
|
|
|
test('existing', () => {
|
|
expect(() => {
|
|
PGF.bootNGF('../haskell/tests/basic.pgf', './basic.ngf')
|
|
}).toThrow(Error)
|
|
})
|
|
})
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
describe('readNGF', () => {
|
|
// beforeAll(() => {
|
|
// try {
|
|
// fs.unlinkSync('./basic.ngf')
|
|
// } catch {
|
|
// // empty
|
|
// }
|
|
// })
|
|
|
|
test('valid', () => {
|
|
const gr = PGF.readNGF('./basic.ngf')
|
|
expect(gr.getCategories().length).toBeGreaterThan(0)
|
|
})
|
|
|
|
test('non-existent', () => {
|
|
expect(() => {
|
|
PGF.readNGF('./abc.ngf')
|
|
}).toThrow(Error)
|
|
})
|
|
|
|
test('GF', () => {
|
|
expect(() => {
|
|
PGF.readNGF('../haskell/tests/basic.gf')
|
|
}).toThrow(PGFError)
|
|
})
|
|
|
|
test('PGF', () => {
|
|
expect(() => {
|
|
PGF.readNGF('../haskell/tests/basic.pgf')
|
|
}).toThrow(PGFError)
|
|
})
|
|
})
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
describe('newNGF', () => {
|
|
beforeAll(() => {
|
|
try {
|
|
fs.unlinkSync('./empty.ngf')
|
|
} catch {
|
|
// empty
|
|
}
|
|
})
|
|
|
|
test('file', () => {
|
|
const gr = PGF.newNGF('empty', './empty.ngf')
|
|
expect(gr.getCategories().length).toBe(0)
|
|
})
|
|
|
|
test('memory', () => {
|
|
const gr = PGF.newNGF('empty')
|
|
expect(gr.getCategories().length).toBe(0)
|
|
})
|
|
|
|
test('existing', () => {
|
|
expect(() => {
|
|
PGF.newNGF('empty', './basic.ngf')
|
|
}).toThrow(Error)
|
|
})
|
|
})
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
describe('abstract syntax', () => {
|
|
let gr: PGFGrammar
|
|
|
|
beforeAll(() => {
|
|
gr = PGF.readPGF('../haskell/tests/basic.pgf')
|
|
})
|
|
|
|
afterAll(() => {
|
|
gr.release()
|
|
})
|
|
|
|
test('abstract name', () => {
|
|
expect(gr.getAbstractName()).toBe('basic')
|
|
})
|
|
|
|
test('categories', () => {
|
|
expect(gr.getCategories()).toEqual(['Float', 'Int', 'N', 'P', 'S', 'String'])
|
|
})
|
|
|
|
test('functions', () => {
|
|
expect(gr.getFunctions()).toEqual(['c', 'ind', 's', 'z'])
|
|
})
|
|
|
|
describe('function is constructor', () => {
|
|
test('s', () => {
|
|
expect(gr.functionIsConstructor('s')).toBe(true)
|
|
})
|
|
test('z', () => {
|
|
expect(gr.functionIsConstructor('z')).toBe(true)
|
|
})
|
|
test('c', () => {
|
|
expect(gr.functionIsConstructor('c')).toBe(true)
|
|
})
|
|
test('ind', () => {
|
|
expect(gr.functionIsConstructor('ind')).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('functions by category', () => {
|
|
test('N', () => {
|
|
expect(gr.functionsByCategory('N')).toEqual(['s', 'z'])
|
|
})
|
|
test('S', () => {
|
|
expect(gr.functionsByCategory('S')).toEqual(['c'])
|
|
})
|
|
test('X', () => {
|
|
expect(gr.functionsByCategory('X')).toEqual([])
|
|
})
|
|
})
|
|
|
|
describe('probabilities', () => {
|
|
test.skip('category existing', () => {
|
|
expect(gr.categoryProbability('S')).toBeDefined()
|
|
})
|
|
|
|
test('category non-existent', () => {
|
|
expect(gr.categoryProbability('NP')).toBeUndefined()
|
|
})
|
|
|
|
test('function existing', () => {
|
|
expect(gr.functionProbability('c')).toBeDefined() // returns -0 (!)
|
|
})
|
|
|
|
test('function non-existent', () => {
|
|
expect(gr.functionProbability('mkC')).toBeUndefined()
|
|
})
|
|
})
|
|
})
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
describe('types', () => {
|
|
describe('read', () => {
|
|
test('invalid', () => {
|
|
expect(() => {
|
|
PGF.readType('->')
|
|
}).toThrow(PGFError)
|
|
})
|
|
|
|
test('1', () => {
|
|
const t1 = PGF.readType('A')
|
|
const t2 = PGF.readType('A')
|
|
const t3 = PGF.readType('B')
|
|
expect(t1).toEqual(t2)
|
|
expect(t1).not.toEqual(t3)
|
|
})
|
|
|
|
test('2', () => {
|
|
const t1 = PGF.readType('A -> B')
|
|
const t2 = PGF.readType('A->B')
|
|
const t3 = PGF.readType('B->B')
|
|
expect(t1).toEqual(t2)
|
|
expect(t1).not.toEqual(t3)
|
|
})
|
|
|
|
test('3', () => {
|
|
const t1 = PGF.readType('A -> B -> C')
|
|
const t2 = PGF.readType('A->B -> C')
|
|
expect(t1).toEqual(t2)
|
|
})
|
|
|
|
test('4', () => {
|
|
const t1 = PGF.readType('(x : N) -> P x')
|
|
const t2 = mkType([mkDepHypo('x', mkType([], 'N', []))], 'P', [new ExprFun('x')])
|
|
expect(t1).toEqual(t2)
|
|
})
|
|
})
|
|
|
|
describe.skip('show', () => {
|
|
test('1', () => {
|
|
const type = mkType([], 'N', [])
|
|
expect(PGF.showType([], type)).toEqual('N')
|
|
})
|
|
|
|
test('2', () => {
|
|
const type = mkType([mkHypo(mkType([], 'N', []))], 'N', [])
|
|
expect(PGF.showType([], type)).toEqual('N -> N')
|
|
})
|
|
|
|
test('3', () => {
|
|
const type = mkType([mkHypo(mkType([mkHypo(mkType([], 'N', []))], 'N', []))], 'N', [])
|
|
expect(PGF.showType([], type)).toEqual('(N -> N) -> N')
|
|
})
|
|
|
|
test('4', () => {
|
|
const type = mkType([mkDepHypo('x', mkType([], 'N', []))], 'P', [new ExprVar(0)])
|
|
expect(PGF.showType([], type)).toEqual('(x : N) -> P x')
|
|
})
|
|
|
|
test('5', () => {
|
|
const type = mkType([mkDepHypo('f', mkType([mkHypo(mkType([], 'N', []))], 'N', []))], 'P', [new ExprApp(new ExprVar(0), new ExprFun('z'))])
|
|
expect(PGF.showType([], type)).toEqual('(f : N -> N) -> P (f z)')
|
|
})
|
|
|
|
test('6', () => {
|
|
const type = mkType([mkDepHypo('f', mkType([mkHypo(mkType([], 'N', []))], 'N', []))], 'P', [new ExprApp(new ExprVar(0), new ExprVar(1))])
|
|
expect(PGF.showType(['n'], type)).toEqual('(f : N -> N) -> P (f n)')
|
|
})
|
|
|
|
test('7', () => {
|
|
const type = mkType([mkImplHypo('f', mkType([mkHypo(mkType([], 'N', []))], 'N', []))], 'P', [new ExprApp(new ExprVar(0), new ExprVar(1))])
|
|
expect(PGF.showType(['n'], type)).toEqual('({f} : N -> N) -> P (f n)')
|
|
})
|
|
|
|
test('8', () => {
|
|
const type = mkType([mkDepHypo('x', mkType([], 'N', [])), mkHypo(mkType([], 'P', [new ExprVar(0)]))], 'S', [])
|
|
expect(PGF.showType(['n'], type)).toEqual('(x : N) -> P x -> S')
|
|
})
|
|
|
|
test('9', () => {
|
|
const type = mkType([mkDepHypo('x', mkType([], 'N', [])), mkDepHypo('y', mkType([], 'P', [new ExprVar(0)]))], 'S', [])
|
|
expect(PGF.showType(['n'], type)).toEqual('(x : N) -> (y : P x) -> S')
|
|
})
|
|
})
|
|
})
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
describe('expressions', () => {
|
|
test('invalid', () => {
|
|
expect(() => {
|
|
PGF.readExpr('->')
|
|
}).toThrow(PGFError)
|
|
})
|
|
|
|
describe('literals', () => {
|
|
test('small integer', () => {
|
|
const e1 = PGF.readExpr('123')
|
|
const e2 = new ExprLit(123)
|
|
const e3 = new ExprLit(456)
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).not.toEqual(e3)
|
|
})
|
|
|
|
test('negative integer', () => {
|
|
const e1 = PGF.readExpr('-123')
|
|
const e2 = new ExprLit(-123)
|
|
const e3 = new ExprLit(-456)
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).not.toEqual(e3)
|
|
})
|
|
|
|
test('big integer', () => {
|
|
const e1 = PGF.readExpr('774763251095801167872')
|
|
const e2 = new ExprLit(BigInt('774763251095801167872'))
|
|
expect(e1).toEqual(e2)
|
|
})
|
|
|
|
test('negative big integer', () => {
|
|
const e1 = PGF.readExpr('-774763251095801167872')
|
|
const e2 = new ExprLit(BigInt('-774763251095801167872'))
|
|
expect(e1).toEqual(e2)
|
|
})
|
|
|
|
test('really big integer', () => {
|
|
const e1 = PGF.readExpr('7747632510958011678729003251095801167999')
|
|
const e2 = new ExprLit(BigInt('7747632510958011678729003251095801167999'))
|
|
const e3 = new ExprLit(BigInt('7747632510958011678729003251095801167990'))
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).not.toEqual(e3)
|
|
})
|
|
|
|
test('negative really big integer', () => {
|
|
const e1 = PGF.readExpr('-7747632510958011678729003251095801167999')
|
|
const e2 = new ExprLit(BigInt('-7747632510958011678729003251095801167999'))
|
|
const e3 = new ExprLit(BigInt('-7747632510958011678729003251095801167990'))
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).not.toEqual(e3)
|
|
})
|
|
|
|
test('float', () => {
|
|
const e1 = PGF.readExpr('3.142')
|
|
const e2 = new ExprLit(3.142)
|
|
const e3 = new ExprLit(2.014)
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).not.toEqual(e3)
|
|
})
|
|
|
|
test('negative float', () => {
|
|
const e1 = PGF.readExpr('-3.142')
|
|
const e2 = new ExprLit(-3.142)
|
|
const e3 = new ExprLit(-2.014)
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).not.toEqual(e3)
|
|
})
|
|
|
|
test('string', () => {
|
|
const e1 = PGF.readExpr('"abc"')
|
|
const e2 = new ExprLit('abc')
|
|
const e3 = new ExprLit('def')
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).not.toEqual(e3)
|
|
})
|
|
|
|
test('string unicode', () => {
|
|
const e1 = PGF.readExpr('"açġħ"')
|
|
const e2 = new ExprLit('açġħ')
|
|
const e3 = new ExprLit('acgh')
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).not.toEqual(e3)
|
|
})
|
|
})
|
|
|
|
describe('functions', () => {
|
|
test('simple', () => {
|
|
const e1 = PGF.readExpr('f')
|
|
expect(e1).toBeInstanceOf(ExprFun)
|
|
expect((e1 as ExprFun).name).toEqual('f')
|
|
|
|
const e2 = new ExprFun('f')
|
|
const e3 = new ExprFun('g')
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).not.toEqual(e3)
|
|
})
|
|
|
|
test('application 1', () => {
|
|
const e1 = PGF.readExpr('f x y')
|
|
expect(e1).toBeInstanceOf(ExprApp)
|
|
expect((e1 as ExprApp).arg).toEqual(new ExprFun('y'))
|
|
|
|
const e2 = new ExprApp(
|
|
new ExprApp(
|
|
new ExprFun('f'),
|
|
new ExprFun('x')
|
|
), new ExprFun('y')
|
|
)
|
|
expect(e1).toEqual(e2)
|
|
})
|
|
|
|
test('application 2', () => {
|
|
const e1 = PGF.readExpr('f (g x)')
|
|
const e2 = new ExprApp(
|
|
new ExprFun('f'),
|
|
new ExprApp(
|
|
new ExprFun('g'),
|
|
new ExprFun('x')
|
|
)
|
|
)
|
|
expect(e1).toEqual(e2)
|
|
})
|
|
|
|
test('application 3', () => {
|
|
const e1 = PGF.readExpr('f {g x}')
|
|
const e2 = new ExprApp(
|
|
new ExprFun('f'),
|
|
new ExprImplArg(
|
|
new ExprApp(
|
|
new ExprFun('g'),
|
|
new ExprFun('x')
|
|
)
|
|
)
|
|
)
|
|
expect(e1).toEqual(e2)
|
|
})
|
|
})
|
|
|
|
describe('variables', () => {
|
|
test('meta 1', () => {
|
|
const e1 = PGF.readExpr('?')
|
|
expect(e1).toBeInstanceOf(ExprMeta)
|
|
const e2 = new ExprMeta()
|
|
const e3 = new ExprMeta(0)
|
|
const e4 = new ExprMeta(1)
|
|
expect(e1).toEqual(e2)
|
|
expect(e1).toEqual(e3)
|
|
expect(e1).not.toEqual(e4)
|
|
})
|
|
|
|
test('meta 2', () => {
|
|
const e1 = PGF.readExpr('?42')
|
|
const e2 = new ExprMeta(42)
|
|
expect(e1).toEqual(e2)
|
|
})
|
|
})
|
|
})
|