···

       
1
       
 
       
(test

     

       
2
       
 
       
 (name simple_test)

     

       
3
       
-
       
 (libraries fastcgi eio)

     

       
4
       
 
       
 (deps (source_tree test_cases))

     

       
5
       
 
       
)

     

       
6
       
 
       


     

       
7
       
 
       
(test

     

       
8
       
 
       
 (name validate_all_test_cases)

     

       
9
       
-
       
 (libraries fastcgi eio)

     

       
10
       
 
       
 (deps (source_tree test_cases))

     

       
11
       
 
       
)

     

···

       
1
       
 
       
(test

     

       
2
       
 
       
 (name simple_test)

     

       
3
       
+
       
 (libraries fastcgi eio eio_main)

     

       
4
       
 
       
 (deps (source_tree test_cases))

     

       
5
       
 
       
)

     

       
6
       
 
       


     

       
7
       
 
       
(test

     

       
8
       
 
       
 (name validate_all_test_cases)

     

       
9
       
+
       
 (libraries fastcgi eio eio_main)

     

       
10
       
 
       
 (deps (source_tree test_cases))

     

       
11
       
 
       
)

     

···

       
67
       
 
       
  

     

       
68
       
 
       
  Printf.printf "✓ Long key-value encoding test passed\n%!"

     

       
69
       
 
       


     

       
70
       
-
       
let test_with_binary_test_case filename expected_type expected_request_id =

     

       
71
       
 
       
  Printf.printf "Testing with binary test case: %s...\n%!" filename;

     

       
72
       
 
       
  

     

       
73
       
-
       
  let content = 

     

       
74
       
-
       
    let ic = open_in_bin ("test_cases/" ^ filename) in

     

       
75
       
-
       
    let len = in_channel_length ic in

     

       
76
       
-
       
    let content = really_input_string ic len in

     

       
77
       
-
       
    close_in ic;

     

       
78
       
-
       
    content

     

       
79
       
 
       
  in

     

       
80
       
-
       
  

     

       
81
       
-
       
  let buf_read = Eio.Buf_read.of_string content in

     

       
82
       
-
       
  let parsed = Record.read buf_read in

     

       
83
       
 
       
  

     

       
84
       
 
       
  assert (parsed.version = 1);

     

       
85
       
 
       
  assert (parsed.record_type = expected_type);

     
···

       
87
       
 
       
  

     

       
88
       
 
       
  Printf.printf "✓ Binary test case %s passed\n%!" filename

     

       
89
       
 
       


     

       
90
       
-
       
let run_tests () =

     

       
91
       
 
       
  Printf.printf "Running FastCGI Record tests...\n\n%!";

     

       
92
       
 
       
  

     

       
93
       
 
       
  test_record_types ();

     
···

       
95
       
 
       
  test_long_key_value ();

     

       
96
       
 
       
  

     

       
97
       
 
       
  (* Test with some of our binary test cases *)

     

       
98
       
-
       
  test_with_binary_test_case "begin_request_responder.bin" Begin_request 1;

     

       
99
       
-
       
  test_with_binary_test_case "params_empty.bin" Params 1;

     

       
100
       
-
       
  test_with_binary_test_case "end_request_success.bin" End_request 1;

     

       
101
       
-
       
  test_with_binary_test_case "get_values.bin" Get_values 0;

     

       
102
       
-
       
  test_with_binary_test_case "abort_request.bin" Abort_request 1;

     

       
103
       
 
       
  

     

       
104
       
 
       
  Printf.printf "\n✅ All FastCGI Record tests passed!\n%!"

     

       
105
       
 
       


     

       
106
       
-
       
let () = run_tests ()

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
67
       
 
       
  

     

       
68
       
 
       
  Printf.printf "✓ Long key-value encoding test passed\n%!"

     

       
69
       
 
       


     

       
70
       
+
       
let test_with_binary_test_case ~fs filename expected_type expected_request_id =

     

       
71
       
 
       
  Printf.printf "Testing with binary test case: %s...\n%!" filename;

     

       
72
       
 
       
  

     

       
73
       
+
       
  let parsed = 

     

       
74
       
+
       
    Eio.Path.with_open_in (fs, "test_cases/" ^ filename) @@ fun flow ->

     

       
75
       
+
       
    let buf_read = Eio.Buf_read.of_flow flow ~max_size:1000000 in

     

       
76
       
+
       
    Record.read buf_read

     

       
0
       
 
       

     

       
0
       
 
       

     

       
77
       
 
       
  in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
78
       
 
       
  

     

       
79
       
 
       
  assert (parsed.version = 1);

     

       
80
       
 
       
  assert (parsed.record_type = expected_type);

     
···

       
82
       
 
       
  

     

       
83
       
 
       
  Printf.printf "✓ Binary test case %s passed\n%!" filename

     

       
84
       
 
       


     

       
85
       
+
       
let run_tests ~fs =

     

       
86
       
 
       
  Printf.printf "Running FastCGI Record tests...\n\n%!";

     

       
87
       
 
       
  

     

       
88
       
 
       
  test_record_types ();

     
···

       
90
       
 
       
  test_long_key_value ();

     

       
91
       
 
       
  

     

       
92
       
 
       
  (* Test with some of our binary test cases *)

     

       
93
       
+
       
  test_with_binary_test_case ~fs "begin_request_responder.bin" Begin_request 1;

     

       
94
       
+
       
  test_with_binary_test_case ~fs "params_empty.bin" Params 1;

     

       
95
       
+
       
  test_with_binary_test_case ~fs "end_request_success.bin" End_request 1;

     

       
96
       
+
       
  test_with_binary_test_case ~fs "get_values.bin" Get_values 0;

     

       
97
       
+
       
  test_with_binary_test_case ~fs "abort_request.bin" Abort_request 1;

     

       
98
       
 
       
  

     

       
99
       
 
       
  Printf.printf "\n✅ All FastCGI Record tests passed!\n%!"

     

       
100
       
 
       


     

       
101
       
+
       
let () = Eio_main.run @@ fun env ->

     

       
102
       
+
       
  let fs = Eio.Stdenv.cwd env in

     

       
103
       
+
       
  run_tests ~fs:(fst fs)

     

···

       
25
       
 
       
  ("unknown_type.bin", Unknown_type, 0);

     

       
26
       
 
       
]

     

       
27
       
 
       


     

       
28
       
-
       
let test_binary_file filename expected_type expected_request_id =

     

       
29
       
 
       
  Printf.printf "Testing %s... " filename;

     

       
30
       
 
       
  

     

       
31
       
-
       
  let content = 

     

       
32
       
-
       
    let ic = open_in_bin ("test_cases/" ^ filename) in

     

       
33
       
-
       
    let len = in_channel_length ic in

     

       
34
       
-
       
    let content = really_input_string ic len in

     

       
35
       
-
       
    close_in ic;

     

       
36
       
-
       
    content

     

       
37
       
 
       
  in

     

       
38
       
 
       
  

     

       
39
       
-
       
  let buf_read = Eio.Buf_read.of_string content in

     

       
40
       
-
       
  let parsed = Record.read buf_read in

     

       
41
       
-
       
  

     

       
42
       
 
       
  assert (parsed.version = 1);

     

       
43
       
 
       
  assert (parsed.record_type = expected_type);

     

       
44
       
 
       
  assert (parsed.request_id = expected_request_id);

     

       
45
       
 
       
  

     

       
46
       
 
       
  Printf.printf "✓\n%!"

     

       
47
       
 
       


     

       
48
       
-
       
let test_params_decoding () =

     

       
49
       
 
       
  Printf.printf "Testing params record content decoding... ";

     

       
50
       
 
       
  

     

       
51
       
-
       
  let content = 

     

       
52
       
-
       
    let ic = open_in_bin "test_cases/params_get.bin" in

     

       
53
       
-
       
    let len = in_channel_length ic in

     

       
54
       
-
       
    let content = really_input_string ic len in

     

       
55
       
-
       
    close_in ic;

     

       
56
       
-
       
    content

     

       
57
       
 
       
  in

     

       
58
       
 
       
  

     

       
59
       
-
       
  let buf_read = Eio.Buf_read.of_string content in

     

       
60
       
-
       
  let parsed = Record.read buf_read in

     

       
61
       
-
       
  

     

       
62
       
 
       
  (* Decode the params content *)

     

       
63
       
 
       
  let params = Record.KV.decode parsed.content in

     

       
64
       
 
       
  

     
···

       
69
       
 
       
  

     

       
70
       
 
       
  Printf.printf "✓\n%!"

     

       
71
       
 
       


     

       
72
       
-
       
let test_large_record () =

     

       
73
       
 
       
  Printf.printf "Testing large record... ";

     

       
74
       
 
       
  

     

       
75
       
-
       
  let content = 

     

       
76
       
-
       
    let ic = open_in_bin "test_cases/large_record.bin" in

     

       
77
       
-
       
    let len = in_channel_length ic in

     

       
78
       
-
       
    let content = really_input_string ic len in

     

       
79
       
-
       
    close_in ic;

     

       
80
       
-
       
    content

     

       
81
       
 
       
  in

     

       
82
       
 
       
  

     

       
83
       
-
       
  let buf_read = Eio.Buf_read.of_string content in

     

       
84
       
-
       
  let parsed = Record.read buf_read in

     

       
85
       
-
       
  

     

       
86
       
 
       
  assert (parsed.version = 1);

     

       
87
       
 
       
  assert (parsed.record_type = Stdout);

     

       
88
       
 
       
  assert (parsed.request_id = 1);

     
···

       
90
       
 
       
  

     

       
91
       
 
       
  Printf.printf "✓\n%!"

     

       
92
       
 
       


     

       
93
       
-
       
let test_padded_record () =

     

       
94
       
 
       
  Printf.printf "Testing padded record... ";

     

       
95
       
 
       
  

     

       
96
       
-
       
  let content = 

     

       
97
       
-
       
    let ic = open_in_bin "test_cases/padded_record.bin" in

     

       
98
       
-
       
    let len = in_channel_length ic in

     

       
99
       
-
       
    let content = really_input_string ic len in

     

       
100
       
-
       
    close_in ic;

     

       
101
       
-
       
    content

     

       
102
       
 
       
  in

     

       
103
       
-
       
  

     

       
104
       
-
       
  let buf_read = Eio.Buf_read.of_string content in

     

       
105
       
-
       
  let parsed = Record.read buf_read in

     

       
106
       
 
       
  

     

       
107
       
 
       
  assert (parsed.version = 1);

     

       
108
       
 
       
  assert (parsed.record_type = Stdout);

     
···

       
111
       
 
       
  

     

       
112
       
 
       
  Printf.printf "✓\n%!"

     

       
113
       
 
       


     

       
114
       
-
       
let test_multiplexed_records () =

     

       
115
       
 
       
  Printf.printf "Testing multiplexed records... ";

     

       
116
       
 
       
  

     

       
117
       
-
       
  let content = 

     

       
118
       
-
       
    let ic = open_in_bin "test_cases/multiplexed_requests.bin" in

     

       
119
       
-
       
    let len = in_channel_length ic in

     

       
120
       
-
       
    let content = really_input_string ic len in

     

       
121
       
-
       
    close_in ic;

     

       
122
       
-
       
    content

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
123
       
 
       
  in

     

       
124
       
 
       
  

     

       
125
       
-
       
  let buf_read = Eio.Buf_read.of_string content in

     

       
126
       
-
       
  let records = ref [] in

     

       
127
       
-
       
  

     

       
128
       
-
       
  (* Read all records from the multiplexed stream *)

     

       
129
       
-
       
  (try

     

       
130
       
-
       
    while true do

     

       
131
       
-
       
      let record = Record.read buf_read in

     

       
132
       
-
       
      records := record :: !records

     

       
133
       
-
       
    done

     

       
134
       
-
       
   with End_of_file -> ());

     

       
135
       
-
       
  

     

       
136
       
-
       
  let records = List.rev !records in

     

       
137
       
 
       
  

     

       
138
       
 
       
  (* Should have multiple records with different request IDs *)

     

       
139
       
 
       
  assert (List.length records > 5);

     
···

       
145
       
 
       
  

     

       
146
       
 
       
  Printf.printf "✓\n%!"

     

       
147
       
 
       


     

       
148
       
-
       
let run_all_tests () =

     

       
149
       
 
       
  Printf.printf "Validating all FastCGI test case files...\n\n%!";

     

       
150
       
 
       
  

     

       
151
       
 
       
  (* Test individual files *)

     

       
152
       
 
       
  List.iter (fun (filename, expected_type, expected_request_id) ->

     

       
153
       
-
       
    test_binary_file filename expected_type expected_request_id

     

       
154
       
 
       
  ) test_cases;

     

       
155
       
 
       
  

     

       
156
       
 
       
  Printf.printf "\nTesting specific content decoding...\n%!";

     

       
157
       
-
       
  test_params_decoding ();

     

       
158
       
-
       
  test_large_record ();

     

       
159
       
-
       
  test_padded_record ();

     

       
160
       
-
       
  test_multiplexed_records ();

     

       
161
       
 
       
  

     

       
162
       
 
       
  Printf.printf "\n✅ All %d test case files validated successfully!\n%!" (List.length test_cases);

     

       
163
       
 
       
  Printf.printf "✅ FastCGI Record implementation is working correctly!\n%!"

     

       
164
       
 
       


     

       
165
       
-
       
let () = run_all_tests ()
     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
25
       
 
       
  ("unknown_type.bin", Unknown_type, 0);

     

       
26
       
 
       
]

     

       
27
       
 
       


     

       
28
       
+
       
let test_binary_file ~fs filename expected_type expected_request_id =

     

       
29
       
 
       
  Printf.printf "Testing %s... " filename;

     

       
30
       
 
       
  

     

       
31
       
+
       
  let parsed = 

     

       
32
       
+
       
    Eio.Path.with_open_in (fs, "test_cases/" ^ filename) @@ fun flow ->

     

       
33
       
+
       
    let buf_read = Eio.Buf_read.of_flow flow ~max_size:1000000 in

     

       
34
       
+
       
    Record.read buf_read

     

       
0
       
 
       

     

       
0
       
 
       

     

       
35
       
 
       
  in

     

       
36
       
 
       
  

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
37
       
 
       
  assert (parsed.version = 1);

     

       
38
       
 
       
  assert (parsed.record_type = expected_type);

     

       
39
       
 
       
  assert (parsed.request_id = expected_request_id);

     

       
40
       
 
       
  

     

       
41
       
 
       
  Printf.printf "✓\n%!"

     

       
42
       
 
       


     

       
43
       
+
       
let test_params_decoding ~fs =

     

       
44
       
 
       
  Printf.printf "Testing params record content decoding... ";

     

       
45
       
 
       
  

     

       
46
       
+
       
  let parsed = 

     

       
47
       
+
       
    Eio.Path.with_open_in (fs, "test_cases/params_get.bin") @@ fun flow ->

     

       
48
       
+
       
    let buf_read = Eio.Buf_read.of_flow flow ~max_size:1000000 in

     

       
49
       
+
       
    Record.read buf_read

     

       
0
       
 
       

     

       
0
       
 
       

     

       
50
       
 
       
  in

     

       
51
       
 
       
  

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
52
       
 
       
  (* Decode the params content *)

     

       
53
       
 
       
  let params = Record.KV.decode parsed.content in

     

       
54
       
 
       
  

     
···

       
59
       
 
       
  

     

       
60
       
 
       
  Printf.printf "✓\n%!"

     

       
61
       
 
       


     

       
62
       
+
       
let test_large_record ~fs =

     

       
63
       
 
       
  Printf.printf "Testing large record... ";

     

       
64
       
 
       
  

     

       
65
       
+
       
  let parsed = 

     

       
66
       
+
       
    Eio.Path.with_open_in (fs, "test_cases/large_record.bin") @@ fun flow ->

     

       
67
       
+
       
    let buf_read = Eio.Buf_read.of_flow flow ~max_size:1000000 in

     

       
68
       
+
       
    Record.read buf_read

     

       
0
       
 
       

     

       
0
       
 
       

     

       
69
       
 
       
  in

     

       
70
       
 
       
  

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
71
       
 
       
  assert (parsed.version = 1);

     

       
72
       
 
       
  assert (parsed.record_type = Stdout);

     

       
73
       
 
       
  assert (parsed.request_id = 1);

     
···

       
75
       
 
       
  

     

       
76
       
 
       
  Printf.printf "✓\n%!"

     

       
77
       
 
       


     

       
78
       
+
       
let test_padded_record ~fs =

     

       
79
       
 
       
  Printf.printf "Testing padded record... ";

     

       
80
       
 
       
  

     

       
81
       
+
       
  let parsed = 

     

       
82
       
+
       
    Eio.Path.with_open_in (fs, "test_cases/padded_record.bin") @@ fun flow ->

     

       
83
       
+
       
    let buf_read = Eio.Buf_read.of_flow flow ~max_size:1000000 in

     

       
84
       
+
       
    Record.read buf_read

     

       
0
       
 
       

     

       
0
       
 
       

     

       
85
       
 
       
  in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
86
       
 
       
  

     

       
87
       
 
       
  assert (parsed.version = 1);

     

       
88
       
 
       
  assert (parsed.record_type = Stdout);

     
···

       
91
       
 
       
  

     

       
92
       
 
       
  Printf.printf "✓\n%!"

     

       
93
       
 
       


     

       
94
       
+
       
let test_multiplexed_records ~fs =

     

       
95
       
 
       
  Printf.printf "Testing multiplexed records... ";

     

       
96
       
 
       
  

     

       
97
       
+
       
  let records = 

     

       
98
       
+
       
    Eio.Path.with_open_in (fs, "test_cases/multiplexed_requests.bin") @@ fun flow ->

     

       
99
       
+
       
    let buf_read = Eio.Buf_read.of_flow flow ~max_size:1000000 in

     

       
100
       
+
       
    let records = ref [] in

     

       
101
       
+
       
    

     

       
102
       
+
       
    (* Read all records from the multiplexed stream *)

     

       
103
       
+
       
    (try

     

       
104
       
+
       
      while true do

     

       
105
       
+
       
        let record = Record.read buf_read in

     

       
106
       
+
       
        records := record :: !records

     

       
107
       
+
       
      done

     

       
108
       
+
       
     with End_of_file -> ());

     

       
109
       
+
       
    !records

     

       
110
       
 
       
  in

     

       
111
       
 
       
  

     

       
112
       
+
       
  let records = List.rev records in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
113
       
 
       
  

     

       
114
       
 
       
  (* Should have multiple records with different request IDs *)

     

       
115
       
 
       
  assert (List.length records > 5);

     
···

       
121
       
 
       
  

     

       
122
       
 
       
  Printf.printf "✓\n%!"

     

       
123
       
 
       


     

       
124
       
+
       
let run_all_tests ~fs =

     

       
125
       
 
       
  Printf.printf "Validating all FastCGI test case files...\n\n%!";

     

       
126
       
 
       
  

     

       
127
       
 
       
  (* Test individual files *)

     

       
128
       
 
       
  List.iter (fun (filename, expected_type, expected_request_id) ->

     

       
129
       
+
       
    test_binary_file ~fs filename expected_type expected_request_id

     

       
130
       
 
       
  ) test_cases;

     

       
131
       
 
       
  

     

       
132
       
 
       
  Printf.printf "\nTesting specific content decoding...\n%!";

     

       
133
       
+
       
  test_params_decoding ~fs;

     

       
134
       
+
       
  test_large_record ~fs;

     

       
135
       
+
       
  test_padded_record ~fs;

     

       
136
       
+
       
  test_multiplexed_records ~fs;

     

       
137
       
 
       
  

     

       
138
       
 
       
  Printf.printf "\n✅ All %d test case files validated successfully!\n%!" (List.length test_cases);

     

       
139
       
 
       
  Printf.printf "✅ FastCGI Record implementation is working correctly!\n%!"

     

       
140
       
 
       


     

       
141
       
+
       
let () = Eio_main.run @@ fun env ->

     

       
142
       
+
       
  let fs = Eio.Stdenv.cwd env in

     

       
143
       
+
       
  run_all_tests ~fs:(fst fs)