+32

yaml/ocaml-yamle/bin/dune

reviewed

··· 30 30 (executable 31 31 (name test_empty_final) 32 32 (libraries yamle)) 33 33 + 34 34 + (executable 35 35 + (name test_block_debug) 36 36 + (libraries yamle)) 37 37 + 38 38 + (executable 39 39 + (name test_failing) 40 40 + (libraries yamle)) 41 41 + 42 42 + (executable 43 43 + (name test_debug_cases) 44 44 + (libraries yamle)) 45 45 + 46 46 + (executable 47 47 + (name test_seq_comment) 48 48 + (libraries yamle)) 49 49 + 50 50 + (executable 51 51 + (name test_rzp5_exact) 52 52 + (libraries yamle)) 53 53 + 54 54 + (executable 55 55 + (name test_indent_comment) 56 56 + (libraries yamle)) 57 57 + 58 58 + (executable 59 59 + (name test_tokens_debug) 60 60 + (libraries yamle)) 61 61 + 62 62 + (executable 63 63 + (name test_error_detail) 64 64 + (libraries yamle))

+2

yaml/ocaml-yamle/lib/error.ml

reviewed

··· 24 24 | Invalid_yaml_version of string 25 25 | Invalid_tag_directive of string 26 26 | Reserved_directive of string 27 27 + | Illegal_flow_key_line (** Key and : must be on same line in flow context *) 27 28 28 29 (* Parser errors *) 29 30 | Unexpected_token of string ··· 123 124 | Invalid_yaml_version s -> Printf.sprintf "invalid YAML version: %s" s 124 125 | Invalid_tag_directive s -> Printf.sprintf "invalid TAG directive: %s" s 125 126 | Reserved_directive s -> Printf.sprintf "reserved directive: %s" s 127 127 + | Illegal_flow_key_line -> "key and ':' must be on the same line in flow context" 126 128 | Unexpected_token s -> Printf.sprintf "unexpected token: %s" s 127 129 | Expected_document_start -> "expected document start '---'" 128 130 | Expected_document_end -> "expected document end '...'"

+6

yaml/ocaml-yamle/lib/parser.ml

reviewed

··· 395 395 push_state t Block_mapping_value; 396 396 parse_node t ~block:true ~indentless:true 397 397 end 398 398 + (* Handle value without explicit key - key is empty/null *) 399 399 + | Token.Value -> 400 400 + t.state <- Block_mapping_value; 401 401 + empty_scalar_event ~anchor:None ~tag:None tok.span 398 402 | Token.Block_end -> 399 403 skip_token t; 400 404 t.state <- pop_state t; 401 405 Event.Mapping_end, tok.span 402 406 | _ -> 407 407 + Printf.eprintf "DEBUG parser parse_block_mapping_key: unexpected token at %d:%d\n%!" 408 408 + tok.span.start.line tok.span.start.column; 403 409 Error.raise_span tok.span Expected_key 404 410 405 411 (** Parse block mapping value *)

+198 -117

yaml/ocaml-yamle/lib/scanner.ml

reviewed

··· 31 31 mutable document_has_content : bool; (** True if we've emitted content tokens in current document *) 32 32 mutable adjacent_value_allowed_at : Position.t option; (** Position where adjacent : is allowed *) 33 33 mutable pending_value : bool; (** True if we've emitted a KEY and are waiting for VALUE *) 34 34 + mutable flow_mapping_stack : bool list; (** Stack of whether each flow level is a mapping *) 34 35 } 35 36 36 37 let create input = ··· 50 51 document_has_content = false; 51 52 adjacent_value_allowed_at = None; 52 53 pending_value = false; 54 54 + flow_mapping_stack = []; 53 55 } 54 56 55 57 let of_string s = create (Input.of_string s) ··· 173 175 let save_simple_key t = 174 176 if t.allow_simple_key then begin 175 177 (* A simple key is required only if we're in a block context, 176 176 - at the current indentation level, AND we have an active indent *) 178 178 + at the current indentation level, AND the current indent needs a block end. 179 179 + This matches saphyr's logic and prevents false positives for values. *) 177 180 let required = t.flow_level = 0 && 178 178 - t.indent_stack <> [] && 179 179 - current_indent t = column t - 1 in 181 181 + match t.indent_stack with 182 182 + | { indent; needs_block_end = true; _ } :: _ -> 183 183 + indent = column t 184 184 + | _ -> false 185 185 + in 180 186 let sk = { 181 187 sk_possible = true; 182 188 sk_required = required; ··· 354 360 (* Just ! followed by suffix *) 355 361 ("!", Buffer.contents buf ^ scan_tag_suffix t)) 356 362 in 363 363 + (* Validate that tag is followed by whitespace, break, or (in flow) flow indicator *) 364 364 + (match Input.peek t.input with 365 365 + | None -> () (* EOF is ok *) 366 366 + | Some c when Input.is_whitespace c || Input.is_break c -> () 367 367 + | Some c when t.flow_level > 0 && Input.is_flow_indicator c -> () 368 368 + | _ -> Error.raise_at start (Invalid_tag "expected whitespace or line break after tag")); 357 369 let span = Span.make ~start ~stop:(Input.mark t.input) in 358 370 (handle, suffix, span) 359 371 ··· 362 374 let start = Input.mark t.input in 363 375 ignore (Input.next t.input); (* consume opening single-quote *) 364 376 let buf = Buffer.create 64 in 377 377 + let whitespace = Buffer.create 16 in (* Track trailing whitespace *) 378 378 + 379 379 + let flush_whitespace () = 380 380 + if Buffer.length whitespace > 0 then begin 381 381 + Buffer.add_buffer buf whitespace; 382 382 + Buffer.clear whitespace 383 383 + end 384 384 + in 385 385 + 365 386 let rec loop () = 366 387 match Input.peek t.input with 367 388 | None -> Error.raise_at start Unclosed_single_quote ··· 370 391 (* Check for escaped quote ('') *) 371 392 (match Input.peek t.input with 372 393 | Some '\'' -> 394 394 + flush_whitespace (); 373 395 Buffer.add_char buf '\''; 374 396 ignore (Input.next t.input); 375 397 loop () 376 376 - | _ -> ()) 398 398 + | _ -> 399 399 + (* End of string - flush any trailing whitespace *) 400 400 + flush_whitespace ()) 401 401 + | Some ' ' | Some '\t' -> 402 402 + (* Track whitespace - don't add to buf yet *) 403 403 + Buffer.add_char whitespace (Option.get (Input.peek t.input)); 404 404 + ignore (Input.next t.input); 405 405 + loop () 377 406 | Some '\n' | Some '\r' -> 407 407 + (* Discard trailing whitespace before line break *) 408 408 + Buffer.clear whitespace; 378 409 Input.consume_break t.input; 379 379 - (* Fold line break to space unless at start of content *) 380 380 - if Buffer.length buf > 0 then 381 381 - Buffer.add_char buf ' '; 382 410 (* Skip leading whitespace on next line *) 383 411 while Input.next_is_blank t.input do 384 412 ignore (Input.next t.input) 385 413 done; 386 386 - (* Check for document boundary - this terminates the quoted string *) 414 414 + (* Check for document boundary *) 387 415 if Input.at_document_boundary t.input then 388 416 Error.raise_at start Unclosed_single_quote; 417 417 + (* Count empty lines (consecutive line breaks) *) 418 418 + let empty_lines = ref 0 in 419 419 + while Input.next_is_break t.input do 420 420 + incr empty_lines; 421 421 + Input.consume_break t.input; 422 422 + while Input.next_is_blank t.input do 423 423 + ignore (Input.next t.input) 424 424 + done; 425 425 + if Input.at_document_boundary t.input then 426 426 + Error.raise_at start Unclosed_single_quote 427 427 + done; 428 428 + (* Apply folding rules *) 429 429 + if !empty_lines > 0 then begin 430 430 + (* Empty lines: preserve as newlines *) 431 431 + for _ = 1 to !empty_lines do 432 432 + Buffer.add_char buf '\n' 433 433 + done 434 434 + end else 435 435 + (* Single break: fold to space (even at start of string) *) 436 436 + Buffer.add_char buf ' '; 389 437 loop () 390 438 | Some c -> 439 439 + flush_whitespace (); 391 440 Buffer.add_char buf c; 392 441 ignore (Input.next t.input); 393 442 loop () ··· 711 760 (Invalid_block_scalar_header "expected newline after header"); 712 761 713 762 let base_indent = current_indent t in 763 763 + (* base_indent is the indent level from the stack, -1 if empty. 764 764 + It's used directly for comparisons in implicit indent case. *) 714 765 let content_indent = ref ( 715 766 match !explicit_indent with 716 767 | Some n -> 717 717 - (* base_indent is a column (1-indexed), convert to indent level (0-indexed) *) 768 768 + (* Explicit indent: base_indent is 1-indexed column, convert to 0-indexed. 769 769 + content_indent = (base_indent - 1) + n, but at least n for document level. *) 718 770 let base_level = max 0 (base_indent - 1) in 719 771 base_level + n 720 772 | None -> 0 (* Will be determined by first non-empty line *) ··· 745 797 (* Line starts with fewer spaces than content_indent - dedented *) 746 798 !spaces_skipped 747 799 end else if Input.next_is_blank t.input then begin 748 748 - (* Line has spaces beyond content_indent - check if rest is only blanks *) 749 749 - let idx = ref 0 in 750 750 - let is_empty = ref false in 751 751 - while not !is_empty do 752 752 - match Input.peek_nth t.input !idx with 753 753 - | Some c when Input.is_blank c -> incr idx 754 754 - | Some c when Input.is_break c -> is_empty := true 755 755 - | _ -> is_empty := true (* Not a break, so has content *) 756 756 - done; 757 757 - (* Check if we found a break (empty line) or content *) 758 758 - (match Input.peek_nth t.input (!idx) with 759 759 - | None | Some '\n' | Some '\r' -> 760 760 - (* Empty line - preserve spaces for literal scalars *) 761 761 - if literal then begin 762 762 - while Input.next_is_blank t.input do 763 763 - Buffer.add_char trailing_breaks ' '; 764 764 - ignore (Input.next t.input) 765 765 - done 766 766 - end else begin 767 767 - while Input.next_is_blank t.input do 768 768 - ignore (Input.next t.input) 769 769 - done 770 770 - end; 771 771 - Buffer.add_char trailing_breaks '\n'; 772 772 - Input.consume_break t.input; 773 773 - skip_to_content_indent () 774 774 - | _ -> 775 775 - (* Has content *) 776 776 - !content_indent) 800 800 + (* Line has spaces/tabs beyond content_indent - could be whitespace content or empty line. 801 801 + For literal scalars, whitespace-only lines ARE content (not empty). 802 802 + For folded scalars, whitespace-only lines that are "more indented" are preserved. *) 803 803 + if literal then 804 804 + (* Literal: whitespace beyond content_indent is content, let read_lines handle it *) 805 805 + !content_indent 806 806 + else begin 807 807 + (* Folded: check if rest is only blanks *) 808 808 + let idx = ref 0 in 809 809 + while match Input.peek_nth t.input !idx with 810 810 + | Some c when Input.is_blank c -> incr idx; true 811 811 + | _ -> false 812 812 + do () done; 813 813 + match Input.peek_nth t.input (!idx) with 814 814 + | None | Some '\n' | Some '\r' -> 815 815 + (* Empty/whitespace-only line in folded - skip spaces *) 816 816 + while Input.next_is_blank t.input do 817 817 + ignore (Input.next t.input) 818 818 + done; 819 819 + Buffer.add_char trailing_breaks '\n'; 820 820 + Input.consume_break t.input; 821 821 + skip_to_content_indent () 822 822 + | _ -> 823 823 + (* Has non-whitespace content *) 824 824 + !content_indent 825 825 + end 777 826 end else 778 827 !content_indent 779 828 end else begin 780 780 - (* Implicit indent - skip empty lines without consuming spaces *) 829 829 + (* Implicit indent - skip empty lines without consuming spaces. 830 830 + Note: Only SPACES count as indentation. Tabs are content, not indentation. 831 831 + So we only check for spaces when determining if a line is "empty". *) 781 832 if Input.next_is_break t.input then begin 782 833 Buffer.add_char trailing_breaks '\n'; 783 834 Input.consume_break t.input; 784 835 skip_to_content_indent () 785 785 - end else if Input.next_is_blank t.input then begin 786 786 - (* Check if line is empty *) 836 836 + end else if Input.next_is (( = ) ' ') t.input then begin 837 837 + (* Check if line is empty (only spaces before break) *) 787 838 let idx = ref 0 in 788 839 while match Input.peek_nth t.input !idx with 789 789 - | Some c when Input.is_blank c -> incr idx; true 840 840 + | Some ' ' -> incr idx; true 790 841 | _ -> false 791 842 do () done; 792 843 match Input.peek_nth t.input (!idx) with 793 844 | None | Some '\n' | Some '\r' -> 794 794 - (* Empty line *) 795 795 - while Input.next_is_blank t.input do 845 845 + (* Line has only spaces - empty line *) 846 846 + while Input.next_is (( = ) ' ') t.input do 796 847 ignore (Input.next t.input) 797 848 done; 798 849 Buffer.add_char trailing_breaks '\n'; 799 850 Input.consume_break t.input; 800 851 skip_to_content_indent () 801 852 | _ -> 802 802 - (* Has content - don't consume anything, return 0 as we haven't skipped *) 853 853 + (* Has content (including tabs which are content, not indentation) *) 803 854 0 804 855 end else 805 805 - (* Not at break or blank - return 0 *) 856 856 + (* Not at break or space - could be tab (content) or other *) 806 857 0 807 858 end 808 859 in ··· 827 878 828 879 (* Determine content indent from first content line (implicit case) *) 829 880 let first_line = !content_indent = 0 in 830 830 - if !content_indent = 0 then begin 831 831 - if line_indent <= base_indent then begin 832 832 - (* No content - restore position conceptually *) 833 833 - () 834 834 - end else 835 835 - content_indent := line_indent 836 836 - end; 881 881 + (* base_indent is 1-indexed column, convert to 0-indexed for comparison with line_indent. 882 882 + If base_indent = -1 (empty stack), then base_level = -1 means col 0 is valid. *) 883 883 + let base_level = base_indent - 1 in 884 884 + let should_process = 885 885 + if !content_indent = 0 then begin 886 886 + (* For implicit indent, content must be more indented than base_level. *) 887 887 + if line_indent <= base_level then 888 888 + false (* No content - first line not indented enough *) 889 889 + else begin 890 890 + content_indent := line_indent; 891 891 + true 892 892 + end 893 893 + end else if line_indent < !content_indent then 894 894 + false (* Dedented - done with content *) 895 895 + else 896 896 + true 897 897 + in 837 898 838 838 - if line_indent < !content_indent then begin 839 839 - (* Dedented - done with content *) 840 840 - () 841 841 - end else begin 842 842 - (* Check if current line is "more indented" (has extra indent beyond content_indent) *) 843 843 - let trailing_blank = line_indent > !content_indent in 899 899 + if should_process then begin 900 900 + (* Check if current line is "more indented" (has extra indent or starts with whitespace). 901 901 + For folded scalars, lines that start with any whitespace (space or tab) after the 902 902 + content indentation are "more indented" and preserve breaks. 903 903 + Note: we check Input.next_is_blank BEFORE reading content to see if content starts with whitespace. *) 904 904 + let trailing_blank = line_indent > !content_indent || Input.next_is_blank t.input in 844 905 845 906 (* Add trailing breaks to buffer *) 846 907 if Buffer.length buf > 0 then begin ··· 1055 1116 let span = Span.make ~start ~stop:(Input.mark t.input) in 1056 1117 let token = if indicator = "---" then Token.Document_start else Token.Document_end in 1057 1118 (* Reset document content flag after document end marker *) 1058 1058 - if indicator = "..." then 1119 1119 + if indicator = "..." then begin 1059 1120 t.document_has_content <- false; 1121 1121 + (* After document end marker, skip whitespace and check for end of line or comment *) 1122 1122 + while Input.next_is_blank t.input do ignore (Input.next t.input) done; 1123 1123 + (match Input.peek t.input with 1124 1124 + | None -> () (* EOF is ok *) 1125 1125 + | Some c when Input.is_break c -> () 1126 1126 + | Some '#' -> () (* Comment is ok *) 1127 1127 + | _ -> Error.raise_at start (Invalid_directive "content not allowed after document end marker on same line")) 1128 1128 + end; 1060 1129 emit t span token 1061 1130 1062 1131 and fetch_directive t = ··· 1079 1148 if t.flow_level = 0 then 1080 1149 t.flow_indent <- column t; 1081 1150 t.flow_level <- t.flow_level + 1; 1151 1151 + (* Track whether this is a mapping or sequence *) 1152 1152 + let is_mapping = (token_type = Token.Flow_mapping_start) in 1153 1153 + t.flow_mapping_stack <- is_mapping :: t.flow_mapping_stack; 1082 1154 t.allow_simple_key <- true; 1083 1155 t.simple_keys <- None :: t.simple_keys; 1084 1156 t.document_has_content <- true; ··· 1090 1162 and fetch_flow_collection_end t token_type = 1091 1163 remove_simple_key t; 1092 1164 t.flow_level <- t.flow_level - 1; 1165 1165 + t.flow_mapping_stack <- (match t.flow_mapping_stack with _ :: rest -> rest | [] -> []); 1093 1166 t.simple_keys <- (match t.simple_keys with _ :: rest -> rest | [] -> []); 1094 1167 t.allow_simple_key <- false; 1095 1168 let start = Input.mark t.input in ··· 1200 1273 | None -> false) 1201 1274 1202 1275 and fetch_value t = 1276 1276 + let start = Input.mark t.input in 1203 1277 (* Check for simple key *) 1204 1204 - (match t.simple_keys with 1205 1205 - | Some sk :: _ when sk.sk_possible -> 1206 1206 - (* Insert KEY token before the simple key value *) 1207 1207 - let key_span = Span.point sk.sk_position in 1208 1208 - let key_token = { Token.token = Token.Key; span = key_span } in 1209 1209 - (* We need to insert at the right position *) 1210 1210 - let tokens = Queue.to_seq t.tokens |> Array.of_seq in 1211 1211 - Queue.clear t.tokens; 1212 1212 - let insert_pos = sk.sk_token_number - t.tokens_taken in 1213 1213 - Array.iteri (fun i tok -> 1214 1214 - if i = insert_pos then Queue.add key_token t.tokens; 1215 1215 - Queue.add tok t.tokens 1216 1216 - ) tokens; 1217 1217 - if insert_pos >= Array.length tokens then 1218 1218 - Queue.add key_token t.tokens; 1219 1219 - t.token_number <- t.token_number + 1; 1220 1220 - t.pending_value <- true; (* We've inserted a KEY token, now waiting for VALUE *) 1221 1221 - (* Roll indent for implicit block mapping *) 1222 1222 - if t.flow_level = 0 then begin 1223 1223 - let col = sk.sk_position.column in 1224 1224 - if roll_indent t col ~sequence:false then begin 1225 1225 - let span = Span.point sk.sk_position in 1226 1226 - (* Insert block mapping start before key *) 1227 1227 - let bm_token = { Token.token = Token.Block_mapping_start; span } in 1228 1228 - let tokens = Queue.to_seq t.tokens |> Array.of_seq in 1229 1229 - Queue.clear t.tokens; 1230 1230 - Array.iteri (fun i tok -> 1231 1231 - if i = insert_pos then Queue.add bm_token t.tokens; 1232 1232 - Queue.add tok t.tokens 1233 1233 - ) tokens; 1234 1234 - if insert_pos >= Array.length tokens then 1235 1235 - Queue.add bm_token t.tokens; 1236 1236 - t.token_number <- t.token_number + 1 1237 1237 - end 1238 1238 - end; 1239 1239 - t.simple_keys <- None :: (List.tl t.simple_keys) 1240 1240 - | _ -> 1241 1241 - (* No simple key - this is a complex value (or empty key) *) 1242 1242 - if t.flow_level = 0 then begin 1243 1243 - if not t.allow_simple_key then 1244 1244 - Error.raise_at (Input.mark t.input) Expected_key; 1245 1245 - let col = column t in 1246 1246 - if roll_indent t col ~sequence:false then begin 1247 1247 - let span = Span.point (Input.mark t.input) in 1248 1248 - emit t span Token.Block_mapping_start 1249 1249 - end; 1250 1250 - (* Emit KEY token for empty key case (e.g., ": value") only if we don't already have a pending KEY *) 1251 1251 - if not t.pending_value then begin 1252 1252 - let span = Span.point (Input.mark t.input) in 1253 1253 - emit t span Token.Key; 1254 1254 - t.pending_value <- true 1255 1255 - end 1256 1256 - end); 1278 1278 + let used_simple_key = 1279 1279 + match t.simple_keys with 1280 1280 + | Some sk :: _ when sk.sk_possible -> 1281 1281 + (* In implicit flow mapping (inside a flow sequence), key and : must be on the same line. 1282 1282 + In explicit flow mapping { }, key and : can span lines. *) 1283 1283 + let is_implicit_flow_mapping = match t.flow_mapping_stack with 1284 1284 + | false :: _ -> true (* false = we're in a sequence, so any mapping is implicit *) 1285 1285 + | _ -> false 1286 1286 + in 1287 1287 + if is_implicit_flow_mapping && sk.sk_position.line < (Input.position t.input).line then 1288 1288 + Error.raise_at start Illegal_flow_key_line; 1289 1289 + (* Insert KEY token before the simple key value *) 1290 1290 + let key_span = Span.point sk.sk_position in 1291 1291 + let key_token = { Token.token = Token.Key; span = key_span } in 1292 1292 + (* We need to insert at the right position *) 1293 1293 + let tokens = Queue.to_seq t.tokens |> Array.of_seq in 1294 1294 + Queue.clear t.tokens; 1295 1295 + let insert_pos = sk.sk_token_number - t.tokens_taken in 1296 1296 + Array.iteri (fun i tok -> 1297 1297 + if i = insert_pos then Queue.add key_token t.tokens; 1298 1298 + Queue.add tok t.tokens 1299 1299 + ) tokens; 1300 1300 + if insert_pos >= Array.length tokens then 1301 1301 + Queue.add key_token t.tokens; 1302 1302 + t.token_number <- t.token_number + 1; 1303 1303 + t.pending_value <- true; (* We've inserted a KEY token, now waiting for VALUE *) 1304 1304 + (* Roll indent for implicit block mapping *) 1305 1305 + if t.flow_level = 0 then begin 1306 1306 + let col = sk.sk_position.column in 1307 1307 + if roll_indent t col ~sequence:false then begin 1308 1308 + let span = Span.point sk.sk_position in 1309 1309 + (* Insert block mapping start before key *) 1310 1310 + let bm_token = { Token.token = Token.Block_mapping_start; span } in 1311 1311 + let tokens = Queue.to_seq t.tokens |> Array.of_seq in 1312 1312 + Queue.clear t.tokens; 1313 1313 + Array.iteri (fun i tok -> 1314 1314 + if i = insert_pos then Queue.add bm_token t.tokens; 1315 1315 + Queue.add tok t.tokens 1316 1316 + ) tokens; 1317 1317 + if insert_pos >= Array.length tokens then 1318 1318 + Queue.add bm_token t.tokens; 1319 1319 + t.token_number <- t.token_number + 1 1320 1320 + end 1321 1321 + end; 1322 1322 + t.simple_keys <- None :: (List.tl t.simple_keys); 1323 1323 + true 1324 1324 + | _ -> 1325 1325 + (* No simple key - this is a complex value (or empty key) *) 1326 1326 + if t.flow_level = 0 then begin 1327 1327 + if not t.allow_simple_key then 1328 1328 + Error.raise_at (Input.mark t.input) Expected_key; 1329 1329 + let col = column t in 1330 1330 + if roll_indent t col ~sequence:false then begin 1331 1331 + let span = Span.point (Input.mark t.input) in 1332 1332 + emit t span Token.Block_mapping_start 1333 1333 + end 1334 1334 + (* Note: We don't emit KEY here. Empty key handling is done by the parser, 1335 1335 + which emits empty scalar when it sees VALUE without preceding KEY. *) 1336 1336 + end; 1337 1337 + false 1338 1338 + in 1257 1339 remove_simple_key t; 1258 1258 - (* In block context, allow_simple_key becomes true only after a line break, 1259 1259 - not immediately after ':'. This prevents constructs like "key: - a". 1260 1260 - The line break handling in skip_to_next_token will set it to true. *) 1261 1261 - t.allow_simple_key <- false; 1340 1340 + (* In block context without simple key, allow simple keys for compact mappings like ": moon: white" 1341 1341 + In flow context or after using a simple key, disallow simple keys *) 1342 1342 + t.allow_simple_key <- (not used_simple_key) && (t.flow_level = 0); 1262 1343 t.document_has_content <- true; 1263 1344 let start = Input.mark t.input in 1264 1345 ignore (Input.next t.input);

+93

yaml/ocaml-yamle/tests/dune

reviewed

··· 82 82 (name test_remaining) 83 83 (modules test_remaining) 84 84 (libraries yamle)) 85 85 + 86 86 + (executable 87 87 + (name debug_multiline) 88 88 + (modules debug_multiline) 89 89 + (libraries yamle)) 90 90 + 91 91 + (executable 92 92 + (name test_anchor_tag_issues) 93 93 + (modules test_anchor_tag_issues) 94 94 + (libraries yamle)) 95 95 + 96 96 + (executable 97 97 + (name debug_quoted) 98 98 + (modules debug_quoted) 99 99 + (libraries yamle test_suite_lib)) 100 100 + 101 101 + (executable 102 102 + (name debug_prh3) 103 103 + (modules debug_prh3) 104 104 + (libraries yamle)) 105 105 + 106 106 + (executable 107 107 + (name test_nat4_a) 108 108 + (modules test_nat4_a) 109 109 + (libraries yamle)) 110 110 + 111 111 + (executable 112 112 + (name test_simple_single) 113 113 + (modules test_simple_single) 114 114 + (libraries yamle)) 115 115 + 116 116 + (executable 117 117 + (name test_a984_trace) 118 118 + (modules test_a984_trace) 119 119 + (libraries yamle)) 120 120 + 121 121 + (executable 122 122 + (name debug_block_scalars) 123 123 + (modules debug_block_scalars) 124 124 + (libraries yamle)) 125 125 + 126 126 + (executable 127 127 + (name debug_jef9) 128 128 + (modules debug_jef9) 129 129 + (libraries yamle test_suite_lib)) 130 130 + 131 131 + (executable 132 132 + (name debug_l24t) 133 133 + (modules debug_l24t) 134 134 + (libraries yamle test_suite_lib)) 135 135 + 136 136 + (executable 137 137 + (name debug_r4yg) 138 138 + (modules debug_r4yg) 139 139 + (libraries yamle test_suite_lib)) 140 140 + 141 141 + (executable 142 142 + (name test_y79y) 143 143 + (modules test_y79y) 144 144 + (libraries yamle)) 145 145 + 146 146 + (executable 147 147 + (name test_y79y_simple) 148 148 + (modules test_y79y_simple) 149 149 + (libraries yamle)) 150 150 + 151 151 + (executable 152 152 + (name test_y79y_trace) 153 153 + (modules test_y79y_trace) 154 154 + (libraries yamle)) 155 155 + 156 156 + (executable 157 157 + (name test_y79y_all) 158 158 + (modules test_y79y_all) 159 159 + (libraries yamle)) 160 160 + 161 161 + (executable 162 162 + (name debug_block_issues) 163 163 + (modules debug_block_issues) 164 164 + (libraries yamle test_suite_lib)) 165 165 + (executable (name test_simple_key_debug) (modules test_simple_key_debug) (libraries yamle)) 166 166 + (executable (name test_trace_a984) (modules test_trace_a984) (libraries yamle)) 167 167 + (executable (name test_debug_stale) (modules test_debug_stale) (libraries yamle)) 168 168 + (executable (name test_error_type) (modules test_error_type) (libraries yamle)) 169 169 + (executable (name test_a984_minimal) (modules test_a984_minimal) (libraries yamle)) 170 170 + (executable (name test_indent_debug) (modules test_indent_debug) (libraries yamle)) 171 171 + (executable (name test_all_mentioned_cases) (modules test_all_mentioned_cases) (libraries yamle)) 172 172 + (executable (name debug_m2n8) (modules debug_m2n8) (libraries yamle test_suite_lib)) 173 173 + (executable (name debug_v9d5) (modules debug_v9d5) (libraries yamle test_suite_lib)) 174 174 + (executable (name test_lhl4) (modules test_lhl4) (libraries yamle)) 175 175 + (executable (name test_dk4h) (modules test_dk4h) (libraries yamle)) 176 176 + (executable (name test_sy6v) (modules test_sy6v) (libraries yamle)) 177 177 + (executable (name test_3hfz) (modules test_3hfz) (libraries yamle))