Coverage for tests/codegen/test_keywords.py: 96%

1from . import bindgen 

2from wasmtime import Store 

3 

4module = """ 

5 (component 

6 (import "false" (instance $i 

7 (type $c1 (variant (case "break" s32) (case "class" s64) (case "true" s64))) 

8 (export $c1' "none" (type (eq $c1))) 

9 (export "as" (func (param "import" $c1') (result s64))) 

10 

11 (type $r1 (record (field "else" u8) (field "not" u8) (field "except" u8))) 

12 (export $r1' "true" (type (eq $r1))) 

13 (export "lambda" (func (param "def" $r1') (result u32))) 

14 )) 

15 

16 (core func $as (canon lower (func $i "as"))) 

17 (core func $lambda (canon lower (func $i "lambda"))) 

18 

19 (core module $m 

20 (import "" "as" (func $as (param i32 i64) (result i64))) 

21 (import "" "lambda" (func $lambda (param i32 i32 i32) (result i32))) 

22 

23 (func (export "await") (result i32) 

24 i32.const 100) 

25 

26 (func (export "as") (param i32 i64) (result i64) 

27 (call $as (local.get 0) (local.get 1))) 

28 

29 (func (export "lambda") (param i32 i32 i32) (result i32) 

30 (call $lambda (local.get 0) (local.get 1) (local.get 2))) 

31 ) 

32 

33 (core instance $i (instantiate $m 

34 (with "" (instance 

35 (export "as" (func $as)) 

36 (export "lambda" (func $lambda)) 

37 )) 

38 )) 

39 

40 (type $c1 (variant (case "break" s32) (case "class" s64) (case "true" s64))) 

41 (type $r1 (record (field "else" u8) (field "not" u8) (field "except" u8))) 

42 

43 (func $await-export (result u8) (canon lift (core func $i "await"))) 

44 (func $as-export (param "import" $c1) (result s64) 

45 (canon lift (core func $i "as"))) 

46 (func $lambda-export (param "def" $r1) (result u32) 

47 (canon lift (core func $i "lambda"))) 

48 

49 (instance (export "for") 

50 (export "none" (type $c1)) 

51 (export "true" (type $r1)) 

52 (export "await" (func $await-export)) 

53 (export "as" (func $as-export)) 

54 (export "lambda" (func $lambda-export)) 

55 ) 

56 ) 

57""" 

58bindgen('keywords', module) 

59 

60from .generated.keywords import Root, RootImports, imports 

61from .generated.keywords import for_ 

62from .generated.keywords.imports import false 

63 

64 

65class Host(imports.HostFalse): 

66 def as_(self, import_): 

67 if isinstance(import_, false.None_Break): 

68 return import_.value + 1 

69 if isinstance(import_, false.None_Class): 

70 return import_.value + 2 

71 if isinstance(import_, false.None_True_): 

72 return import_.value + 3 

73 else: 

74 raise ValueError("Invalid input value!") 

75 

76 def lambda_(self, def_): 

77 return def_.else_ + def_.not_ + def_.except_ 

78 

79 

80def test_bindings(): 

81 store = Store() 

82 bindings = Root(store, RootImports(false=Host())) 

83 assert 100 == bindings.for_().await_(store) 

84 assert 101 == bindings.for_().as_(store, for_.None_Break(100)) 

85 assert 102 == bindings.for_().as_(store, for_.None_Class(100)) 

86 assert 103 == bindings.for_().as_(store, for_.None_True_(100)) 

87 assert 24 == bindings.for_().lambda_(store, for_.True_(7, 8, 9))