web-prover-circuits/circuits/test/json/values.test.ts at main · pluto/web-prover-circuits · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import { circomkit, WitnessTester, generateDescription } from "../common";
import { Delimiters, WhiteSpace, Numbers, Escape, INITIAL_IN, INITIAL_OUT } from '.';

describe("StateUpdate :: Values", () => {
    let circuit: WitnessTester<
        ["byte", "pointer", "stack", "parsing_string", "parsing_number", "escaped"],
        ["next_pointer", "next_stack", "next_parsing_string", "next_parsing_number", "next_escaped"]
    >;
    before(async () => {
        circuit = await circomkit.WitnessTester(`GetTopOfStack`, {
            file: "json/machine",
            template: "StateUpdate",
            params: [4],
        });
    });

    function generatePassCase(input: any, expected: any, desc: string) {
        const description = generateDescription(input);

        it(`(valid) witness: ${description}\n${desc}`, async () => {
            await circuit.expectPass(input, expected);
        });
    }

    describe("StateUpdate :: Values :: Number", () => {
        //-TEST_1----------------------------------------------------------//
        // idea:   Read a number value after a key in an object.
        // state:  stack == [[1, 1], [0, 0], [0, 0], [0, 0]]
        // read:   `0`
        // expect: stack          --> [[1, 1], [0, 0], [0, 0], [0, 0]]
        //         parsing_number --> 1
        let read_number = { ...INITIAL_IN };
        read_number.stack = [[1, 1], [0, 0], [0, 0], [0, 0]];
        read_number.byte = Numbers.ZERO;
        let read_number_out = { ...INITIAL_OUT };
        read_number_out.next_stack = [[1, 1], [0, 0], [0, 0], [0, 0]];
        read_number_out.next_parsing_number = 1;
        generatePassCase(read_number, read_number_out, ">>>> `0` read");

        // // TODO: Note that reading a space while reading a number will not throw an error!

        //-TEST_2----------------------------------------------------------//
        // idea:   Inside a number value after a key in an object.
        // state:  stack == [[1, 1], [0, 0], [0, 0], [0, 0]], parsing_number == 1
        // read:   `1`
        // expect: stack          --> [[1, 1], [0, 0], [0, 0], [0, 0]]
        //         parsing_number --> 0
        let inside_number_continue = { ...INITIAL_IN };
        inside_number_continue.stack = [[1, 1], [0, 0], [0, 0], [0, 0]];
        inside_number_continue.parsing_number = 1;
        inside_number_continue.byte = Numbers.ONE;
        let inside_number_continue_out = { ...INITIAL_OUT };
        inside_number_continue_out.next_stack = [[1, 1], [0, 0], [0, 0], [0, 0]];
        inside_number_continue_out.next_parsing_number = 1;
        generatePassCase(inside_number_continue, inside_number_continue_out, ">>>> `1` read");

        //-TEST_2----------------------------------------------------------//
        // idea:   Inside a number value after a key in an object.
        // state:  stack == [[1, 1], [0, 0], [0, 0], [0, 0]], parsing_number == 1
        // read:   `1`
        // expect: stack          --> [[1, 1], [0, 0], [0, 0], [0, 0]]
        //         parsing_number --> 0
        let inside_number_exit = { ...INITIAL_IN };
        inside_number_exit.stack = [[1, 1], [0, 0], [0, 0], [0, 0]];
        inside_number_exit.parsing_number = 1;
        inside_number_exit.byte = WhiteSpace.SPACE;
        let inside_number_exit_out = { ...INITIAL_OUT };
        inside_number_exit_out.next_stack = [[1, 1], [0, 0], [0, 0], [0, 0]];
        inside_number_exit_out.next_parsing_number = 0;
        generatePassCase(inside_number_exit, inside_number_exit_out, ">>>> ` ` read");

        //-TEST_3----------------------------------------------------------//
        // idea:   Inside a number value after a key in an object.
        // state:  stack == [[1, 1], [0, 0], [0, 0], [0, 0]], parsing_number == 1
        // read:   `$`
        // expect: stack          --> [[1, 1], [0, 0], [0, 0], [0, 0]]
        //         parsing_number --> 0
        let inside_number_exit2 = { ...INITIAL_IN };
        inside_number_exit2.stack = [[1, 1], [0, 0], [0, 0], [0, 0]];
        inside_number_exit2.parsing_number = 1;
        inside_number_exit2.byte = 36; // Dollar sign `$`
        let inside_number_exit2_out = { ...INITIAL_OUT };
        inside_number_exit2_out.next_stack = [[1, 1], [0, 0], [0, 0], [0, 0]];
        inside_number_exit2_out.next_parsing_number = 0;
        generatePassCase(inside_number_exit2, inside_number_exit2_out, ">>>> `$` read");
    });

    describe("StateUpdate :: Values :: String", () => {
        //-TEST_4----------------------------------------------------------//
        // idea:   Inside a string key inside an object
        // state:  stack == [[1, 0], [0, 0], [0, 0], [0, 0]], parsing_string == 1
        // read:   `,`
        // expect: stack          --> [[1, 0], [0, 0], [0, 0], [0, 0]]
        //         parsing_string --> 0
        let inside_number = { ...INITIAL_IN };
        inside_number.stack = [[1, 1], [0, 0], [0, 0], [0, 0]];
        inside_number.parsing_string = 1;
        inside_number.byte = Delimiters.COMMA;
        let inside_number_out = { ...INITIAL_OUT };
        inside_number_out.next_stack = [[1, 0], [0, 0], [0, 0], [0, 0]];
        inside_number_out.next_parsing_string = 1;
        generatePassCase(inside_number, inside_number_out, ">>>> `,` read");
    });

    describe("StateUpdate :: Values :: Array", () => {
        // Internal array parsing -----------------------------------------//

        //-TEST_10----------------------------------------------------------//
        // init:   stack  == [[1, 0], [2, 0], [0, 0], [0, 0]]
        // read:   `,`
        // expext: stack --> [[1, 0], [2, 1], [0, 0], [0, 0]]
        let in_arr = { ...INITIAL_IN };
        in_arr.stack = [[1, 0], [2, 0], [0, 0], [0, 0]];
        in_arr.byte = Delimiters.COMMA;
        let in_arr_out = { ...INITIAL_OUT };
        in_arr_out.next_stack = [[1, 0], [2, 1], [0, 0], [0, 0]];
        generatePassCase(in_arr, in_arr_out, ">>>> `,` read");

        //-TEST_10----------------------------------------------------------//
        // init:   stack  == [[1, 0], [2, 1], [0, 0], [0, 0]]
        // read:   `]`
        // expect: stack --> [[1, 0], [0, 0], [0, 0], [0, 0]]
        let in_arr_idx_to_leave = { ...INITIAL_IN };
        in_arr_idx_to_leave.stack = [[1, 0], [2, 1], [0, 0], [0, 0]];
        in_arr_idx_to_leave.byte = Delimiters.END_BRACKET;
        let in_arr_idx_to_leave_out = { ...INITIAL_OUT };
        in_arr_idx_to_leave_out.next_stack = [[1, 0], [0, 0], [0, 0], [0, 0]];
        generatePassCase(in_arr_idx_to_leave, in_arr_idx_to_leave_out, ">>>> `]` read");
    });
});