From 200c90ea54b89b650ca657268cea8a3d42d5e144 Mon Sep 17 00:00:00 2001 From: Thomas Gazagnaire Date: Fri, 28 Aug 2026 13:17:30 +0000 Subject: [PATCH] csv: migrate monorepo callers to field codecs Qualify scalar codecs through Csv.Field, move callers to the structured-error entry points, and adapt the legacy CDM channel wrappers through Bytesrw readers. --- merlint/lib/rules/e820.ml | 4 +- merlint/lib/rules/e825.ml | 2 +- .../good/foo/test/interop/oracle/test.ml | 6 +- .../good/foo/test/interop/oracle/test.ml | 2 +- ocaml-aos/test/interop/dariol83/test.ml | 30 +- .../lib/resolve/test/interop/indigo/test.ml | 8 +- ocaml-ax25/test/interop/pyax25/test.ml | 30 +- ocaml-bluetooth/test/interop/bumble/test.ml | 20 +- ocaml-bpsec/test/interop/bp7/test.ml | 18 +- ocaml-bundle/test/interop/bp7/test.ml | 14 +- ocaml-cdm/lib/cdm.ml | 37 +-- ocaml-cdm/lib/cdm.mli | 2 +- ocaml-cdm/lib/dune | 2 +- ocaml-cdm/test/interop/orekit/test.ml | 110 +++---- ocaml-cfdp/test/interop/dariol83/test.ml | 26 +- ocaml-cfdp/test/interop/spacepackets/test.ml | 281 +++++++++--------- ocaml-clcw/test/interop/dariol83/test.ml | 34 ++- ocaml-coordinate/test/interop/proj/test.ml | 16 +- ocaml-cop1/test/interop/dariol83/test.ml | 58 ++-- ocaml-cose/test/interop/pycose/test.ml | 42 +-- ocaml-crc/test/interop/crcmod/test.ml | 16 +- ocaml-crdt/test/interop/automerge/test.ml | 4 +- ocaml-crdt/test/interop/crdts/test.ml | 4 +- ocaml-crdt/test/support/crdt_interop_trace.ml | 16 +- ocaml-csv/bench/bench.ml | 14 +- ocaml-csv/lib/csv.mli | 6 +- ocaml-did/lib/plc/test/interop/indigo/test.ml | 10 +- ocaml-did/lib/web/test/interop/indigo/test.ml | 8 +- ocaml-did/test/interop/indigo/test.ml | 10 +- ocaml-dsp/test/interop/numpy/test.ml | 16 +- ocaml-etcd/test/interop/etcd/test.ml | 8 +- ocaml-fat/test/interop/mtools/test.ml | 10 +- ocaml-fsr/test/interop/cryptolib/test.ml | 20 +- ocaml-http/test/interop/boto3/test.ml | 10 +- ocaml-ip/test/interop/scapy/test.ml | 48 +-- ocaml-ipam/test/interop/moby/test.ml | 16 +- ocaml-latlon/test/interop/haversine/test.ml | 16 +- ocaml-latlon/test/interop/s2/test.ml | 24 +- ocaml-ltp/test/interop/ion/test.ml | 12 +- ocaml-merge3/test/interop/git/test.ml | 16 +- ocaml-mst/test/interop/atrium/test.ml | 14 +- ocaml-mst/test/interop/indigo/test.ml | 14 +- ocaml-ocm/test/interop/orekit/test.ml | 49 +-- ocaml-oem/test/interop/orekit/test.ml | 34 +-- ocaml-opm/test/interop/orekit/test.ml | 32 +- ocaml-passwd/test/interop/runc/test.ml | 16 +- .../test/interop/prometheus_client/test.ml | 10 +- ocaml-pus/test/interop/spacepackets/test.ml | 28 +- .../test/interop/reedsolo/test.ml | 10 +- ocaml-rice/test/interop/libaec/test.ml | 15 +- ocaml-s3/test/interop/boto3/test.ml | 24 +- ocaml-scc/test/interop/dariol83/test.ml | 32 +- ocaml-sdls/test/interop/cryptolib/test.ml | 50 ++-- ocaml-sle/test/interop/asn1tools/test.ml | 10 +- ocaml-sle/test/interop/dariol83/test.ml | 33 +- .../test/interop/spacepackets/test.ml | 24 +- .../test/interop/squashfs-tools/test.ml | 10 +- ocaml-ssh/test/interop/paramiko/test.ml | 10 +- ocaml-stats/test/interop/numpy/test.ml | 38 +-- ocaml-stats/test/interop/scipy/test.ml | 26 +- ocaml-tc/test/interop/dariol83/test.ml | 24 +- ocaml-tcf/test/interop/spacepackets/test.ml | 16 +- ocaml-tcp/test/interop/lwip/test.ml | 8 +- ocaml-tcp/test/interop/mirage/test.ml | 10 +- ocaml-tcp/test/interop/utcp/test.ml | 8 +- ocaml-tcpcl/test/interop/dtn7-go/test.ml | 10 +- ocaml-tcpcl/test/interop/ion/test.ml | 31 +- ocaml-tdm/test/interop/orekit/test.ml | 22 +- ocaml-tiff/test/interop/gdal/test.ml | 50 ++-- ocaml-tm/test/interop/dariol83/test.ml | 40 +-- ocaml-tpm/test/interop/go-tpm/test.ml | 10 +- ocaml-turbo/test/interop/aff3ct/test.ml | 14 +- ocaml-uslp/test/interop/spacepackets/test.ml | 38 +-- ocaml-vaccel/test/interop/vaccel-rust/test.ml | 12 +- .../test/interop/mapshaper/test.ml | 22 +- ocaml-viterbi/test/interop/commpy/test.ml | 10 +- ocaml-xen/test/interop/xenstored/test.ml | 16 +- ocaml-xlsx/test/interop/xlrd/test.ml | 18 +- ocaml-xtce/test/interop/yamcs/test.ml | 14 +- 79 files changed, 952 insertions(+), 926 deletions(-) diff --git a/merlint/lib/rules/e820.ml b/merlint/lib/rules/e820.ml index 7cc13a879d..284f65f9d6 100644 --- a/merlint/lib/rules/e820.ml +++ b/merlint/lib/rules/e820.ml @@ -36,6 +36,6 @@ let pp ppf { dir } = let rule = Rule.v ~code:"E820" ~title:"Hand-rolled CSV parsing" ~category:Interop_testing ~hint: - "Use csv (Csv.decode_file with a Csv.Row codec) for CSV trace parsing. \ - Never hand-roll CSV readers with open_in/input_line/split_on_char." + "Use csv (Csv.of_file with a Csv.Row codec) for CSV trace parsing. Never \ + hand-roll CSV readers with open_in/input_line/split_on_char." ~examples:[] ~pp (Project check) diff --git a/merlint/lib/rules/e825.ml b/merlint/lib/rules/e825.ml index c1a02e2857..d45a982f96 100644 --- a/merlint/lib/rules/e825.ml +++ b/merlint/lib/rules/e825.ml @@ -48,6 +48,6 @@ let rule = Rule.v ~code:"E825" ~title:"Missing csv dependency" ~category:Interop_testing ~hint: "Interop tests with CSV traces should use csv for parsing. Add csv to \ - the (libraries ...) in the dune file and use Csv.decode_file with a Row \ + the (libraries ...) in the dune file and use Csv.of_file with a Row \ codec." ~examples:[] ~pp (Project check) diff --git a/merlint/test/cram/e820.t/good/foo/test/interop/oracle/test.ml b/merlint/test/cram/e820.t/good/foo/test/interop/oracle/test.ml index 9ffe00e777..4c41a051c4 100644 --- a/merlint/test/cram/e820.t/good/foo/test/interop/oracle/test.ml +++ b/merlint/test/cram/e820.t/good/foo/test/interop/oracle/test.ml @@ -1,8 +1,10 @@ let () = let codec = Csv.Row.( - obj (fun value -> value) |> col "value" Csv.string ~enc:Fun.id |> finish) + obj (fun value -> value) + |> col "value" Csv.Field.string ~enc:Fun.id + |> finish) in - match Csv.decode_file codec "traces/sample.csv" with + match Csv.of_file codec "traces/sample.csv" with | Ok _rows -> () | Error _ -> () diff --git a/merlint/test/cram/e825.t/good/foo/test/interop/oracle/test.ml b/merlint/test/cram/e825.t/good/foo/test/interop/oracle/test.ml index a3d3354969..83c2f0efa7 100644 --- a/merlint/test/cram/e825.t/good/foo/test/interop/oracle/test.ml +++ b/merlint/test/cram/e825.t/good/foo/test/interop/oracle/test.ml @@ -1 +1 @@ -let () = ignore (Csv.decode_file "traces/sample.csv") +let () = ignore (Csv.of_file "traces/sample.csv") diff --git a/ocaml-aos/test/interop/dariol83/test.ml b/ocaml-aos/test/interop/dariol83/test.ml index 5acd6f2e73..6531c74338 100644 --- a/ocaml-aos/test/interop/dariol83/test.ml +++ b/ocaml-aos/test/interop/dariol83/test.ml @@ -59,19 +59,19 @@ let vector_codec = expect_fecf; frame_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "version" int ~enc:(fun r -> r.version) - |> col "scid" int ~enc:(fun r -> r.scid) - |> col "vcid" int ~enc:(fun r -> r.vcid) - |> col "vcfc" int ~enc:(fun r -> r.vcfc) - |> col "replay_flag" bool ~enc:(fun r -> r.replay_flag) - |> col "vc_count_flag" bool ~enc:(fun r -> r.vc_count_flag) - |> col "vc_count_cycle" int ~enc:(fun r -> r.vc_count_cycle) - |> col "data_hex" string ~enc:(fun r -> r.data_hex) - |> col "ocf_hex" string ~enc:(fun r -> r.ocf_hex) - |> col "expect_ocf" bool ~enc:(fun r -> r.expect_ocf) - |> col "expect_fecf" bool ~enc:(fun r -> r.expect_fecf) - |> col "frame_hex" string ~enc:(fun r -> r.frame_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "version" Field.int ~enc:(fun r -> r.version) + |> col "scid" Field.int ~enc:(fun r -> r.scid) + |> col "vcid" Field.int ~enc:(fun r -> r.vcid) + |> col "vcfc" Field.int ~enc:(fun r -> r.vcfc) + |> col "replay_flag" Field.bool ~enc:(fun r -> r.replay_flag) + |> col "vc_count_flag" Field.bool ~enc:(fun r -> r.vc_count_flag) + |> col "vc_count_cycle" Field.int ~enc:(fun r -> r.vc_count_cycle) + |> col "data_hex" Field.string ~enc:(fun r -> r.data_hex) + |> col "ocf_hex" Field.string ~enc:(fun r -> r.ocf_hex) + |> col "expect_ocf" Field.bool ~enc:(fun r -> r.expect_ocf) + |> col "expect_fecf" Field.bool ~enc:(fun r -> r.expect_fecf) + |> col "frame_hex" Field.string ~enc:(fun r -> r.frame_hex) |> finish)) (* {1 Helpers} *) @@ -83,9 +83,9 @@ let parse_ocf_hex s = (Optint.of_unsigned_int32 (Int64.to_int32 (Int64.of_string ("0x" ^ s)))) let load_vectors () = - match Csv.decode_file vector_codec "traces/vectors.csv" with + match Csv.of_file vector_codec "traces/vectors.csv" with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e (* {1 Tests} *) diff --git a/ocaml-atproto-handle/lib/resolve/test/interop/indigo/test.ml b/ocaml-atproto-handle/lib/resolve/test/interop/indigo/test.ml index 0cbc987293..23d9fa1091 100644 --- a/ocaml-atproto-handle/lib/resolve/test/interop/indigo/test.ml +++ b/ocaml-atproto-handle/lib/resolve/test/interop/indigo/test.ml @@ -17,8 +17,8 @@ let row_codec = Csv.( Row.( obj (fun handle did -> { handle; did }) - |> col "handle" string ~enc:(fun r -> r.handle) - |> col "did" string ~enc:(fun r -> r.did) + |> col "handle" Field.string ~enc:(fun r -> r.handle) + |> col "did" Field.string ~enc:(fun r -> r.did) |> finish)) let network_enabled () = @@ -39,8 +39,8 @@ let check_resolution ~sw ~clock ~mono ~net ~random handle_s expected_did = Alcotest.failf "resolve %s: %a" handle_s Atproto_handle_resolve.pp_error e let load_data () = - match Csv.decode_file row_codec "traces/handles.csv" with - | Error msg -> Alcotest.failf "load CSV: %s" msg + match Csv.of_file row_codec "traces/handles.csv" with + | Error e -> Alcotest.failf "load CSV: %a" Csv.Error.pp e | Ok [] -> Alcotest.fail "empty CSV" | Ok rows -> rows diff --git a/ocaml-ax25/test/interop/pyax25/test.ml b/ocaml-ax25/test/interop/pyax25/test.ml index 75c57359b6..6985a3f07d 100644 --- a/ocaml-ax25/test/interop/pyax25/test.ml +++ b/ocaml-ax25/test/interop/pyax25/test.ml @@ -30,13 +30,13 @@ let ui_frame_codec = info_hex; frame_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "source" string ~enc:(fun r -> r.source) - |> col "destination" string ~enc:(fun r -> r.destination) - |> col "digipeaters" string ~enc:(fun r -> r.digipeaters) - |> col "pid_hex" string ~enc:(fun r -> r.pid_hex) - |> col "info_hex" string ~enc:(fun r -> r.info_hex) - |> col "frame_hex" string ~enc:(fun r -> r.frame_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "source" Field.string ~enc:(fun r -> r.source) + |> col "destination" Field.string ~enc:(fun r -> r.destination) + |> col "digipeaters" Field.string ~enc:(fun r -> r.digipeaters) + |> col "pid_hex" Field.string ~enc:(fun r -> r.pid_hex) + |> col "info_hex" Field.string ~enc:(fun r -> r.info_hex) + |> col "frame_hex" Field.string ~enc:(fun r -> r.frame_hex) |> finish)) type ext_bit_row = { @@ -51,10 +51,10 @@ let ext_bit_codec = Row.( obj (fun name frame_hex n_callsigns last_index -> { name; frame_hex; n_callsigns; last_index }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "frame_hex" string ~enc:(fun r -> r.frame_hex) - |> col "n_callsigns" int ~enc:(fun r -> r.n_callsigns) - |> col "last_index" int ~enc:(fun r -> r.last_index) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "frame_hex" Field.string ~enc:(fun r -> r.frame_hex) + |> col "n_callsigns" Field.int ~enc:(fun r -> r.n_callsigns) + |> col "last_index" Field.int ~enc:(fun r -> r.last_index) |> finish)) (* {1 Helpers} *) @@ -66,9 +66,9 @@ let hex_of_bytes b = Hex.encode (Bytes.to_string b) let ui_frame_encoding () = let rows = - match Csv.decode_file ui_frame_codec (trace "ui_frames.csv") with + match Csv.of_file ui_frame_codec (trace "ui_frames.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : ui_frame_row) -> @@ -95,9 +95,9 @@ let ui_frame_encoding () = let extension_bits () = let rows = - match Csv.decode_file ext_bit_codec (trace "extension_bits.csv") with + match Csv.of_file ext_bit_codec (trace "extension_bits.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : ext_bit_row) -> diff --git a/ocaml-bluetooth/test/interop/bumble/test.ml b/ocaml-bluetooth/test/interop/bumble/test.ml index c734bfe707..d2bb80106c 100644 --- a/ocaml-bluetooth/test/interop/bumble/test.ml +++ b/ocaml-bluetooth/test/interop/bumble/test.ml @@ -38,10 +38,10 @@ let crypto_codec = Csv.( Row.( obj (fun name func args expected -> { name; func; args; expected }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "func" string ~enc:(fun r -> r.func) - |> col "args" string ~enc:(fun r -> r.args) - |> col "expected" string ~enc:(fun r -> r.expected) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "func" Field.string ~enc:(fun r -> r.func) + |> col "args" Field.string ~enc:(fun r -> r.args) + |> col "expected" Field.string ~enc:(fun r -> r.expected) |> finish)) (* Dispatch a crypto row on its function, computing with Toolbox and comparing @@ -82,8 +82,8 @@ let check_crypto r () = | f -> Alcotest.failf "%s: unknown crypto function %S" r.name f let crypto_cases () = - match Csv.decode_file crypto_codec (trace "crypto.csv") with - | Error e -> Alcotest.failf "crypto.csv: %s" e + match Csv.of_file crypto_codec (trace "crypto.csv") with + | Error e -> Alcotest.failf "crypto.csv: %a" Csv.Error.pp e | Ok rows -> List.map (fun r -> Alcotest.test_case r.name `Quick (check_crypto r)) rows @@ -95,8 +95,8 @@ let pdu_codec = Csv.( Row.( obj (fun name encoded_hex -> { name; encoded_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "encoded_hex" string ~enc:(fun r -> r.encoded_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "encoded_hex" Field.string ~enc:(fun r -> r.encoded_hex) |> finish)) (* The logical PDUs, built with Message constructors from the same field values @@ -184,8 +184,8 @@ let logical_pdus = let pdu_cases () = let rows = - match Csv.decode_file pdu_codec (trace "pdus.csv") with - | Error e -> Alcotest.failf "pdus.csv: %s" e + match Csv.of_file pdu_codec (trace "pdus.csv") with + | Error e -> Alcotest.failf "pdus.csv: %a" Csv.Error.pp e | Ok rows -> rows in let expected = List.map (fun r -> (r.name, r.encoded_hex)) rows in diff --git a/ocaml-bpsec/test/interop/bp7/test.ml b/ocaml-bpsec/test/interop/bp7/test.ml index f792a19bef..2fac873ff8 100644 --- a/ocaml-bpsec/test/interop/bp7/test.ml +++ b/ocaml-bpsec/test/interop/bp7/test.ml @@ -69,13 +69,13 @@ let row_codec = Csv.Row.( obj (fun name sha_variant scope key_hex ippt_hex signature_hex asb_hex -> { name; sha_variant; scope; key_hex; ippt_hex; signature_hex; asb_hex }) - |> col "name" Csv.string ~enc:(fun r -> r.name) - |> col "sha_variant" Csv.int ~enc:(fun r -> r.sha_variant) - |> col "scope" Csv.int ~enc:(fun r -> r.scope) - |> col "key_hex" Csv.string ~enc:(fun r -> r.key_hex) - |> col "ippt_hex" Csv.string ~enc:(fun r -> r.ippt_hex) - |> col "signature_hex" Csv.string ~enc:(fun r -> r.signature_hex) - |> col "asb_hex" Csv.string ~enc:(fun r -> r.asb_hex) + |> col "name" Csv.Field.string ~enc:(fun r -> r.name) + |> col "sha_variant" Csv.Field.int ~enc:(fun r -> r.sha_variant) + |> col "scope" Csv.Field.int ~enc:(fun r -> r.scope) + |> col "key_hex" Csv.Field.string ~enc:(fun r -> r.key_hex) + |> col "ippt_hex" Csv.Field.string ~enc:(fun r -> r.ippt_hex) + |> col "signature_hex" Csv.Field.string ~enc:(fun r -> r.signature_hex) + |> col "asb_hex" Csv.Field.string ~enc:(fun r -> r.asb_hex) |> finish) (* Every SHA variant bp7 records is one RFC 9173 Table 1 defines, so this also @@ -105,8 +105,8 @@ let check_row r () = Alcotest.(check string) "ASB matches bp7" r.asb_hex (Hex.encode btsd)) let suite = - match Csv.decode_file row_codec (trace "integrity.csv") with - | Error msg -> Alcotest.failf "decoding integrity.csv: %s" msg + match Csv.of_file row_codec (trace "integrity.csv") with + | Error e -> Alcotest.failf "decoding integrity.csv: %a" Csv.Error.pp e | Ok rows -> ( "bp7", List.map (fun r -> Alcotest.test_case r.name `Quick (check_row r)) rows diff --git a/ocaml-bundle/test/interop/bp7/test.ml b/ocaml-bundle/test/interop/bp7/test.ml index e0a8685d1f..3ef1ad421d 100644 --- a/ocaml-bundle/test/interop/bp7/test.ml +++ b/ocaml-bundle/test/interop/bp7/test.ml @@ -20,11 +20,11 @@ let raw_vector_codec = Row.( obj (fun name source destination payload_hex bundle_hex -> { name; source; destination; payload_hex; bundle_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "source" string ~enc:(fun r -> r.source) - |> col "destination" string ~enc:(fun r -> r.destination) - |> col "payload_hex" string ~enc:(fun r -> r.payload_hex) - |> col "bundle_hex" string ~enc:(fun r -> r.bundle_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "source" Field.string ~enc:(fun r -> r.source) + |> col "destination" Field.string ~enc:(fun r -> r.destination) + |> col "payload_hex" Field.string ~enc:(fun r -> r.payload_hex) + |> col "bundle_hex" Field.string ~enc:(fun r -> r.bundle_hex) |> finish)) (* {1 Helpers} *) @@ -61,9 +61,9 @@ type vector = { let parse_vectors () = let rows = - match Csv.decode_file raw_vector_codec (trace "vectors.csv") with + match Csv.of_file raw_vector_codec (trace "vectors.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.map (fun (r : raw_vector) -> diff --git a/ocaml-cdm/lib/cdm.ml b/ocaml-cdm/lib/cdm.ml index 7aa4df362b..337446b3c8 100644 --- a/ocaml-cdm/lib/cdm.ml +++ b/ocaml-cdm/lib/cdm.ml @@ -181,7 +181,7 @@ let bool_of_met = function Met -> true | Not_met -> false let met_of_bool = function true -> Met | false -> Not_met let met_criteria_codec = - Csv.col_map ~kind:"met_criteria" + Csv.Field.v ~kind:"met_criteria" ~dec:(fun s -> match int_of_string_opt s with | Some i -> Ok (met_of_bool (i <> 0)) @@ -237,8 +237,8 @@ type flat = { file2 : string; } -let nf = Csv.nullable_float -let ni = Csv.nullable_int +let nf = Csv.Field.nullable_float +let ni = Csv.Field.nullable_int let obj1_cols row = let open Csv.Row in @@ -333,26 +333,26 @@ let flat run_id conj_id obj1 met1 obj2 met2 min_range vrel prob dilution let flat_header_cols row = let open Csv.Row in row - |> col "run_id" Csv.int ~enc:(fun f -> f.run_id) - |> col "conj_id" Csv.int ~enc:(fun f -> f.conj_id) - |> col "obj1" Csv.int ~enc:(fun f -> f.obj1) + |> col "run_id" Csv.Field.int ~enc:(fun f -> f.run_id) + |> col "conj_id" Csv.Field.int ~enc:(fun f -> f.conj_id) + |> col "obj1" Csv.Field.int ~enc:(fun f -> f.obj1) |> col "met_criteria1" met_criteria_codec ~enc:(fun f -> f.met1) - |> col "obj2" Csv.int ~enc:(fun f -> f.obj2) + |> col "obj2" Csv.Field.int ~enc:(fun f -> f.obj2) |> col "met_criteria2" met_criteria_codec ~enc:(fun f -> f.met2) |> col "min_range" nf ~enc:(fun f -> f.min_range) |> col "Vrel" nf ~enc:(fun f -> f.vrel) |> col "prob" nf ~enc:(fun f -> f.prob) |> col "dilution" ni ~enc:(fun f -> f.dilution) |> col "mdistance" nf ~enc:(fun f -> f.mdistance) - |> col "epoch" Csv.string ~enc:(fun f -> f.epoch) + |> col "epoch" Csv.Field.string ~enc:(fun f -> f.epoch) |> col "jdate" nf ~enc:(fun f -> f.jdate) let flat_codec = Csv.( Row.( obj flat |> flat_header_cols |> obj1_cols |> obj2_cols - |> col "obj1_filename" string ~enc:(fun f -> f.file1) - |> col "obj2_filename" string ~enc:(fun f -> f.file2) + |> col "obj1_filename" Field.string ~enc:(fun f -> f.file1) + |> col "obj2_filename" Field.string ~enc:(fun f -> f.file2) |> finish)) let obj_of_flat ~id ~met ~x ~y ~z ~vx ~vy ~vz ~lx ~ly ~lz ~c11 ~c12 ~c13 ~c22 @@ -401,9 +401,8 @@ let of_flat f = relative_metadata = None; } -let convert_error s = Parse_error s let convert_structured_error e = Parse_error (Csv.Error.to_string e) -let wrap_result r = Result.map_error convert_error r +let wrap_result r = Result.map_error convert_structured_error r let csv_header = [| @@ -455,26 +454,28 @@ let csv_header = |] let of_csv_row row fields = - match Csv.Private.resolve flat_codec csv_header with + match Csv.resolve flat_codec csv_header with | Error e -> Error (convert_structured_error e) | Ok resolved -> ( - match Csv.Private.decode_row resolved row fields with + match Csv.decode_row resolved row fields with | Error e -> Error (convert_structured_error e) | Ok flat -> Ok (of_flat flat)) let of_csv_string s = - wrap_result (Csv.decode_string flat_codec s) |> Result.map (List.map of_flat) + wrap_result (Csv.of_string flat_codec s) |> Result.map (List.map of_flat) let fold_csv_channel ic f acc = wrap_result - (Csv.fold_channel flat_codec ic (fun acc flat -> f acc (of_flat flat)) acc) + (Csv.fold_reader flat_codec ~init:acc + ~f:(fun acc flat -> f acc (of_flat flat)) + (Bytesrw.Bytes.Reader.of_in_channel ic)) let of_csv_channel ic = - wrap_result (Csv.decode_channel flat_codec ic) + wrap_result (Csv.of_reader flat_codec (Bytesrw.Bytes.Reader.of_in_channel ic)) |> Result.map (List.map of_flat) let of_csv_file path = - wrap_result (Csv.decode_file flat_codec path) |> Result.map (List.map of_flat) + wrap_result (Csv.of_file flat_codec path) |> Result.map (List.map of_flat) (* {1 Key-value table helpers} diff --git a/ocaml-cdm/lib/cdm.mli b/ocaml-cdm/lib/cdm.mli index 1e949686a1..d7e3495394 100644 --- a/ocaml-cdm/lib/cdm.mli +++ b/ocaml-cdm/lib/cdm.mli @@ -290,7 +290,7 @@ val of_csv_file : string -> (t list, error) result (** @deprecated Use {!Csv.of_file}. *) val fold_csv_channel : in_channel -> ('a -> t -> 'a) -> 'a -> ('a, error) result -(** @deprecated Use {!Csv.fold_channel}. *) +(** @deprecated Use {!Csv.fold_reader}. *) (** {1:accessors Accessors} *) diff --git a/ocaml-cdm/lib/dune b/ocaml-cdm/lib/dune index 37312af1af..417fcc18fd 100644 --- a/ocaml-cdm/lib/dune +++ b/ocaml-cdm/lib/dune @@ -1,4 +1,4 @@ (library (name cdm) (public_name cdm) - (libraries kvn vec3 nox-csv nox-json ptime fmt)) + (libraries bytesrw kvn vec3 nox-csv nox-json ptime fmt)) diff --git a/ocaml-cdm/test/interop/orekit/test.ml b/ocaml-cdm/test/interop/orekit/test.ml index c6159a39d8..5523c55b0d 100644 --- a/ocaml-cdm/test/interop/orekit/test.ml +++ b/ocaml-cdm/test/interop/orekit/test.ml @@ -191,66 +191,68 @@ let index_codec = obj2_obs_used; obj2_weighted_rms; }) - |> col "filename" string ~enc:(fun r -> r.filename) - |> col "tca" string ~enc:(fun r -> r.tca) - |> col "miss_distance" float ~enc:(fun r -> r.miss_distance) - |> col "relative_speed" float ~enc:(fun r -> r.relative_speed) - |> col "collision_probability" float ~enc:(fun r -> + |> col "filename" Field.string ~enc:(fun r -> r.filename) + |> col "tca" Field.string ~enc:(fun r -> r.tca) + |> col "miss_distance" Field.float ~enc:(fun r -> r.miss_distance) + |> col "relative_speed" Field.float ~enc:(fun r -> r.relative_speed) + |> col "collision_probability" Field.float ~enc:(fun r -> r.collision_probability) - |> col "collision_probability_method" string ~enc:(fun r -> + |> col "collision_probability_method" Field.string ~enc:(fun r -> r.collision_probability_method) - |> col "obj1_designator" string ~enc:(fun r -> r.obj1_designator) - |> col "obj1_name" string ~enc:(fun r -> r.obj1_name) - |> col "obj1_type" string ~enc:(fun r -> r.obj1_type) - |> col "obj1_x" float ~enc:(fun r -> r.obj1_x) - |> col "obj1_y" float ~enc:(fun r -> r.obj1_y) - |> col "obj1_z" float ~enc:(fun r -> r.obj1_z) - |> col "obj1_xdot" float ~enc:(fun r -> r.obj1_xdot) - |> col "obj1_ydot" float ~enc:(fun r -> r.obj1_ydot) - |> col "obj1_zdot" float ~enc:(fun r -> r.obj1_zdot) - |> col "obj1_cr_r" float ~enc:(fun r -> r.obj1_cr_r) - |> col "obj1_ct_r" float ~enc:(fun r -> r.obj1_ct_r) - |> col "obj1_ct_t" float ~enc:(fun r -> r.obj1_ct_t) - |> col "obj1_cn_r" float ~enc:(fun r -> r.obj1_cn_r) - |> col "obj1_cn_t" float ~enc:(fun r -> r.obj1_cn_t) - |> col "obj1_cn_n" float ~enc:(fun r -> r.obj1_cn_n) - |> col "obj1_mass" float ~enc:(fun r -> r.obj1_mass) - |> col "obj1_area_pc" float ~enc:(fun r -> r.obj1_area_pc) - |> col "obj1_cov_method" string ~enc:(fun r -> r.obj1_cov_method) - |> col "obj1_maneuverable" string ~enc:(fun r -> r.obj1_maneuverable) - |> col "obj1_ref_frame" string ~enc:(fun r -> r.obj1_ref_frame) - |> col "obj1_od_span" float ~enc:(fun r -> r.obj1_od_span) - |> col "obj1_obs_used" int ~enc:(fun r -> r.obj1_obs_used) - |> col "obj1_weighted_rms" float ~enc:(fun r -> r.obj1_weighted_rms) - |> col "obj2_designator" string ~enc:(fun r -> r.obj2_designator) - |> col "obj2_name" string ~enc:(fun r -> r.obj2_name) - |> col "obj2_type" string ~enc:(fun r -> r.obj2_type) - |> col "obj2_x" float ~enc:(fun r -> r.obj2_x) - |> col "obj2_y" float ~enc:(fun r -> r.obj2_y) - |> col "obj2_z" float ~enc:(fun r -> r.obj2_z) - |> col "obj2_xdot" float ~enc:(fun r -> r.obj2_xdot) - |> col "obj2_ydot" float ~enc:(fun r -> r.obj2_ydot) - |> col "obj2_zdot" float ~enc:(fun r -> r.obj2_zdot) - |> col "obj2_cr_r" float ~enc:(fun r -> r.obj2_cr_r) - |> col "obj2_ct_r" float ~enc:(fun r -> r.obj2_ct_r) - |> col "obj2_ct_t" float ~enc:(fun r -> r.obj2_ct_t) - |> col "obj2_cn_r" float ~enc:(fun r -> r.obj2_cn_r) - |> col "obj2_cn_t" float ~enc:(fun r -> r.obj2_cn_t) - |> col "obj2_cn_n" float ~enc:(fun r -> r.obj2_cn_n) - |> col "obj2_mass" float ~enc:(fun r -> r.obj2_mass) - |> col "obj2_area_pc" float ~enc:(fun r -> r.obj2_area_pc) - |> col "obj2_cov_method" string ~enc:(fun r -> r.obj2_cov_method) - |> col "obj2_maneuverable" string ~enc:(fun r -> r.obj2_maneuverable) - |> col "obj2_ref_frame" string ~enc:(fun r -> r.obj2_ref_frame) - |> col "obj2_od_span" float ~enc:(fun r -> r.obj2_od_span) - |> col "obj2_obs_used" int ~enc:(fun r -> r.obj2_obs_used) - |> col "obj2_weighted_rms" float ~enc:(fun r -> r.obj2_weighted_rms) + |> col "obj1_designator" Field.string ~enc:(fun r -> r.obj1_designator) + |> col "obj1_name" Field.string ~enc:(fun r -> r.obj1_name) + |> col "obj1_type" Field.string ~enc:(fun r -> r.obj1_type) + |> col "obj1_x" Field.float ~enc:(fun r -> r.obj1_x) + |> col "obj1_y" Field.float ~enc:(fun r -> r.obj1_y) + |> col "obj1_z" Field.float ~enc:(fun r -> r.obj1_z) + |> col "obj1_xdot" Field.float ~enc:(fun r -> r.obj1_xdot) + |> col "obj1_ydot" Field.float ~enc:(fun r -> r.obj1_ydot) + |> col "obj1_zdot" Field.float ~enc:(fun r -> r.obj1_zdot) + |> col "obj1_cr_r" Field.float ~enc:(fun r -> r.obj1_cr_r) + |> col "obj1_ct_r" Field.float ~enc:(fun r -> r.obj1_ct_r) + |> col "obj1_ct_t" Field.float ~enc:(fun r -> r.obj1_ct_t) + |> col "obj1_cn_r" Field.float ~enc:(fun r -> r.obj1_cn_r) + |> col "obj1_cn_t" Field.float ~enc:(fun r -> r.obj1_cn_t) + |> col "obj1_cn_n" Field.float ~enc:(fun r -> r.obj1_cn_n) + |> col "obj1_mass" Field.float ~enc:(fun r -> r.obj1_mass) + |> col "obj1_area_pc" Field.float ~enc:(fun r -> r.obj1_area_pc) + |> col "obj1_cov_method" Field.string ~enc:(fun r -> r.obj1_cov_method) + |> col "obj1_maneuverable" Field.string ~enc:(fun r -> + r.obj1_maneuverable) + |> col "obj1_ref_frame" Field.string ~enc:(fun r -> r.obj1_ref_frame) + |> col "obj1_od_span" Field.float ~enc:(fun r -> r.obj1_od_span) + |> col "obj1_obs_used" Field.int ~enc:(fun r -> r.obj1_obs_used) + |> col "obj1_weighted_rms" Field.float ~enc:(fun r -> r.obj1_weighted_rms) + |> col "obj2_designator" Field.string ~enc:(fun r -> r.obj2_designator) + |> col "obj2_name" Field.string ~enc:(fun r -> r.obj2_name) + |> col "obj2_type" Field.string ~enc:(fun r -> r.obj2_type) + |> col "obj2_x" Field.float ~enc:(fun r -> r.obj2_x) + |> col "obj2_y" Field.float ~enc:(fun r -> r.obj2_y) + |> col "obj2_z" Field.float ~enc:(fun r -> r.obj2_z) + |> col "obj2_xdot" Field.float ~enc:(fun r -> r.obj2_xdot) + |> col "obj2_ydot" Field.float ~enc:(fun r -> r.obj2_ydot) + |> col "obj2_zdot" Field.float ~enc:(fun r -> r.obj2_zdot) + |> col "obj2_cr_r" Field.float ~enc:(fun r -> r.obj2_cr_r) + |> col "obj2_ct_r" Field.float ~enc:(fun r -> r.obj2_ct_r) + |> col "obj2_ct_t" Field.float ~enc:(fun r -> r.obj2_ct_t) + |> col "obj2_cn_r" Field.float ~enc:(fun r -> r.obj2_cn_r) + |> col "obj2_cn_t" Field.float ~enc:(fun r -> r.obj2_cn_t) + |> col "obj2_cn_n" Field.float ~enc:(fun r -> r.obj2_cn_n) + |> col "obj2_mass" Field.float ~enc:(fun r -> r.obj2_mass) + |> col "obj2_area_pc" Field.float ~enc:(fun r -> r.obj2_area_pc) + |> col "obj2_cov_method" Field.string ~enc:(fun r -> r.obj2_cov_method) + |> col "obj2_maneuverable" Field.string ~enc:(fun r -> + r.obj2_maneuverable) + |> col "obj2_ref_frame" Field.string ~enc:(fun r -> r.obj2_ref_frame) + |> col "obj2_od_span" Field.float ~enc:(fun r -> r.obj2_od_span) + |> col "obj2_obs_used" Field.int ~enc:(fun r -> r.obj2_obs_used) + |> col "obj2_weighted_rms" Field.float ~enc:(fun r -> r.obj2_weighted_rms) |> finish)) let parse_index () = - match Csv.decode_file index_codec (trace "index.csv") with + match Csv.of_file index_codec (trace "index.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "failed to parse index.csv: %s" e + | Error e -> Alcotest.failf "failed to parse index.csv: %a" Csv.Error.pp e let check_enum msg expected actual = let expected' = normalize_enum expected in diff --git a/ocaml-cfdp/test/interop/dariol83/test.ml b/ocaml-cfdp/test/interop/dariol83/test.ml index 01c9f48cab..15b1cb0129 100644 --- a/ocaml-cfdp/test/interop/dariol83/test.ml +++ b/ocaml-cfdp/test/interop/dariol83/test.ml @@ -59,23 +59,23 @@ let ka_codec = large_file; pdu_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "source_entity" int ~enc:(fun r -> r.source_entity) - |> col "dest_entity" int ~enc:(fun r -> r.dest_entity) - |> col "seq_nr" int ~enc:(fun r -> r.seq_nr) - |> col "entity_id_len" int ~enc:(fun r -> r.entity_id_len) - |> col "seq_nr_len" int ~enc:(fun r -> r.seq_nr_len) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "mode" string ~enc:(fun r -> r.mode) - |> col "progress" int64 ~enc:(fun r -> r.progress) - |> col "large_file" bool ~enc:(fun r -> r.large_file) - |> col "pdu_hex" string ~enc:(fun r -> r.pdu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "source_entity" Field.int ~enc:(fun r -> r.source_entity) + |> col "dest_entity" Field.int ~enc:(fun r -> r.dest_entity) + |> col "seq_nr" Field.int ~enc:(fun r -> r.seq_nr) + |> col "entity_id_len" Field.int ~enc:(fun r -> r.entity_id_len) + |> col "seq_nr_len" Field.int ~enc:(fun r -> r.seq_nr_len) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "mode" Field.string ~enc:(fun r -> r.mode) + |> col "progress" Field.int64 ~enc:(fun r -> r.progress) + |> col "large_file" Field.bool ~enc:(fun r -> r.large_file) + |> col "pdu_hex" Field.string ~enc:(fun r -> r.pdu_hex) |> finish)) let load_rows () = - match Csv.decode_file ka_codec (trace "keep_alive.csv") with + match Csv.of_file ka_codec (trace "keep_alive.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e let decode_ka () = let rows = load_rows () in diff --git a/ocaml-cfdp/test/interop/spacepackets/test.ml b/ocaml-cfdp/test/interop/spacepackets/test.ml index 5ff3f9ff11..ab999b1ddd 100644 --- a/ocaml-cfdp/test/interop/spacepackets/test.ml +++ b/ocaml-cfdp/test/interop/spacepackets/test.ml @@ -160,21 +160,21 @@ let eof_codec = fault_location; pdu_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "pdu_type" string ~enc:(fun _ -> "eof") - |> col "source_entity" int ~enc:(fun r -> r.source_entity) - |> col "dest_entity" int ~enc:(fun r -> r.dest_entity) - |> col "seq_nr" int ~enc:(fun r -> r.seq_nr) - |> col "entity_id_len" int ~enc:(fun r -> r.entity_id_len) - |> col "seq_nr_len" int ~enc:(fun r -> r.seq_nr_len) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "mode" string ~enc:(fun r -> r.mode) - |> col "condition" string ~enc:(fun r -> r.condition) - |> col "checksum" string ~enc:(fun r -> r.checksum) - |> col "file_size" int64 ~enc:(fun r -> r.file_size) - |> col "large_file" bool ~enc:(fun r -> r.large_file) - |> col "fault_location" string ~enc:(fun r -> r.fault_location) - |> col "pdu_hex" string ~enc:(fun r -> r.pdu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "pdu_type" Field.string ~enc:(fun _ -> "eof") + |> col "source_entity" Field.int ~enc:(fun r -> r.source_entity) + |> col "dest_entity" Field.int ~enc:(fun r -> r.dest_entity) + |> col "seq_nr" Field.int ~enc:(fun r -> r.seq_nr) + |> col "entity_id_len" Field.int ~enc:(fun r -> r.entity_id_len) + |> col "seq_nr_len" Field.int ~enc:(fun r -> r.seq_nr_len) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "mode" Field.string ~enc:(fun r -> r.mode) + |> col "condition" Field.string ~enc:(fun r -> r.condition) + |> col "checksum" Field.string ~enc:(fun r -> r.checksum) + |> col "file_size" Field.int64 ~enc:(fun r -> r.file_size) + |> col "large_file" Field.bool ~enc:(fun r -> r.large_file) + |> col "fault_location" Field.string ~enc:(fun r -> r.fault_location) + |> col "pdu_hex" Field.string ~enc:(fun r -> r.pdu_hex) |> finish)) let check_eof_condition name expected actual = @@ -220,17 +220,17 @@ let decode_eof_row (r : eof_row) = let decode_eof () = let rows = - match Csv.decode_file eof_codec (trace "eof.csv") with + match Csv.of_file eof_codec (trace "eof.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter decode_eof_row rows let encode_eof () = let rows = - match Csv.decode_file eof_codec (trace "eof.csv") with + match Csv.of_file eof_codec (trace "eof.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : eof_row) -> @@ -333,29 +333,29 @@ let metadata_codec = large_file; pdu_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "pdu_type" string ~enc:(fun _ -> "metadata") - |> col "source_entity" int ~enc:(fun r -> r.source_entity) - |> col "dest_entity" int ~enc:(fun r -> r.dest_entity) - |> col "seq_nr" int ~enc:(fun r -> r.seq_nr) - |> col "entity_id_len" int ~enc:(fun r -> r.entity_id_len) - |> col "seq_nr_len" int ~enc:(fun r -> r.seq_nr_len) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "mode" string ~enc:(fun r -> r.mode) - |> col "closure_requested" bool ~enc:(fun r -> r.closure_requested) - |> col "checksum_type" string ~enc:(fun r -> r.checksum_type) - |> col "file_size" int64 ~enc:(fun r -> r.file_size) - |> col "source_filename" string ~enc:(fun r -> r.source_filename) - |> col "dest_filename" string ~enc:(fun r -> r.dest_filename) - |> col "large_file" bool ~enc:(fun r -> r.large_file) - |> col "pdu_hex" string ~enc:(fun r -> r.pdu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "pdu_type" Field.string ~enc:(fun _ -> "metadata") + |> col "source_entity" Field.int ~enc:(fun r -> r.source_entity) + |> col "dest_entity" Field.int ~enc:(fun r -> r.dest_entity) + |> col "seq_nr" Field.int ~enc:(fun r -> r.seq_nr) + |> col "entity_id_len" Field.int ~enc:(fun r -> r.entity_id_len) + |> col "seq_nr_len" Field.int ~enc:(fun r -> r.seq_nr_len) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "mode" Field.string ~enc:(fun r -> r.mode) + |> col "closure_requested" Field.bool ~enc:(fun r -> r.closure_requested) + |> col "checksum_type" Field.string ~enc:(fun r -> r.checksum_type) + |> col "file_size" Field.int64 ~enc:(fun r -> r.file_size) + |> col "source_filename" Field.string ~enc:(fun r -> r.source_filename) + |> col "dest_filename" Field.string ~enc:(fun r -> r.dest_filename) + |> col "large_file" Field.bool ~enc:(fun r -> r.large_file) + |> col "pdu_hex" Field.string ~enc:(fun r -> r.pdu_hex) |> finish)) let decode_metadata () = let rows = - match Csv.decode_file metadata_codec (trace "metadata.csv") with + match Csv.of_file metadata_codec (trace "metadata.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : metadata_row) -> @@ -392,9 +392,9 @@ let decode_metadata () = let encode_metadata () = let rows = - match Csv.decode_file metadata_codec (trace "metadata.csv") with + match Csv.of_file metadata_codec (trace "metadata.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : metadata_row) -> @@ -484,19 +484,20 @@ let ack_codec = transaction_status; pdu_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "pdu_type" string ~enc:(fun _ -> "ack") - |> col "source_entity" int ~enc:(fun r -> r.source_entity) - |> col "dest_entity" int ~enc:(fun r -> r.dest_entity) - |> col "seq_nr" int ~enc:(fun r -> r.seq_nr) - |> col "entity_id_len" int ~enc:(fun r -> r.entity_id_len) - |> col "seq_nr_len" int ~enc:(fun r -> r.seq_nr_len) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "mode" string ~enc:(fun r -> r.mode) - |> col "acked_directive" string ~enc:(fun r -> r.acked_directive) - |> col "acked_condition" string ~enc:(fun r -> r.acked_condition) - |> col "transaction_status" string ~enc:(fun r -> r.transaction_status) - |> col "pdu_hex" string ~enc:(fun r -> r.pdu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "pdu_type" Field.string ~enc:(fun _ -> "ack") + |> col "source_entity" Field.int ~enc:(fun r -> r.source_entity) + |> col "dest_entity" Field.int ~enc:(fun r -> r.dest_entity) + |> col "seq_nr" Field.int ~enc:(fun r -> r.seq_nr) + |> col "entity_id_len" Field.int ~enc:(fun r -> r.entity_id_len) + |> col "seq_nr_len" Field.int ~enc:(fun r -> r.seq_nr_len) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "mode" Field.string ~enc:(fun r -> r.mode) + |> col "acked_directive" Field.string ~enc:(fun r -> r.acked_directive) + |> col "acked_condition" Field.string ~enc:(fun r -> r.acked_condition) + |> col "transaction_status" Field.string ~enc:(fun r -> + r.transaction_status) + |> col "pdu_hex" Field.string ~enc:(fun r -> r.pdu_hex) |> finish)) (* ACK subtype: EOF->0, Finished->1 per spacepackets *) @@ -509,9 +510,9 @@ let ack_subtype_of_directive : Cfdp.directive_code -> int = function let decode_ack () = let rows = - match Csv.decode_file ack_codec (trace "ack.csv") with + match Csv.of_file ack_codec (trace "ack.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : ack_row) -> @@ -554,9 +555,9 @@ let decode_ack () = let encode_ack () = let rows = - match Csv.decode_file ack_codec (trace "ack.csv") with + match Csv.of_file ack_codec (trace "ack.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : ack_row) -> @@ -647,26 +648,26 @@ let finished_codec = file_status; pdu_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "pdu_type" string ~enc:(fun _ -> "finished") - |> col "source_entity" int ~enc:(fun r -> r.source_entity) - |> col "dest_entity" int ~enc:(fun r -> r.dest_entity) - |> col "seq_nr" int ~enc:(fun r -> r.seq_nr) - |> col "entity_id_len" int ~enc:(fun r -> r.entity_id_len) - |> col "seq_nr_len" int ~enc:(fun r -> r.seq_nr_len) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "mode" string ~enc:(fun r -> r.mode) - |> col "condition" string ~enc:(fun r -> r.condition) - |> col "delivery_code" string ~enc:(fun r -> r.delivery_code) - |> col "file_status" string ~enc:(fun r -> r.file_status) - |> col "pdu_hex" string ~enc:(fun r -> r.pdu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "pdu_type" Field.string ~enc:(fun _ -> "finished") + |> col "source_entity" Field.int ~enc:(fun r -> r.source_entity) + |> col "dest_entity" Field.int ~enc:(fun r -> r.dest_entity) + |> col "seq_nr" Field.int ~enc:(fun r -> r.seq_nr) + |> col "entity_id_len" Field.int ~enc:(fun r -> r.entity_id_len) + |> col "seq_nr_len" Field.int ~enc:(fun r -> r.seq_nr_len) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "mode" Field.string ~enc:(fun r -> r.mode) + |> col "condition" Field.string ~enc:(fun r -> r.condition) + |> col "delivery_code" Field.string ~enc:(fun r -> r.delivery_code) + |> col "file_status" Field.string ~enc:(fun r -> r.file_status) + |> col "pdu_hex" Field.string ~enc:(fun r -> r.pdu_hex) |> finish)) let decode_finished () = let rows = - match Csv.decode_file finished_codec (trace "finished.csv") with + match Csv.of_file finished_codec (trace "finished.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : finished_row) -> @@ -713,9 +714,9 @@ let decode_finished () = let encode_finished () = let rows = - match Csv.decode_file finished_codec (trace "finished.csv") with + match Csv.of_file finished_codec (trace "finished.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : finished_row) -> @@ -806,26 +807,26 @@ let file_data_codec = large_file; pdu_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "pdu_type" string ~enc:(fun _ -> "file_data") - |> col "source_entity" int ~enc:(fun r -> r.source_entity) - |> col "dest_entity" int ~enc:(fun r -> r.dest_entity) - |> col "seq_nr" int ~enc:(fun r -> r.seq_nr) - |> col "entity_id_len" int ~enc:(fun r -> r.entity_id_len) - |> col "seq_nr_len" int ~enc:(fun r -> r.seq_nr_len) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "mode" string ~enc:(fun r -> r.mode) - |> col "offset" int64 ~enc:(fun r -> r.offset) - |> col "data_hex" string ~enc:(fun r -> r.data_hex) - |> col "large_file" bool ~enc:(fun r -> r.large_file) - |> col "pdu_hex" string ~enc:(fun r -> r.pdu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "pdu_type" Field.string ~enc:(fun _ -> "file_data") + |> col "source_entity" Field.int ~enc:(fun r -> r.source_entity) + |> col "dest_entity" Field.int ~enc:(fun r -> r.dest_entity) + |> col "seq_nr" Field.int ~enc:(fun r -> r.seq_nr) + |> col "entity_id_len" Field.int ~enc:(fun r -> r.entity_id_len) + |> col "seq_nr_len" Field.int ~enc:(fun r -> r.seq_nr_len) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "mode" Field.string ~enc:(fun r -> r.mode) + |> col "offset" Field.int64 ~enc:(fun r -> r.offset) + |> col "data_hex" Field.string ~enc:(fun r -> r.data_hex) + |> col "large_file" Field.bool ~enc:(fun r -> r.large_file) + |> col "pdu_hex" Field.string ~enc:(fun r -> r.pdu_hex) |> finish)) let decode_file_data () = let rows = - match Csv.decode_file file_data_codec (trace "file_data.csv") with + match Csv.of_file file_data_codec (trace "file_data.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : file_data_row) -> @@ -849,9 +850,9 @@ let decode_file_data () = let encode_file_data () = let rows = - match Csv.decode_file file_data_codec (trace "file_data.csv") with + match Csv.of_file file_data_codec (trace "file_data.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : file_data_row) -> @@ -942,20 +943,20 @@ let nak_codec = large_file; pdu_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "pdu_type" string ~enc:(fun _ -> "nak") - |> col "source_entity" int ~enc:(fun r -> r.source_entity) - |> col "dest_entity" int ~enc:(fun r -> r.dest_entity) - |> col "seq_nr" int ~enc:(fun r -> r.seq_nr) - |> col "entity_id_len" int ~enc:(fun r -> r.entity_id_len) - |> col "seq_nr_len" int ~enc:(fun r -> r.seq_nr_len) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "mode" string ~enc:(fun r -> r.mode) - |> col "start_scope" int64 ~enc:(fun r -> r.start_scope) - |> col "end_scope" int64 ~enc:(fun r -> r.end_scope) - |> col "segments" string ~enc:(fun r -> r.segments) - |> col "large_file" bool ~enc:(fun r -> r.large_file) - |> col "pdu_hex" string ~enc:(fun r -> r.pdu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "pdu_type" Field.string ~enc:(fun _ -> "nak") + |> col "source_entity" Field.int ~enc:(fun r -> r.source_entity) + |> col "dest_entity" Field.int ~enc:(fun r -> r.dest_entity) + |> col "seq_nr" Field.int ~enc:(fun r -> r.seq_nr) + |> col "entity_id_len" Field.int ~enc:(fun r -> r.entity_id_len) + |> col "seq_nr_len" Field.int ~enc:(fun r -> r.seq_nr_len) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "mode" Field.string ~enc:(fun r -> r.mode) + |> col "start_scope" Field.int64 ~enc:(fun r -> r.start_scope) + |> col "end_scope" Field.int64 ~enc:(fun r -> r.end_scope) + |> col "segments" Field.string ~enc:(fun r -> r.segments) + |> col "large_file" Field.bool ~enc:(fun r -> r.large_file) + |> col "pdu_hex" Field.string ~enc:(fun r -> r.pdu_hex) |> finish)) let parse_segments s = @@ -970,9 +971,9 @@ let parse_segments s = let decode_nak () = let rows = - match Csv.decode_file nak_codec (trace "nak.csv") with + match Csv.of_file nak_codec (trace "nak.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : nak_row) -> @@ -1010,9 +1011,9 @@ let decode_nak () = let encode_nak () = let rows = - match Csv.decode_file nak_codec (trace "nak.csv") with + match Csv.of_file nak_codec (trace "nak.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : nak_row) -> @@ -1108,26 +1109,24 @@ let keep_alive_codec = large_file; pdu_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "source_entity" int ~enc:(fun r -> r.source_entity) - |> col "dest_entity" int ~enc:(fun r -> r.dest_entity) - |> col "seq_nr" int ~enc:(fun r -> r.seq_nr) - |> col "entity_id_len" int ~enc:(fun r -> r.entity_id_len) - |> col "seq_nr_len" int ~enc:(fun r -> r.seq_nr_len) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "mode" string ~enc:(fun r -> r.mode) - |> col "progress" int64 ~enc:(fun r -> r.progress) - |> col "large_file" bool ~enc:(fun r -> r.large_file) - |> col "pdu_hex" string ~enc:(fun r -> r.pdu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "source_entity" Field.int ~enc:(fun r -> r.source_entity) + |> col "dest_entity" Field.int ~enc:(fun r -> r.dest_entity) + |> col "seq_nr" Field.int ~enc:(fun r -> r.seq_nr) + |> col "entity_id_len" Field.int ~enc:(fun r -> r.entity_id_len) + |> col "seq_nr_len" Field.int ~enc:(fun r -> r.seq_nr_len) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "mode" Field.string ~enc:(fun r -> r.mode) + |> col "progress" Field.int64 ~enc:(fun r -> r.progress) + |> col "large_file" Field.bool ~enc:(fun r -> r.large_file) + |> col "pdu_hex" Field.string ~enc:(fun r -> r.pdu_hex) |> finish)) let decode_keep_alive () = let rows = - match - Csv.decode_file keep_alive_codec (dariol83_trace "keep_alive.csv") - with + match Csv.of_file keep_alive_codec (dariol83_trace "keep_alive.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : keep_alive_row) -> @@ -1147,11 +1146,9 @@ let decode_keep_alive () = let encode_keep_alive () = let rows = - match - Csv.decode_file keep_alive_codec (dariol83_trace "keep_alive.csv") - with + match Csv.of_file keep_alive_codec (dariol83_trace "keep_alive.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : keep_alive_row) -> @@ -1216,26 +1213,26 @@ let spacepackets_ka_codec = pdu_hex buggy_hex -> { name; progress; pdu_hex; buggy_hex }) - |> col "name" string ~enc:(fun _ -> "") - |> col "pdu_type" string ~enc:(fun _ -> "") - |> col "source_entity" int ~enc:(fun _ -> 0) - |> col "dest_entity" int ~enc:(fun _ -> 0) - |> col "seq_nr" int ~enc:(fun _ -> 0) - |> col "entity_id_len" int ~enc:(fun _ -> 0) - |> col "seq_nr_len" int ~enc:(fun _ -> 0) - |> col "direction" string ~enc:(fun _ -> "") - |> col "mode" string ~enc:(fun _ -> "") - |> col "progress" int64 ~enc:(fun _ -> 0L) - |> col "large_file" bool ~enc:(fun _ -> false) - |> col "pdu_hex" string ~enc:(fun _ -> "") - |> col "buggy_hex" string ~enc:(fun _ -> "") + |> col "name" Field.string ~enc:(fun _ -> "") + |> col "pdu_type" Field.string ~enc:(fun _ -> "") + |> col "source_entity" Field.int ~enc:(fun _ -> 0) + |> col "dest_entity" Field.int ~enc:(fun _ -> 0) + |> col "seq_nr" Field.int ~enc:(fun _ -> 0) + |> col "entity_id_len" Field.int ~enc:(fun _ -> 0) + |> col "seq_nr_len" Field.int ~enc:(fun _ -> 0) + |> col "direction" Field.string ~enc:(fun _ -> "") + |> col "mode" Field.string ~enc:(fun _ -> "") + |> col "progress" Field.int64 ~enc:(fun _ -> 0L) + |> col "large_file" Field.bool ~enc:(fun _ -> false) + |> col "pdu_hex" Field.string ~enc:(fun _ -> "") + |> col "buggy_hex" Field.string ~enc:(fun _ -> "") |> finish)) let keep_alive_spacepackets_bug () = let rows = - match Csv.decode_file spacepackets_ka_codec (trace "keep_alive.csv") with + match Csv.of_file spacepackets_ka_codec (trace "keep_alive.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : spacepackets_ka_row) -> diff --git a/ocaml-clcw/test/interop/dariol83/test.ml b/ocaml-clcw/test/interop/dariol83/test.ml index 371fcc1a23..4fd936548b 100644 --- a/ocaml-clcw/test/interop/dariol83/test.ml +++ b/ocaml-clcw/test/interop/dariol83/test.ml @@ -66,26 +66,28 @@ let vector_codec = report_value; word_hex; }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "cwt" int ~enc:(fun v -> v.cwt) - |> col "version" int ~enc:(fun v -> v.version) - |> col "status" int ~enc:(fun v -> v.status) - |> col "cop" int ~enc:(fun v -> v.cop) - |> col "vcid" int ~enc:(fun v -> v.vcid) - |> col "no_rf" int ~enc:(fun v -> if v.no_rf then 1 else 0) - |> col "no_bit_lock" int ~enc:(fun v -> if v.no_bit_lock then 1 else 0) - |> col "lockout" int ~enc:(fun v -> if v.lockout then 1 else 0) - |> col "wait" int ~enc:(fun v -> if v.wait then 1 else 0) - |> col "retransmit" int ~enc:(fun v -> if v.retransmit then 1 else 0) - |> col "farm_b" int ~enc:(fun v -> v.farm_b) - |> col "report_value" int ~enc:(fun v -> v.report_value) - |> col "word_hex" string ~enc:(fun v -> v.word_hex) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "cwt" Field.int ~enc:(fun v -> v.cwt) + |> col "version" Field.int ~enc:(fun v -> v.version) + |> col "status" Field.int ~enc:(fun v -> v.status) + |> col "cop" Field.int ~enc:(fun v -> v.cop) + |> col "vcid" Field.int ~enc:(fun v -> v.vcid) + |> col "no_rf" Field.int ~enc:(fun v -> if v.no_rf then 1 else 0) + |> col "no_bit_lock" Field.int ~enc:(fun v -> + if v.no_bit_lock then 1 else 0) + |> col "lockout" Field.int ~enc:(fun v -> if v.lockout then 1 else 0) + |> col "wait" Field.int ~enc:(fun v -> if v.wait then 1 else 0) + |> col "retransmit" Field.int ~enc:(fun v -> + if v.retransmit then 1 else 0) + |> col "farm_b" Field.int ~enc:(fun v -> v.farm_b) + |> col "report_value" Field.int ~enc:(fun v -> v.report_value) + |> col "word_hex" Field.string ~enc:(fun v -> v.word_hex) |> finish)) let parse_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse vectors.csv: %s" e + | Error e -> Alcotest.failf "failed to parse vectors.csv: %a" Csv.Error.pp e let word_of_hex hex = int_of_string ("0x" ^ hex) diff --git a/ocaml-coordinate/test/interop/proj/test.ml b/ocaml-coordinate/test/interop/proj/test.ml index 3eec37520f..767f90c8f9 100644 --- a/ocaml-coordinate/test/interop/proj/test.ml +++ b/ocaml-coordinate/test/interop/proj/test.ml @@ -36,19 +36,19 @@ let vector_codec = Row.( obj (fun name lat lon epsg easting northing -> { name; lat; lon; epsg; easting; northing }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "lat_deg" float ~enc:(fun v -> v.lat) - |> col "lon_deg" float ~enc:(fun v -> v.lon) - |> col "epsg" int ~enc:(fun v -> v.epsg) - |> col "easting_m" float ~enc:(fun v -> v.easting) - |> col "northing_m" float ~enc:(fun v -> v.northing) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "lat_deg" Field.float ~enc:(fun v -> v.lat) + |> col "lon_deg" Field.float ~enc:(fun v -> v.lon) + |> col "epsg" Field.int ~enc:(fun v -> v.epsg) + |> col "easting_m" Field.float ~enc:(fun v -> v.easting) + |> col "northing_m" Field.float ~enc:(fun v -> v.northing) |> finish)) let vectors = lazy - (match Csv.decode_file vector_codec "traces/cs2cs_utm.csv" with + (match Csv.of_file vector_codec "traces/cs2cs_utm.csv" with | Ok vs -> vs - | Error e -> Alcotest.failf "reading the cs2cs traces: %s" e) + | Error e -> Alcotest.failf "reading the cs2cs traces: %a" Csv.Error.pp e) (* Forward: geodetic -> projected, against cs2cs. *) let test_forward () = diff --git a/ocaml-cop1/test/interop/dariol83/test.ml b/ocaml-cop1/test/interop/dariol83/test.ml index 6cb87fe0a2..7028ab24df 100644 --- a/ocaml-cop1/test/interop/dariol83/test.ml +++ b/ocaml-cop1/test/interop/dariol83/test.ml @@ -72,25 +72,27 @@ let vector_codec = report_value; clcw_hex; }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "status_field" int ~enc:(fun v -> v.status_field) - |> col "cop_in_effect" int ~enc:(fun v -> v.cop_in_effect) - |> col "vcid" int ~enc:(fun v -> v.vcid) - |> col "no_rf_available" int ~enc:(fun v -> + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "status_field" Field.int ~enc:(fun v -> v.status_field) + |> col "cop_in_effect" Field.int ~enc:(fun v -> v.cop_in_effect) + |> col "vcid" Field.int ~enc:(fun v -> v.vcid) + |> col "no_rf_available" Field.int ~enc:(fun v -> if v.no_rf_available then 1 else 0) - |> col "no_bit_lock" int ~enc:(fun v -> if v.no_bit_lock then 1 else 0) - |> col "lockout" int ~enc:(fun v -> if v.lockout then 1 else 0) - |> col "wait" int ~enc:(fun v -> if v.wait then 1 else 0) - |> col "retransmit" int ~enc:(fun v -> if v.retransmit then 1 else 0) - |> col "farm_b_counter" int ~enc:(fun v -> v.farm_b_counter) - |> col "report_value" int ~enc:(fun v -> v.report_value) - |> col "clcw_hex" string ~enc:(fun v -> v.clcw_hex) + |> col "no_bit_lock" Field.int ~enc:(fun v -> + if v.no_bit_lock then 1 else 0) + |> col "lockout" Field.int ~enc:(fun v -> if v.lockout then 1 else 0) + |> col "wait" Field.int ~enc:(fun v -> if v.wait then 1 else 0) + |> col "retransmit" Field.int ~enc:(fun v -> + if v.retransmit then 1 else 0) + |> col "farm_b_counter" Field.int ~enc:(fun v -> v.farm_b_counter) + |> col "report_value" Field.int ~enc:(fun v -> v.report_value) + |> col "clcw_hex" Field.string ~enc:(fun v -> v.clcw_hex) |> finish)) let parse_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse vectors.csv: %s" e + | Error e -> Alcotest.failf "failed to parse vectors.csv: %a" Csv.Error.pp e (* --- Test: decode dariol83 bytes and check field values --- *) @@ -266,24 +268,26 @@ let farm_codec = clcw_wait = bool_of_int clcw_wait; clcw_retransmit = bool_of_int clcw_retransmit; }) - |> col "name" string ~enc:(fun v -> v.fname) - |> col "step" int ~enc:(fun v -> v.step) - |> col "frame_seq_num" int ~enc:(fun v -> v.frame_seq_num) - |> col "bypass" int ~enc:(fun v -> if v.bypass then 1 else 0) - |> col "command" string ~enc:(fun v -> v.command) - |> col "farm_state" string ~enc:(fun v -> v.farm_state) - |> col "event" string ~enc:(fun v -> v.event) - |> col "clcw_report" int ~enc:(fun v -> v.clcw_report) - |> col "clcw_lockout" int ~enc:(fun v -> if v.clcw_lockout then 1 else 0) - |> col "clcw_wait" int ~enc:(fun v -> if v.clcw_wait then 1 else 0) - |> col "clcw_retransmit" int ~enc:(fun v -> + |> col "name" Field.string ~enc:(fun v -> v.fname) + |> col "step" Field.int ~enc:(fun v -> v.step) + |> col "frame_seq_num" Field.int ~enc:(fun v -> v.frame_seq_num) + |> col "bypass" Field.int ~enc:(fun v -> if v.bypass then 1 else 0) + |> col "command" Field.string ~enc:(fun v -> v.command) + |> col "farm_state" Field.string ~enc:(fun v -> v.farm_state) + |> col "event" Field.string ~enc:(fun v -> v.event) + |> col "clcw_report" Field.int ~enc:(fun v -> v.clcw_report) + |> col "clcw_lockout" Field.int ~enc:(fun v -> + if v.clcw_lockout then 1 else 0) + |> col "clcw_wait" Field.int ~enc:(fun v -> if v.clcw_wait then 1 else 0) + |> col "clcw_retransmit" Field.int ~enc:(fun v -> if v.clcw_retransmit then 1 else 0) |> finish)) let parse_farm_vectors () = - match Csv.decode_file farm_codec (trace "farm_vectors.csv") with + match Csv.of_file farm_codec (trace "farm_vectors.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse farm_vectors.csv: %s" e + | Error e -> + Alcotest.failf "failed to parse farm_vectors.csv: %a" Csv.Error.pp e (* Group farm steps by scenario name, preserving order. *) let group_by_name steps = diff --git a/ocaml-cose/test/interop/pycose/test.ml b/ocaml-cose/test/interop/pycose/test.ml index b7a04886f8..6591c9676d 100644 --- a/ocaml-cose/test/interop/pycose/test.ml +++ b/ocaml-cose/test/interop/pycose/test.ml @@ -31,11 +31,11 @@ let header_codec = Row.( obj (fun name algorithm content_type key_id header_cbor_hex -> { name; algorithm; content_type; key_id; header_cbor_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "algorithm" string ~enc:(fun r -> r.algorithm) - |> col "content_type" string ~enc:(fun r -> r.content_type) - |> col "key_id" string ~enc:(fun r -> r.key_id) - |> col "header_cbor_hex" string ~enc:(fun r -> r.header_cbor_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "algorithm" Field.string ~enc:(fun r -> r.algorithm) + |> col "content_type" Field.string ~enc:(fun r -> r.content_type) + |> col "key_id" Field.string ~enc:(fun r -> r.key_id) + |> col "header_cbor_hex" Field.string ~enc:(fun r -> r.header_cbor_hex) |> finish)) let algorithm_of_string = function @@ -49,9 +49,9 @@ let algorithm_of_string = function let decode_headers () = let rows = - match Csv.decode_file header_codec (trace "headers.csv") with + match Csv.of_file header_codec (trace "headers.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : header_row) -> @@ -114,9 +114,9 @@ let check_header_reencode (r : header_row) = let header_reencode () = let rows = - match Csv.decode_file header_codec (trace "headers.csv") with + match Csv.of_file header_codec (trace "headers.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter check_header_reencode rows @@ -154,13 +154,15 @@ let sign1_codec = external_aad_hex; cose_sign1_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "algorithm" string ~enc:(fun r -> r.algorithm) - |> col "private_key_der_hex" string ~enc:(fun r -> r.private_key_der_hex) - |> col "public_key_der_hex" string ~enc:(fun r -> r.public_key_der_hex) - |> col "payload_hex" string ~enc:(fun r -> r.payload_hex) - |> col "external_aad_hex" string ~enc:(fun r -> r.external_aad_hex) - |> col "cose_sign1_hex" string ~enc:(fun r -> r.cose_sign1_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "algorithm" Field.string ~enc:(fun r -> r.algorithm) + |> col "private_key_der_hex" Field.string ~enc:(fun r -> + r.private_key_der_hex) + |> col "public_key_der_hex" Field.string ~enc:(fun r -> + r.public_key_der_hex) + |> col "payload_hex" Field.string ~enc:(fun r -> r.payload_hex) + |> col "external_aad_hex" Field.string ~enc:(fun r -> r.external_aad_hex) + |> col "cose_sign1_hex" Field.string ~enc:(fun r -> r.cose_sign1_hex) |> finish)) let load_public_key hex = @@ -178,9 +180,9 @@ let load_private_key hex = (** Decode pycose's COSE_Sign1 and verify with the public key. *) let decode_verify () = let rows = - match Csv.decode_file sign1_codec (trace "sign1.csv") with + match Csv.of_file sign1_codec (trace "sign1.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : sign1_row) -> @@ -280,9 +282,9 @@ let check_signed_row (r : sign1_row) = let sign_structure () = Crypto_rng_unix.use_default (); let rows = - match Csv.decode_file sign1_codec (trace "sign1.csv") with + match Csv.of_file sign1_codec (trace "sign1.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter check_signed_row rows diff --git a/ocaml-crc/test/interop/crcmod/test.ml b/ocaml-crc/test/interop/crcmod/test.ml index bb93ac4ade..dcff2880a3 100644 --- a/ocaml-crc/test/interop/crcmod/test.ml +++ b/ocaml-crc/test/interop/crcmod/test.ml @@ -26,18 +26,18 @@ let vector_codec = crc32 = int_of_hex crc32; crc32c = int_of_hex crc32c; }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "input_hex" string ~enc:(fun _ -> "") - |> col "crc16_ccitt" string ~enc:(fun _ -> "") - |> col "crc16_x25" string ~enc:(fun _ -> "") - |> col "crc32" string ~enc:(fun _ -> "") - |> col "crc32c" string ~enc:(fun _ -> "") + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "input_hex" Field.string ~enc:(fun _ -> "") + |> col "crc16_ccitt" Field.string ~enc:(fun _ -> "") + |> col "crc16_x25" Field.string ~enc:(fun _ -> "") + |> col "crc32" Field.string ~enc:(fun _ -> "") + |> col "crc32c" Field.string ~enc:(fun _ -> "") |> finish)) let parse_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e let crc16_ccitt vec () = let got = Crc.crc16_ccitt vec.input in diff --git a/ocaml-crdt/test/interop/automerge/test.ml b/ocaml-crdt/test/interop/automerge/test.ml index 8ce728a2cf..cb61c3181f 100644 --- a/ocaml-crdt/test/interop/automerge/test.ml +++ b/ocaml-crdt/test/interop/automerge/test.ml @@ -26,9 +26,9 @@ let trace path = Filename.concat "traces" path let actor replica = Crdt.Acctor.of_bytes replica let load_trace path = - match Csv.decode_file row_codec path with + match Csv.of_file row_codec path with | Ok rows -> group rows - | Error e -> Alcotest.failf "CSV %s: %s" path e + | Error e -> Alcotest.failf "CSV %s: %a" path Csv.Error.pp e let check row observed = Alcotest.(check string) (label row) row.expected observed diff --git a/ocaml-crdt/test/interop/crdts/test.ml b/ocaml-crdt/test/interop/crdts/test.ml index de8cd2e29b..17ec75c154 100644 --- a/ocaml-crdt/test/interop/crdts/test.ml +++ b/ocaml-crdt/test/interop/crdts/test.ml @@ -21,9 +21,9 @@ open Crdt_interop_trace let trace path = Filename.concat "traces" path let load_trace path = - match Csv.decode_file row_codec path with + match Csv.of_file row_codec path with | Ok rows -> group rows - | Error e -> Alcotest.failf "CSV %s: %s" path e + | Error e -> Alcotest.failf "CSV %s: %a" path Csv.Error.pp e module Int_ord = struct type t = int diff --git a/ocaml-crdt/test/support/crdt_interop_trace.ml b/ocaml-crdt/test/support/crdt_interop_trace.ml index 043b3591d1..f6c0f7ce74 100644 --- a/ocaml-crdt/test/support/crdt_interop_trace.ml +++ b/ocaml-crdt/test/support/crdt_interop_trace.ml @@ -17,12 +17,12 @@ let row_codec = Row.( obj (fun fixture step replica op arg expected -> { fixture; step; replica; op; arg; expected }) - |> col "fixture" string ~enc:(fun r -> r.fixture) - |> col "step" int ~enc:(fun r -> r.step) - |> col "replica" string ~enc:(fun r -> r.replica) - |> col "op" string ~enc:(fun r -> r.op) - |> col "arg" string ~enc:(fun r -> r.arg) - |> col "expected" string ~enc:(fun r -> r.expected) + |> col "fixture" Field.string ~enc:(fun r -> r.fixture) + |> col "step" Field.int ~enc:(fun r -> r.step) + |> col "replica" Field.string ~enc:(fun r -> r.replica) + |> col "op" Field.string ~enc:(fun r -> r.op) + |> col "arg" Field.string ~enc:(fun r -> r.arg) + |> col "expected" Field.string ~enc:(fun r -> r.expected) |> finish)) let group rows = @@ -45,8 +45,8 @@ let group rows = (fixture, rows)) let load path = - match Csv.decode_file row_codec path with + match Csv.of_file row_codec path with | Ok rows -> group rows - | Error e -> Alcotest.failf "CSV %s: %s" path e + | Error e -> Alcotest.failf "CSV %s: %a" path Csv.Error.pp e let label row = Fmt.str "%s step %d (%s)" row.fixture row.step row.op diff --git a/ocaml-csv/bench/bench.ml b/ocaml-csv/bench/bench.ml index 23951d440e..d80a8d44d5 100644 --- a/ocaml-csv/bench/bench.ml +++ b/ocaml-csv/bench/bench.ml @@ -73,10 +73,10 @@ let narrow = Csv.( Row.( obj (fun a b c d -> a + b + c + d) - |> col "c0" int ~enc:(fun _ -> 0) - |> col "c1" int ~enc:(fun _ -> 0) - |> col "c2" int ~enc:(fun _ -> 0) - |> col "c3" int ~enc:(fun _ -> 0) + |> col "c0" Field.int ~enc:(fun _ -> 0) + |> col "c1" Field.int ~enc:(fun _ -> 0) + |> col "c2" Field.int ~enc:(fun _ -> 0) + |> col "c3" Field.int ~enc:(fun _ -> 0) |> finish)) (* Every column of a [cols]-wide file. *) @@ -84,13 +84,13 @@ let wide cols = Csv.( Row.( obj List.length - |> col_block ~start:0 ~stride:1 ~count:cols int ~enc:(fun _ -> []) + |> col_block ~start:0 ~stride:1 ~count:cols Field.int ~enc:(fun _ -> []) |> finish)) let fold codec path = - match Csv.fold_file codec path (fun acc v -> acc + v) 0 with + match Csv.fold_file codec ~init:0 ~f:(fun acc v -> acc + v) path with | Ok n -> n - | Error e -> Fmt.failwith "decode failed: %s" e + | Error e -> Fmt.failwith "decode failed: %a" Csv.Error.pp e (* {1 The measurement} *) diff --git a/ocaml-csv/lib/csv.mli b/ocaml-csv/lib/csv.mli index f5f6e8cd36..4c936424d2 100644 --- a/ocaml-csv/lib/csv.mli +++ b/ocaml-csv/lib/csv.mli @@ -205,9 +205,9 @@ module Row : sig {v Row.(obj (fun a b c -> { a; b; c }) - |> col "a" string ~enc:(fun r -> r.a) - |> col "b" int ~enc:(fun r -> r.b) - |> col "c" float ~enc:(fun r -> r.c) + |> col "a" Field.string ~enc:(fun r -> r.a) + |> col "b" Field.int ~enc:(fun r -> r.b) + |> col "c" Field.float ~enc:(fun r -> r.c) |> finish) v} *) diff --git a/ocaml-did/lib/plc/test/interop/indigo/test.ml b/ocaml-did/lib/plc/test/interop/indigo/test.ml index 891cc96488..9b7f30b577 100644 --- a/ocaml-did/lib/plc/test/interop/indigo/test.ml +++ b/ocaml-did/lib/plc/test/interop/indigo/test.ml @@ -13,9 +13,9 @@ let row_codec = Csv.( Row.( obj (fun name input url -> { name; input; url }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "input" string ~enc:(fun r -> r.input) - |> col "url" string ~enc:(fun r -> r.url) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "input" Field.string ~enc:(fun r -> r.input) + |> col "url" Field.string ~enc:(fun r -> r.url) |> finish)) let url_result input = @@ -24,8 +24,8 @@ let url_result input = | Ok d -> ( match Did_plc.url_of_did d with Error _ -> "error" | Ok u -> u) let urls () = - match Csv.decode_file row_codec "traces/urls.csv" with - | Error msg -> Alcotest.failf "load CSV: %s" msg + match Csv.of_file row_codec "traces/urls.csv" with + | Error e -> Alcotest.failf "load CSV: %a" Csv.Error.pp e | Ok [] -> Alcotest.fail "empty CSV" | Ok rows -> List.iter diff --git a/ocaml-did/lib/web/test/interop/indigo/test.ml b/ocaml-did/lib/web/test/interop/indigo/test.ml index 459a46262a..3744db06b6 100644 --- a/ocaml-did/lib/web/test/interop/indigo/test.ml +++ b/ocaml-did/lib/web/test/interop/indigo/test.ml @@ -12,8 +12,8 @@ let row_codec = Csv.( Row.( obj (fun did url -> { did; url }) - |> col "did" string ~enc:(fun r -> r.did) - |> col "url" string ~enc:(fun r -> r.url) + |> col "did" Field.string ~enc:(fun r -> r.did) + |> col "url" Field.string ~enc:(fun r -> r.url) |> finish)) let checked_url did_s = @@ -25,8 +25,8 @@ let checked_url did_s = | Error (`Msg m) -> Alcotest.failf "url_of_did %S: %s" did_s m) let urls () = - match Csv.decode_file row_codec "traces/urls.csv" with - | Error msg -> Alcotest.failf "load CSV: %s" msg + match Csv.of_file row_codec "traces/urls.csv" with + | Error e -> Alcotest.failf "load CSV: %a" Csv.Error.pp e | Ok [] -> Alcotest.fail "empty CSV" | Ok rows -> List.iter diff --git a/ocaml-did/test/interop/indigo/test.ml b/ocaml-did/test/interop/indigo/test.ml index df02035124..731167caa4 100644 --- a/ocaml-did/test/interop/indigo/test.ml +++ b/ocaml-did/test/interop/indigo/test.ml @@ -14,14 +14,14 @@ let row_codec = Csv.( Row.( obj (fun name input result -> { name; input; result }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "input" string ~enc:(fun r -> r.input) - |> col "result" string ~enc:(fun r -> r.result) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "input" Field.string ~enc:(fun r -> r.input) + |> col "result" Field.string ~enc:(fun r -> r.result) |> finish)) let syntax () = - match Csv.decode_file row_codec "traces/syntax.csv" with - | Error msg -> Alcotest.failf "load CSV: %s" msg + match Csv.of_file row_codec "traces/syntax.csv" with + | Error e -> Alcotest.failf "load CSV: %a" Csv.Error.pp e | Ok rows -> List.iter (fun { name; input; result = expected } -> diff --git a/ocaml-dsp/test/interop/numpy/test.ml b/ocaml-dsp/test/interop/numpy/test.ml index 3ce42e4e0e..a107fbd84b 100644 --- a/ocaml-dsp/test/interop/numpy/test.ml +++ b/ocaml-dsp/test/interop/numpy/test.ml @@ -37,21 +37,25 @@ let vector_codec = Csv.( Row.( obj (fun name n input expected -> { name; n; input; expected }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "n" int ~enc:(fun v -> v.n) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "n" Field.int ~enc:(fun v -> v.n) |> col "input" - (map ~dec:parse_complex ~enc:(fun _ -> assert false) string) + (Field.map ~dec:parse_complex + ~enc:(fun _ -> assert false) + Field.string) ~enc:(fun v -> v.input) |> col "expected" - (map ~dec:parse_complex ~enc:(fun _ -> assert false) string) + (Field.map ~dec:parse_complex + ~enc:(fun _ -> assert false) + Field.string) ~enc:(fun v -> v.expected) |> finish)) let vectors = lazy - (match Csv.decode_file vector_codec "traces/fft.csv" with + (match Csv.of_file vector_codec "traces/fft.csv" with | Ok vs -> vs - | Error e -> Alcotest.failf "reading the numpy traces: %s" e) + | Error e -> Alcotest.failf "reading the numpy traces: %a" Csv.Error.pp e) let check_close name expected actual = Alcotest.(check int) diff --git a/ocaml-etcd/test/interop/etcd/test.ml b/ocaml-etcd/test/interop/etcd/test.ml index ab707aca83..11a68b8c35 100644 --- a/ocaml-etcd/test/interop/etcd/test.ml +++ b/ocaml-etcd/test/interop/etcd/test.ml @@ -17,13 +17,13 @@ let row_codec = Csv.( Row.( obj (fun name hex -> { name; hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "hex" string ~enc:(fun r -> r.hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "hex" Field.string ~enc:(fun r -> r.hex) |> finish)) let load_traces () = - match Csv.decode_file row_codec (trace "kv.csv") with - | Error e -> Alcotest.failf "kv.csv: %s" e + match Csv.of_file row_codec (trace "kv.csv") with + | Error e -> Alcotest.failf "kv.csv: %a" Csv.Error.pp e | Ok rows -> let tbl = Hashtbl.create 8 in List.iter (fun r -> Hashtbl.replace tbl r.name r.hex) rows; diff --git a/ocaml-fat/test/interop/mtools/test.ml b/ocaml-fat/test/interop/mtools/test.ml index a1ab54c277..47e55a15f0 100644 --- a/ocaml-fat/test/interop/mtools/test.ml +++ b/ocaml-fat/test/interop/mtools/test.ml @@ -39,15 +39,15 @@ let row_codec = Csv.( Row.( obj (fun image path content_hex -> { image; path; content_hex }) - |> col "image" string ~enc:(fun r -> r.image) - |> col "path" string ~enc:(fun r -> r.path) - |> col "content_hex" string ~enc:(fun r -> r.content_hex) + |> col "image" Field.string ~enc:(fun r -> r.image) + |> col "path" Field.string ~enc:(fun r -> r.path) + |> col "content_hex" Field.string ~enc:(fun r -> r.content_hex) |> finish)) let rows () = - match Csv.decode_file row_codec (trace "manifest.csv") with + match Csv.of_file row_codec (trace "manifest.csv") with | Ok rows -> rows - | Error msg -> Alcotest.failf "manifest.csv: %s" msg + | Error e -> Alcotest.failf "manifest.csv: %a" Csv.Error.pp e let images = [ ("fat12.img", "FAT12"); ("fat16.img", "FAT16") ] diff --git a/ocaml-fsr/test/interop/cryptolib/test.ml b/ocaml-fsr/test/interop/cryptolib/test.ml index c1a9995792..359908de73 100644 --- a/ocaml-fsr/test/interop/cryptolib/test.ml +++ b/ocaml-fsr/test/interop/cryptolib/test.ml @@ -36,20 +36,20 @@ let vector_codec = arsn_lsb; word_hex; }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "alarm" int ~enc:(fun v -> if v.alarm then 1 else 0) - |> col "bad_sn" int ~enc:(fun v -> if v.bad_sn then 1 else 0) - |> col "bad_mac" int ~enc:(fun v -> if v.bad_mac then 1 else 0) - |> col "bad_sa" int ~enc:(fun v -> if v.bad_sa then 1 else 0) - |> col "spi" int ~enc:(fun v -> v.spi) - |> col "arsn_lsb" int ~enc:(fun v -> v.arsn_lsb) - |> col "word_hex" string ~enc:(fun v -> v.word_hex) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "alarm" Field.int ~enc:(fun v -> if v.alarm then 1 else 0) + |> col "bad_sn" Field.int ~enc:(fun v -> if v.bad_sn then 1 else 0) + |> col "bad_mac" Field.int ~enc:(fun v -> if v.bad_mac then 1 else 0) + |> col "bad_sa" Field.int ~enc:(fun v -> if v.bad_sa then 1 else 0) + |> col "spi" Field.int ~enc:(fun v -> v.spi) + |> col "arsn_lsb" Field.int ~enc:(fun v -> v.arsn_lsb) + |> col "word_hex" Field.string ~enc:(fun v -> v.word_hex) |> finish)) let parse_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse vectors.csv: %s" e + | Error e -> Alcotest.failf "failed to parse vectors.csv: %a" Csv.Error.pp e let word_of_hex hex = Int32.of_string ("0x" ^ hex) diff --git a/ocaml-http/test/interop/boto3/test.ml b/ocaml-http/test/interop/boto3/test.ml index 54154a4a7a..3cba5a0882 100644 --- a/ocaml-http/test/interop/boto3/test.ml +++ b/ocaml-http/test/interop/boto3/test.ml @@ -32,15 +32,15 @@ let fixture_codec = input = bytes_of_hex input_hex; expected = bytes_of_hex expected_hex; }) - |> col "name" Csv.string ~enc:(fun r -> r.name) - |> col "input_hex" Csv.string ~enc:(fun _ -> "") - |> col "expected_hex" Csv.string ~enc:(fun _ -> "") + |> col "name" Csv.Field.string ~enc:(fun r -> r.name) + |> col "input_hex" Csv.Field.string ~enc:(fun _ -> "") + |> col "expected_hex" Csv.Field.string ~enc:(fun _ -> "") |> finish) let load_fixtures () = - match Csv.decode_file fixture_codec trace_path with + match Csv.of_file fixture_codec trace_path with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e let quote_bytes s = let buf = Buffer.create (String.length s + 2) in diff --git a/ocaml-ip/test/interop/scapy/test.ml b/ocaml-ip/test/interop/scapy/test.ml index 0dc3525682..5882e72a28 100644 --- a/ocaml-ip/test/interop/scapy/test.ml +++ b/ocaml-ip/test/interop/scapy/test.ml @@ -15,9 +15,9 @@ let trace path = Filename.concat "traces" path let of_hex = Hex.decode let rows codec file = - match Csv.decode_file codec (trace file) with + match Csv.of_file codec (trace file) with | Ok rows -> rows - | Error e -> Alcotest.failf "%s: %s" file e + | Error e -> Alcotest.failf "%s: %a" file Csv.Error.pp e (* {1 IPv4 headers} *) @@ -44,13 +44,13 @@ let v4_codec = payload_len; header = of_hex header_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "src" string ~enc:(fun r -> r.src) - |> col "dst" string ~enc:(fun r -> r.dst) - |> col "proto" int ~enc:(fun r -> r.proto) - |> col "ttl" int ~enc:(fun r -> r.ttl) - |> col "payload_len" int ~enc:(fun r -> r.payload_len) - |> col "header_hex" string ~enc:(fun _ -> "") + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "src" Field.string ~enc:(fun r -> r.src) + |> col "dst" Field.string ~enc:(fun r -> r.dst) + |> col "proto" Field.int ~enc:(fun r -> r.proto) + |> col "ttl" Field.int ~enc:(fun r -> r.ttl) + |> col "payload_len" Field.int ~enc:(fun r -> r.payload_len) + |> col "header_hex" Field.string ~enc:(fun _ -> "") |> finish)) let test_v4_headers () = @@ -104,15 +104,15 @@ let v6_codec = payload_len; header = of_hex header_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "src" string ~enc:(fun r -> r.src) - |> col "dst" string ~enc:(fun r -> r.dst) - |> col "tc" int ~enc:(fun r -> r.tc) - |> col "fl" int ~enc:(fun r -> r.fl) - |> col "hlim" int ~enc:(fun r -> r.hlim) - |> col "nh" int ~enc:(fun r -> r.nh) - |> col "payload_len" int ~enc:(fun r -> r.payload_len) - |> col "header_hex" string ~enc:(fun _ -> "") + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "src" Field.string ~enc:(fun r -> r.src) + |> col "dst" Field.string ~enc:(fun r -> r.dst) + |> col "tc" Field.int ~enc:(fun r -> r.tc) + |> col "fl" Field.int ~enc:(fun r -> r.fl) + |> col "hlim" Field.int ~enc:(fun r -> r.hlim) + |> col "nh" Field.int ~enc:(fun r -> r.nh) + |> col "payload_len" Field.int ~enc:(fun r -> r.payload_len) + |> col "header_hex" Field.string ~enc:(fun _ -> "") |> finish)) let test_v6_headers () = @@ -155,10 +155,10 @@ let chain_codec = Row.( obj (fun name datagram_hex upper_proto payload_off -> { name; datagram = of_hex datagram_hex; upper_proto; payload_off }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "datagram_hex" string ~enc:(fun _ -> "") - |> col "upper_proto" int ~enc:(fun r -> r.upper_proto) - |> col "payload_off" int ~enc:(fun r -> r.payload_off) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "datagram_hex" Field.string ~enc:(fun _ -> "") + |> col "upper_proto" Field.int ~enc:(fun r -> r.upper_proto) + |> col "payload_off" Field.int ~enc:(fun r -> r.payload_off) |> finish)) let test_v6_chains () = @@ -193,8 +193,8 @@ let csum_codec = Csv.( Row.( obj (fun name datagram_hex -> { name; datagram = of_hex datagram_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "datagram_hex" string ~enc:(fun _ -> "") + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "datagram_hex" Field.string ~enc:(fun _ -> "") |> finish)) let test_v6_pseudoheader () = diff --git a/ocaml-ipam/test/interop/moby/test.ml b/ocaml-ipam/test/interop/moby/test.ml index c826e9ed41..c0fbba67b7 100644 --- a/ocaml-ipam/test/interop/moby/test.ml +++ b/ocaml-ipam/test/interop/moby/test.ml @@ -24,12 +24,12 @@ let row_codec = Row.( obj (fun _step op space pool arg result -> { op; space; pool; arg; result }) - |> col "step" int ~enc:(fun _ -> 0) - |> col "op" string ~enc:(fun r -> r.op) - |> col "space" string ~enc:(fun r -> r.space) ~dec_absent:"" - |> col "pool" string ~enc:(fun r -> r.pool) ~dec_absent:"" - |> col "arg" string ~enc:(fun r -> r.arg) ~dec_absent:"" - |> col "result" string ~enc:(fun r -> r.result) ~dec_absent:"" + |> col "step" Field.int ~enc:(fun _ -> 0) + |> col "op" Field.string ~enc:(fun r -> r.op) + |> col "space" Field.string ~enc:(fun r -> r.space) ~dec_absent:"" + |> col "pool" Field.string ~enc:(fun r -> r.pool) ~dec_absent:"" + |> col "arg" Field.string ~enc:(fun r -> r.arg) ~dec_absent:"" + |> col "result" Field.string ~enc:(fun r -> r.result) ~dec_absent:"" |> finish)) let prefix = Ipaddr.Prefix.of_string_exn @@ -45,9 +45,9 @@ let ok = function let replay () = let rows = - match Csv.decode_file row_codec (trace "operations.csv") with + match Csv.of_file row_codec (trace "operations.csv") with | Ok rows -> rows - | Error msg -> Alcotest.failf "reading trace: %s" msg + | Error e -> Alcotest.failf "reading trace: %a" Csv.Error.pp e in (* The allocated pool CIDR is the cross-implementation handle for a pool. *) let pools : (string, Ipam.pool_id) Hashtbl.t = Hashtbl.create 8 in diff --git a/ocaml-latlon/test/interop/haversine/test.ml b/ocaml-latlon/test/interop/haversine/test.ml index 6b72fad4de..738ed818d6 100644 --- a/ocaml-latlon/test/interop/haversine/test.ml +++ b/ocaml-latlon/test/interop/haversine/test.ml @@ -10,9 +10,9 @@ let trace path = Filename.concat "traces" path let load codec path = - match Csv.decode_file codec (trace path) with + match Csv.of_file codec (trace path) with | Ok rows -> rows - | Error msg -> Alcotest.failf "%s: %s" path msg + | Error e -> Alcotest.failf "%s: %a" path Csv.Error.pp e (* {1 Distance} *) @@ -30,12 +30,12 @@ let distance_codec = Row.( obj (fun name lat0 lon0 lat1 lon1 km -> { name; lat0; lon0; lat1; lon1; km }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "lat0" float ~enc:(fun r -> r.lat0) - |> col "lon0" float ~enc:(fun r -> r.lon0) - |> col "lat1" float ~enc:(fun r -> r.lat1) - |> col "lon1" float ~enc:(fun r -> r.lon1) - |> col "km" float ~enc:(fun r -> r.km) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "lat0" Field.float ~enc:(fun r -> r.lat0) + |> col "lon0" Field.float ~enc:(fun r -> r.lon0) + |> col "lat1" Field.float ~enc:(fun r -> r.lat1) + |> col "lon1" Field.float ~enc:(fun r -> r.lon1) + |> col "km" Field.float ~enc:(fun r -> r.km) |> finish)) (* Both are doubles running the same formula, so they agree to rounding: a part diff --git a/ocaml-latlon/test/interop/s2/test.ml b/ocaml-latlon/test/interop/s2/test.ml index 6fc727a455..be59acb8a4 100644 --- a/ocaml-latlon/test/interop/s2/test.ml +++ b/ocaml-latlon/test/interop/s2/test.ml @@ -15,9 +15,9 @@ let trace path = Filename.concat "traces" path let load codec path = - match Csv.decode_file codec (trace path) with + match Csv.of_file codec (trace path) with | Ok rows -> rows - | Error msg -> Alcotest.failf "%s: %s" path msg + | Error e -> Alcotest.failf "%s: %a" path Csv.Error.pp e (* {1 The disc bounding box} *) @@ -51,16 +51,16 @@ let cap_codec = inverted; full; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "lat" float ~enc:(fun r -> r.lat) - |> col "lon" float ~enc:(fun r -> r.lon) - |> col "radius_km" float ~enc:(fun r -> r.radius_km) - |> col "lat_lo" float ~enc:(fun r -> r.lat_lo) - |> col "lng_lo" float ~enc:(fun r -> r.lng_lo) - |> col "lat_hi" float ~enc:(fun r -> r.lat_hi) - |> col "lng_hi" float ~enc:(fun r -> r.lng_hi) - |> col "inverted" bool ~enc:(fun r -> r.inverted) - |> col "full" bool ~enc:(fun r -> r.full) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "lat" Field.float ~enc:(fun r -> r.lat) + |> col "lon" Field.float ~enc:(fun r -> r.lon) + |> col "radius_km" Field.float ~enc:(fun r -> r.radius_km) + |> col "lat_lo" Field.float ~enc:(fun r -> r.lat_lo) + |> col "lng_lo" Field.float ~enc:(fun r -> r.lng_lo) + |> col "lat_hi" Field.float ~enc:(fun r -> r.lat_hi) + |> col "lng_hi" Field.float ~enc:(fun r -> r.lng_hi) + |> col "inverted" Field.bool ~enc:(fun r -> r.inverted) + |> col "full" Field.bool ~enc:(fun r -> r.full) |> finish)) (* Our boxes carry a nanodegree of margin, so they must contain S2's rectangle diff --git a/ocaml-ltp/test/interop/ion/test.ml b/ocaml-ltp/test/interop/ion/test.ml index a33209d591..6277a3d54c 100644 --- a/ocaml-ltp/test/interop/ion/test.ml +++ b/ocaml-ltp/test/interop/ion/test.ml @@ -23,16 +23,16 @@ let vector_codec = Row.( obj (fun name value length encoded_hex -> { name; value; length; encoded_hex }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "value" int64 ~enc:(fun v -> v.value) - |> col "length" int ~enc:(fun v -> v.length) - |> col "encoded_hex" string ~enc:(fun v -> v.encoded_hex) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "value" Field.int64 ~enc:(fun v -> v.value) + |> col "length" Field.int ~enc:(fun v -> v.length) + |> col "encoded_hex" Field.string ~enc:(fun v -> v.encoded_hex) |> finish)) let parse_vectors () = - match Csv.decode_file vector_codec (trace "sdnv.csv") with + match Csv.of_file vector_codec (trace "sdnv.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse sdnv.csv: %s" e + | Error e -> Alcotest.failf "failed to parse sdnv.csv: %a" Csv.Error.pp e (* --- Test: encode matches ION --- *) diff --git a/ocaml-merge3/test/interop/git/test.ml b/ocaml-merge3/test/interop/git/test.ml index b7c154f176..ee0fd3ee0c 100644 --- a/ocaml-merge3/test/interop/git/test.ml +++ b/ocaml-merge3/test/interop/git/test.ml @@ -33,18 +33,18 @@ let case_codec = exit_code; merged = Hex.decode merged_hex; }) - |> col "name" string ~enc:(fun _ -> assert false) - |> col "base_hex" string ~enc:(fun _ -> assert false) - |> col "ours_hex" string ~enc:(fun _ -> assert false) - |> col "theirs_hex" string ~enc:(fun _ -> assert false) - |> col "exit_code" int ~enc:(fun _ -> assert false) - |> col "merged_hex" string ~enc:(fun _ -> assert false) + |> col "name" Field.string ~enc:(fun _ -> assert false) + |> col "base_hex" Field.string ~enc:(fun _ -> assert false) + |> col "ours_hex" Field.string ~enc:(fun _ -> assert false) + |> col "theirs_hex" Field.string ~enc:(fun _ -> assert false) + |> col "exit_code" Field.int ~enc:(fun _ -> assert false) + |> col "merged_hex" Field.string ~enc:(fun _ -> assert false) |> finish)) let parse_cases () = - match Csv.decode_file case_codec (trace "cases.csv") with + match Csv.of_file case_codec (trace "cases.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "cases.csv: %s" e + | Error e -> Alcotest.failf "cases.csv: %a" Csv.Error.pp e let check_case row () = let chunks = diff --git a/ocaml-mst/test/interop/atrium/test.ml b/ocaml-mst/test/interop/atrium/test.ml index cfab5fc4c7..e70ff360e2 100644 --- a/ocaml-mst/test/interop/atrium/test.ml +++ b/ocaml-mst/test/interop/atrium/test.ml @@ -78,20 +78,20 @@ let row_codec = Row.( obj (fun fixture step op arg expected_cid -> { fixture; step; op; arg; expected_cid }) - |> col "fixture" string ~enc:(fun r -> r.fixture) - |> col "step" int ~enc:(fun r -> r.step) - |> col "op" string ~enc:(fun r -> r.op) - |> col "arg" string ~enc:(fun r -> r.arg) - |> col "expected_cid" string ~enc:(fun r -> r.expected_cid) + |> col "fixture" Field.string ~enc:(fun r -> r.fixture) + |> col "step" Field.int ~enc:(fun r -> r.step) + |> col "op" Field.string ~enc:(fun r -> r.op) + |> col "arg" Field.string ~enc:(fun r -> r.arg) + |> col "expected_cid" Field.string ~enc:(fun r -> r.expected_cid) |> finish)) type op = Add of string | Remove of string | Expect of Atp.Cid.t let load_operations () = let rows = - match Csv.decode_file row_codec (trace "operations.csv") with + match Csv.of_file row_codec (trace "operations.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e in let groups : (string, (int * op) list ref) Hashtbl.t = Hashtbl.create 8 in let order : string list ref = ref [] in diff --git a/ocaml-mst/test/interop/indigo/test.ml b/ocaml-mst/test/interop/indigo/test.ml index 9873f43821..1597c7683e 100644 --- a/ocaml-mst/test/interop/indigo/test.ml +++ b/ocaml-mst/test/interop/indigo/test.ml @@ -79,11 +79,11 @@ let row_codec = Row.( obj (fun fixture step op arg expected_cid -> { fixture; step; op; arg; expected_cid }) - |> col "fixture" string ~enc:(fun r -> r.fixture) - |> col "step" int ~enc:(fun r -> r.step) - |> col "op" string ~enc:(fun r -> r.op) - |> col "arg" string ~enc:(fun r -> r.arg) - |> col "expected_cid" string ~enc:(fun r -> r.expected_cid) + |> col "fixture" Field.string ~enc:(fun r -> r.fixture) + |> col "step" Field.int ~enc:(fun r -> r.step) + |> col "op" Field.string ~enc:(fun r -> r.op) + |> col "arg" Field.string ~enc:(fun r -> r.arg) + |> col "expected_cid" Field.string ~enc:(fun r -> r.expected_cid) |> finish)) (* ---------- operations.csv ---------- *) @@ -92,9 +92,9 @@ type op = Add of string | Remove of string | Expect of Atp.Cid.t let load_operations () = let rows = - match Csv.decode_file row_codec (trace "operations.csv") with + match Csv.of_file row_codec (trace "operations.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e in let groups : (string, (int * op) list ref) Hashtbl.t = Hashtbl.create 8 in let order : string list ref = ref [] in diff --git a/ocaml-ocm/test/interop/orekit/test.ml b/ocaml-ocm/test/interop/orekit/test.ml index c5a770625a..c4bf21fc2e 100644 --- a/ocaml-ocm/test/interop/orekit/test.ml +++ b/ocaml-ocm/test/interop/orekit/test.ml @@ -87,35 +87,36 @@ let index_codec = rcs; solar_rad_coeff; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "filename" string ~enc:(fun r -> r.filename) - |> col "object_name" string ~enc:(fun r -> r.object_name) - |> col "object_designator" string ~enc:(fun r -> r.object_designator) - |> col "international_designator" string ~enc:(fun r -> + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "filename" Field.string ~enc:(fun r -> r.filename) + |> col "object_name" Field.string ~enc:(fun r -> r.object_name) + |> col "object_designator" Field.string ~enc:(fun r -> + r.object_designator) + |> col "international_designator" Field.string ~enc:(fun r -> r.international_designator) - |> col "catalog_name" string ~enc:(fun r -> r.catalog_name) - |> col "epoch_tzero" string ~enc:(fun r -> r.epoch_tzero) - |> col "start_time" string ~enc:(fun r -> r.start_time) - |> col "stop_time" string ~enc:(fun r -> r.stop_time) - |> col "traj_ref_frame" string ~enc:(fun r -> r.traj_ref_frame) - |> col "traj_type" string ~enc:(fun r -> r.traj_type) - |> col "num_states" int ~enc:(fun r -> r.num_states) - |> col "sv0_epoch" string ~enc:(fun r -> r.sv0_epoch) - |> col "sv0_x" float ~enc:(fun r -> r.sv0_x) - |> col "sv0_y" float ~enc:(fun r -> r.sv0_y) - |> col "sv0_z" float ~enc:(fun r -> r.sv0_z) - |> col "sv0_vx" float ~enc:(fun r -> r.sv0_vx) - |> col "sv0_vy" float ~enc:(fun r -> r.sv0_vy) - |> col "sv0_vz" float ~enc:(fun r -> r.sv0_vz) - |> col "wet_mass" string ~enc:(fun r -> r.wet_mass) - |> col "rcs" string ~enc:(fun r -> r.rcs) - |> col "solar_rad_coeff" string ~enc:(fun r -> r.solar_rad_coeff) + |> col "catalog_name" Field.string ~enc:(fun r -> r.catalog_name) + |> col "epoch_tzero" Field.string ~enc:(fun r -> r.epoch_tzero) + |> col "start_time" Field.string ~enc:(fun r -> r.start_time) + |> col "stop_time" Field.string ~enc:(fun r -> r.stop_time) + |> col "traj_ref_frame" Field.string ~enc:(fun r -> r.traj_ref_frame) + |> col "traj_type" Field.string ~enc:(fun r -> r.traj_type) + |> col "num_states" Field.int ~enc:(fun r -> r.num_states) + |> col "sv0_epoch" Field.string ~enc:(fun r -> r.sv0_epoch) + |> col "sv0_x" Field.float ~enc:(fun r -> r.sv0_x) + |> col "sv0_y" Field.float ~enc:(fun r -> r.sv0_y) + |> col "sv0_z" Field.float ~enc:(fun r -> r.sv0_z) + |> col "sv0_vx" Field.float ~enc:(fun r -> r.sv0_vx) + |> col "sv0_vy" Field.float ~enc:(fun r -> r.sv0_vy) + |> col "sv0_vz" Field.float ~enc:(fun r -> r.sv0_vz) + |> col "wet_mass" Field.string ~enc:(fun r -> r.wet_mass) + |> col "rcs" Field.string ~enc:(fun r -> r.rcs) + |> col "solar_rad_coeff" Field.string ~enc:(fun r -> r.solar_rad_coeff) |> finish)) let parse_index () = - match Csv.decode_file index_codec (trace "index.csv") with + match Csv.of_file index_codec (trace "index.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "failed to parse index.csv: %s" e + | Error e -> Alcotest.failf "failed to parse index.csv: %a" Csv.Error.pp e (* --- Helpers --- *) diff --git a/ocaml-oem/test/interop/orekit/test.ml b/ocaml-oem/test/interop/orekit/test.ml index 0bf319c6ce..fbd7dc6200 100644 --- a/ocaml-oem/test/interop/orekit/test.ml +++ b/ocaml-oem/test/interop/orekit/test.ml @@ -61,21 +61,21 @@ let row_codec = vys; vzs; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "file" string ~enc:(fun r -> r.file) - |> col "object_name" string ~enc:(fun r -> r.object_name) - |> col "object_id" string ~enc:(fun r -> r.object_id) - |> col "center_name" string ~enc:(fun r -> r.center_name) - |> col "ref_frame" string ~enc:(fun r -> r.ref_frame) - |> col "time_system" string ~enc:(fun r -> r.time_system) - |> col "num_states" int ~enc:(fun r -> r.num_states) - |> col "epochs" string ~enc:(fun r -> r.epochs) - |> col "xs" string ~enc:(fun r -> r.xs) - |> col "ys" string ~enc:(fun r -> r.ys) - |> col "zs" string ~enc:(fun r -> r.zs) - |> col "vxs" string ~enc:(fun r -> r.vxs) - |> col "vys" string ~enc:(fun r -> r.vys) - |> col "vzs" string ~enc:(fun r -> r.vzs) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "file" Field.string ~enc:(fun r -> r.file) + |> col "object_name" Field.string ~enc:(fun r -> r.object_name) + |> col "object_id" Field.string ~enc:(fun r -> r.object_id) + |> col "center_name" Field.string ~enc:(fun r -> r.center_name) + |> col "ref_frame" Field.string ~enc:(fun r -> r.ref_frame) + |> col "time_system" Field.string ~enc:(fun r -> r.time_system) + |> col "num_states" Field.int ~enc:(fun r -> r.num_states) + |> col "epochs" Field.string ~enc:(fun r -> r.epochs) + |> col "xs" Field.string ~enc:(fun r -> r.xs) + |> col "ys" Field.string ~enc:(fun r -> r.ys) + |> col "zs" Field.string ~enc:(fun r -> r.zs) + |> col "vxs" Field.string ~enc:(fun r -> r.vxs) + |> col "vys" Field.string ~enc:(fun r -> r.vys) + |> col "vzs" Field.string ~enc:(fun r -> r.vzs) |> finish)) let split_semicolons s = String.split_on_char ';' s @@ -95,9 +95,9 @@ let check_float ~name expected actual = let parse () = let rows = - match Csv.decode_file row_codec (trace "index.csv") with + match Csv.of_file row_codec (trace "index.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e in List.iter (fun (r : row) -> diff --git a/ocaml-opm/test/interop/orekit/test.ml b/ocaml-opm/test/interop/orekit/test.ml index 227185c330..b35425c657 100644 --- a/ocaml-opm/test/interop/orekit/test.ml +++ b/ocaml-opm/test/interop/orekit/test.ml @@ -58,20 +58,20 @@ let row_codec = y_dot; z_dot; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "file" string ~enc:(fun r -> r.file) - |> col "object_name" string ~enc:(fun r -> r.object_name) - |> col "object_id" string ~enc:(fun r -> r.object_id) - |> col "center_name" string ~enc:(fun r -> r.center_name) - |> col "ref_frame" string ~enc:(fun r -> r.ref_frame) - |> col "time_system" string ~enc:(fun r -> r.time_system) - |> col "epoch" string ~enc:(fun r -> r.epoch) - |> col "x" float ~enc:(fun r -> r.x) - |> col "y" float ~enc:(fun r -> r.y) - |> col "z" float ~enc:(fun r -> r.z) - |> col "x_dot" float ~enc:(fun r -> r.x_dot) - |> col "y_dot" float ~enc:(fun r -> r.y_dot) - |> col "z_dot" float ~enc:(fun r -> r.z_dot) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "file" Field.string ~enc:(fun r -> r.file) + |> col "object_name" Field.string ~enc:(fun r -> r.object_name) + |> col "object_id" Field.string ~enc:(fun r -> r.object_id) + |> col "center_name" Field.string ~enc:(fun r -> r.center_name) + |> col "ref_frame" Field.string ~enc:(fun r -> r.ref_frame) + |> col "time_system" Field.string ~enc:(fun r -> r.time_system) + |> col "epoch" Field.string ~enc:(fun r -> r.epoch) + |> col "x" Field.float ~enc:(fun r -> r.x) + |> col "y" Field.float ~enc:(fun r -> r.y) + |> col "z" Field.float ~enc:(fun r -> r.z) + |> col "x_dot" Field.float ~enc:(fun r -> r.x_dot) + |> col "y_dot" Field.float ~enc:(fun r -> r.y_dot) + |> col "z_dot" Field.float ~enc:(fun r -> r.z_dot) |> finish)) let epsilon = 1e-6 @@ -85,9 +85,9 @@ let check_float ~name expected actual = let parse () = let rows = - match Csv.decode_file row_codec (trace "index.csv") with + match Csv.of_file row_codec (trace "index.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e in List.iter (fun (r : row) -> diff --git a/ocaml-passwd/test/interop/runc/test.ml b/ocaml-passwd/test/interop/runc/test.ml index 0ede4474bb..9e2a7cdc91 100644 --- a/ocaml-passwd/test/interop/runc/test.ml +++ b/ocaml-passwd/test/interop/runc/test.ml @@ -32,12 +32,12 @@ let row_codec = Row.( obj (fun fixture spec error uid gid sgids -> { fixture; spec; error; uid; gid; sgids }) - |> col "fixture" string ~enc:(fun r -> r.fixture) - |> col "spec" string ~enc:(fun r -> r.spec) ~dec_absent:"" - |> col "error" bool ~enc:(fun r -> r.error) - |> col "uid" string ~enc:(fun r -> r.uid) ~dec_absent:"" - |> col "gid" string ~enc:(fun r -> r.gid) ~dec_absent:"" - |> col "sgids" string ~enc:(fun r -> r.sgids) ~dec_absent:"" + |> col "fixture" Field.string ~enc:(fun r -> r.fixture) + |> col "spec" Field.string ~enc:(fun r -> r.spec) ~dec_absent:"" + |> col "error" Field.bool ~enc:(fun r -> r.error) + |> col "uid" Field.string ~enc:(fun r -> r.uid) ~dec_absent:"" + |> col "gid" Field.string ~enc:(fun r -> r.gid) ~dec_absent:"" + |> col "sgids" Field.string ~enc:(fun r -> r.sgids) ~dec_absent:"" |> finish)) let read_file path = In_channel.with_open_bin path In_channel.input_all @@ -60,9 +60,9 @@ let ints s = let test_resolve () = let rows = - match Csv.decode_file row_codec (trace "resolve.csv") with + match Csv.of_file row_codec (trace "resolve.csv") with | Ok rows -> rows - | Error msg -> Alcotest.failf "reading trace: %s" msg + | Error e -> Alcotest.failf "reading trace: %a" Csv.Error.pp e in List.iter (fun r -> diff --git a/ocaml-prometheus/test/interop/prometheus_client/test.ml b/ocaml-prometheus/test/interop/prometheus_client/test.ml index cab4e19f91..78438f7137 100644 --- a/ocaml-prometheus/test/interop/prometheus_client/test.ml +++ b/ocaml-prometheus/test/interop/prometheus_client/test.ml @@ -41,15 +41,15 @@ type row = { name : string; labels : string; value : float } let row_codec = Csv.Row.( obj (fun name labels value -> { name; labels; value }) - |> col "name" Csv.string ~enc:(fun r -> r.name) - |> col "labels" Csv.string ~enc:(fun r -> r.labels) - |> col "value" Csv.float ~enc:(fun r -> r.value) + |> col "name" Csv.Field.string ~enc:(fun r -> r.name) + |> col "labels" Csv.Field.string ~enc:(fun r -> r.labels) + |> col "value" Csv.Field.float ~enc:(fun r -> r.value) |> finish) (* The reference samples, read from the CSV trace via nox-csv. *) let expected () = - match Csv.decode_file row_codec (trace "samples.csv") with - | Error msg -> Alcotest.failf "decoding samples.csv: %s" msg + match Csv.of_file row_codec (trace "samples.csv") with + | Error e -> Alcotest.failf "decoding samples.csv: %a" Csv.Error.pp e | Ok rows -> List.map (fun r -> (Fmt.str "%s{%s}" r.name r.labels, r.value)) rows |> List.sort (fun (a, _) (b, _) -> String.compare a b) diff --git a/ocaml-pus/test/interop/spacepackets/test.ml b/ocaml-pus/test/interop/spacepackets/test.ml index 92931f0880..3d5824b691 100644 --- a/ocaml-pus/test/interop/spacepackets/test.ml +++ b/ocaml-pus/test/interop/spacepackets/test.ml @@ -48,16 +48,16 @@ let packet_codec = time_hex; packet_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "apid" int ~enc:(fun r -> r.apid) - |> col "seq_count" int ~enc:(fun r -> r.seq_count) - |> col "service" int ~enc:(fun r -> r.service) - |> col "subservice" int ~enc:(fun r -> r.subservice) - |> col "ack_flags" int ~enc:(fun r -> r.ack_flags) - |> col "source_dest_id" int ~enc:(fun r -> r.source_dest_id) - |> col "time_hex" string ~enc:(fun r -> r.time_hex) - |> col "packet_hex" string ~enc:(fun r -> r.packet_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "apid" Field.int ~enc:(fun r -> r.apid) + |> col "seq_count" Field.int ~enc:(fun r -> r.seq_count) + |> col "service" Field.int ~enc:(fun r -> r.service) + |> col "subservice" Field.int ~enc:(fun r -> r.subservice) + |> col "ack_flags" Field.int ~enc:(fun r -> r.ack_flags) + |> col "source_dest_id" Field.int ~enc:(fun r -> r.source_dest_id) + |> col "time_hex" Field.string ~enc:(fun r -> r.time_hex) + |> col "packet_hex" Field.string ~enc:(fun r -> r.packet_hex) |> finish)) (* {1 Helpers} *) @@ -85,9 +85,9 @@ let hex_of_string s = let decode_reference_packets () = let rows = - match Csv.decode_file packet_codec (trace "packets.csv") with + match Csv.of_file packet_codec (trace "packets.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : packet_row) -> @@ -111,9 +111,9 @@ let decode_reference_packets () = mirrors a decode mistake) cannot catch. *) let decode_encode_roundtrip_matches_reference () = let rows = - match Csv.decode_file packet_codec (trace "packets.csv") with + match Csv.of_file packet_codec (trace "packets.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : packet_row) -> diff --git a/ocaml-reed-solomon/test/interop/reedsolo/test.ml b/ocaml-reed-solomon/test/interop/reedsolo/test.ml index c72f7c88a1..1f52766111 100644 --- a/ocaml-reed-solomon/test/interop/reedsolo/test.ml +++ b/ocaml-reed-solomon/test/interop/reedsolo/test.ml @@ -17,16 +17,16 @@ let vector_codec = data = bytes_of_hex data_hex; expected_codeword = bytes_of_hex codeword_hex; }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "data_hex" string ~enc:(fun v -> Bytes.to_string v.data) - |> col "codeword_hex" string ~enc:(fun v -> + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "data_hex" Field.string ~enc:(fun v -> Bytes.to_string v.data) + |> col "codeword_hex" Field.string ~enc:(fun v -> Bytes.to_string v.expected_codeword) |> finish)) let parse_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e let encode vec () = let cfg = Reed_solomon.ccsds in diff --git a/ocaml-rice/test/interop/libaec/test.ml b/ocaml-rice/test/interop/libaec/test.ml index c246d8bd78..dda7291a51 100644 --- a/ocaml-rice/test/interop/libaec/test.ml +++ b/ocaml-rice/test/interop/libaec/test.ml @@ -30,17 +30,18 @@ let vector_codec = input = bytes_of_hex input_hex; compressed = bytes_of_hex compressed_hex; }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "block_size" int ~enc:(fun v -> v.block_size) - |> col "bits_per_sample" int ~enc:(fun v -> v.bits_per_sample) - |> col "input_hex" string ~enc:(fun v -> hex_of_bytes v.input) - |> col "compressed_hex" string ~enc:(fun v -> hex_of_bytes v.compressed) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "block_size" Field.int ~enc:(fun v -> v.block_size) + |> col "bits_per_sample" Field.int ~enc:(fun v -> v.bits_per_sample) + |> col "input_hex" Field.string ~enc:(fun v -> hex_of_bytes v.input) + |> col "compressed_hex" Field.string ~enc:(fun v -> + hex_of_bytes v.compressed) |> finish)) let load_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e let compress vec () = let cfg = diff --git a/ocaml-s3/test/interop/boto3/test.ml b/ocaml-s3/test/interop/boto3/test.ml index 9054cb65cf..23ba993956 100644 --- a/ocaml-s3/test/interop/boto3/test.ml +++ b/ocaml-s3/test/interop/boto3/test.ml @@ -43,16 +43,16 @@ let fixture_codec = authorization; amz_date; }) - |> col "name" Csv.string ~enc:(fun r -> r.name) - |> col "method" Csv.string ~enc:(fun r -> r.method_) - |> col "path" Csv.string ~enc:(fun r -> r.path) - |> col "query" Csv.string ~enc:(fun r -> r.query) - |> col "payload_hex" Csv.string ~enc:(fun r -> r.payload_hex) - |> col "service" Csv.string ~enc:(fun r -> r.service) - |> col "region" Csv.string ~enc:(fun r -> r.region) - |> col "host" Csv.string ~enc:(fun r -> r.host) - |> col "authorization" Csv.string ~enc:(fun r -> r.authorization) - |> col "amz_date" Csv.string ~enc:(fun r -> r.amz_date) + |> col "name" Csv.Field.string ~enc:(fun r -> r.name) + |> col "method" Csv.Field.string ~enc:(fun r -> r.method_) + |> col "path" Csv.Field.string ~enc:(fun r -> r.path) + |> col "query" Csv.Field.string ~enc:(fun r -> r.query) + |> col "payload_hex" Csv.Field.string ~enc:(fun r -> r.payload_hex) + |> col "service" Csv.Field.string ~enc:(fun r -> r.service) + |> col "region" Csv.Field.string ~enc:(fun r -> r.region) + |> col "host" Csv.Field.string ~enc:(fun r -> r.host) + |> col "authorization" Csv.Field.string ~enc:(fun r -> r.authorization) + |> col "amz_date" Csv.Field.string ~enc:(fun r -> r.amz_date) |> finish) let parse_query = function @@ -122,8 +122,8 @@ let check_fixture (f : fixture) () = let suite () = let path = Filename.concat "traces" "signatures.csv" in - match Csv.decode_file fixture_codec path with - | Error e -> Alcotest.failf "failed to read fixtures: %s" e + match Csv.of_file fixture_codec path with + | Error e -> Alcotest.failf "failed to read fixtures: %a" Csv.Error.pp e | Ok rows -> ( "boto3", List.map diff --git a/ocaml-scc/test/interop/dariol83/test.ml b/ocaml-scc/test/interop/dariol83/test.ml index 96e2e93871..ce8444c47c 100644 --- a/ocaml-scc/test/interop/dariol83/test.ml +++ b/ocaml-scc/test/interop/dariol83/test.ml @@ -21,15 +21,15 @@ let cltu_codec = Csv.( Row.( obj (fun name tc_frame_hex cltu_hex -> { name; tc_frame_hex; cltu_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "tc_frame_hex" string ~enc:(fun r -> r.tc_frame_hex) - |> col "cltu_hex" string ~enc:(fun r -> r.cltu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "tc_frame_hex" Field.string ~enc:(fun r -> r.tc_frame_hex) + |> col "cltu_hex" Field.string ~enc:(fun r -> r.cltu_hex) |> finish)) let parse_cltu_rows () = - match Csv.decode_file cltu_codec (trace "cltu.csv") with + match Csv.of_file cltu_codec (trace "cltu.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "failed to parse cltu.csv: %s" e + | Error e -> Alcotest.failf "failed to parse cltu.csv: %a" Csv.Error.pp e let cltu_encode (r : cltu_row) () = let tc_frame = bytes_of_hex r.tc_frame_hex in @@ -90,15 +90,16 @@ let rand_codec = Row.( obj (fun name input_hex randomized_hex -> { name; input_hex; randomized_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "input_hex" string ~enc:(fun r -> r.input_hex) - |> col "randomized_hex" string ~enc:(fun r -> r.randomized_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "input_hex" Field.string ~enc:(fun r -> r.input_hex) + |> col "randomized_hex" Field.string ~enc:(fun r -> r.randomized_hex) |> finish)) let parse_rand_rows () = - match Csv.decode_file rand_codec (trace "randomizer.csv") with + match Csv.of_file rand_codec (trace "randomizer.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "failed to parse randomizer.csv: %s" e + | Error e -> + Alcotest.failf "failed to parse randomizer.csv: %a" Csv.Error.pp e let randomize (r : rand_row) () = let input = bytes_of_hex r.input_hex in @@ -144,15 +145,16 @@ let rs_codec = Csv.( Row.( obj (fun name data_hex codeword_hex -> { name; data_hex; codeword_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "data_hex" string ~enc:(fun r -> r.data_hex) - |> col "codeword_hex" string ~enc:(fun r -> r.codeword_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "data_hex" Field.string ~enc:(fun r -> r.data_hex) + |> col "codeword_hex" Field.string ~enc:(fun r -> r.codeword_hex) |> finish)) let parse_rs_rows () = - match Csv.decode_file rs_codec (trace "reed_solomon.csv") with + match Csv.of_file rs_codec (trace "reed_solomon.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "failed to parse reed_solomon.csv: %s" e + | Error e -> + Alcotest.failf "failed to parse reed_solomon.csv: %a" Csv.Error.pp e let rs_encode (r : rs_row) () = let data = bytes_of_hex r.data_hex in diff --git a/ocaml-sdls/test/interop/cryptolib/test.ml b/ocaml-sdls/test/interop/cryptolib/test.ml index 9c209c22b3..5982b79888 100644 --- a/ocaml-sdls/test/interop/cryptolib/test.ml +++ b/ocaml-sdls/test/interop/cryptolib/test.ml @@ -73,23 +73,23 @@ let vector_codec = input_hex; secured_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "mode" string ~enc:(fun r -> r.mode) - |> col "spi" int ~enc:(fun r -> r.spi) - |> col "ekid" int ~enc:(fun r -> r.ekid) - |> col "ecs" int ~enc:(fun r -> r.ecs) - |> col "iv_len" int ~enc:(fun r -> r.iv_len) - |> col "mac_len" int ~enc:(fun r -> r.mac_len) - |> col "has_seg_hdr" int ~enc:(fun r -> r.has_seg_hdr) - |> col "key_hex" string ~enc:(fun r -> r.key_hex) - |> col "input_hex" string ~enc:(fun r -> r.input_hex) - |> col "secured_hex" string ~enc:(fun r -> r.secured_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "mode" Field.string ~enc:(fun r -> r.mode) + |> col "spi" Field.int ~enc:(fun r -> r.spi) + |> col "ekid" Field.int ~enc:(fun r -> r.ekid) + |> col "ecs" Field.int ~enc:(fun r -> r.ecs) + |> col "iv_len" Field.int ~enc:(fun r -> r.iv_len) + |> col "mac_len" Field.int ~enc:(fun r -> r.mac_len) + |> col "has_seg_hdr" Field.int ~enc:(fun r -> r.has_seg_hdr) + |> col "key_hex" Field.string ~enc:(fun r -> r.key_hex) + |> col "input_hex" Field.string ~enc:(fun r -> r.input_hex) + |> col "secured_hex" Field.string ~enc:(fun r -> r.secured_hex) |> finish)) let load_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV parse: %s" e + | Error e -> Alcotest.failf "CSV parse: %a" Csv.Error.pp e (* {1 SA / key setup} *) @@ -206,14 +206,14 @@ let fsr_codec = Csv.( Row.( obj (fun name hex -> { name; hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "fsr_hex" string ~enc:(fun r -> r.hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "fsr_hex" Field.string ~enc:(fun r -> r.hex) |> finish)) let load_fsr_vectors () = - match Csv.decode_file fsr_codec (trace "fsr.csv") with + match Csv.of_file fsr_codec (trace "fsr.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "fsr.csv: %s" e + | Error e -> Alcotest.failf "fsr.csv: %a" Csv.Error.pp e let test_fsr_decode (r : fsr_row) () = let word = Int32.of_string ("0x" ^ r.hex) in @@ -252,18 +252,18 @@ let cmac_codec = Row.( obj (fun name spi mac_len key_hex input_hex secured_hex -> { name; spi; mac_len; key_hex; input_hex; secured_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "spi" int ~enc:(fun r -> r.spi) - |> col "mac_len" int ~enc:(fun r -> r.mac_len) - |> col "key_hex" string ~enc:(fun r -> r.key_hex) - |> col "input_hex" string ~enc:(fun r -> r.input_hex) - |> col "secured_hex" string ~enc:(fun r -> r.secured_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "spi" Field.int ~enc:(fun r -> r.spi) + |> col "mac_len" Field.int ~enc:(fun r -> r.mac_len) + |> col "key_hex" Field.string ~enc:(fun r -> r.key_hex) + |> col "input_hex" Field.string ~enc:(fun r -> r.input_hex) + |> col "secured_hex" Field.string ~enc:(fun r -> r.secured_hex) |> finish)) let load_cmac_vectors () = - match Csv.decode_file cmac_codec (trace "cmac_vectors.csv") with + match Csv.of_file cmac_codec (trace "cmac_vectors.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "cmac_vectors.csv: %s" e + | Error e -> Alcotest.failf "cmac_vectors.csv: %a" Csv.Error.pp e (* CryptoLib's auth-only SA uses akid 130, key fedcba9876543210 x4. *) let cmac_akid = 130 diff --git a/ocaml-sle/test/interop/asn1tools/test.ml b/ocaml-sle/test/interop/asn1tools/test.ml index 9a6a03006c..ae18502d94 100644 --- a/ocaml-sle/test/interop/asn1tools/test.ml +++ b/ocaml-sle/test/interop/asn1tools/test.ml @@ -21,15 +21,15 @@ let pdu_codec = Csv.( Row.( obj (fun name direction pdu_hex -> { name; direction; pdu_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "direction" string ~enc:(fun r -> r.direction) - |> col "pdu_hex" string ~enc:(fun r -> r.pdu_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "direction" Field.string ~enc:(fun r -> r.direction) + |> col "pdu_hex" Field.string ~enc:(fun r -> r.pdu_hex) |> finish)) let rows file = - match Csv.decode_file pdu_codec (trace file) with + match Csv.of_file pdu_codec (trace file) with | Ok rows -> rows - | Error e -> Alcotest.failf "failed to parse %s: %s" file e + | Error e -> Alcotest.failf "failed to parse %s: %a" file Csv.Error.pp e type codec = { user : bytes -> (bytes, string) result; diff --git a/ocaml-sle/test/interop/dariol83/test.ml b/ocaml-sle/test/interop/dariol83/test.ml index 43620ad8fd..144c41ab77 100644 --- a/ocaml-sle/test/interop/dariol83/test.ml +++ b/ocaml-sle/test/interop/dariol83/test.ml @@ -30,15 +30,16 @@ let pdu_codec = Row.( obj (fun name payload_hex message_hex -> { name; payload_hex; message_hex }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "payload_hex" string ~enc:(fun v -> v.payload_hex) - |> col "message_hex" string ~enc:(fun v -> v.message_hex) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "payload_hex" Field.string ~enc:(fun v -> v.payload_hex) + |> col "message_hex" Field.string ~enc:(fun v -> v.message_hex) |> finish)) let parse_pdu_vectors () = - match Csv.decode_file pdu_codec (trace "pdu_vectors.csv") with + match Csv.of_file pdu_codec (trace "pdu_vectors.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse pdu_vectors.csv: %s" e + | Error e -> + Alcotest.failf "failed to parse pdu_vectors.csv: %a" Csv.Error.pp e let pdu_encode (vec : pdu_vector) () = let payload = bytes_of_hex vec.payload_hex in @@ -78,14 +79,15 @@ let hbt_codec = Csv.( Row.( obj (fun name message_hex -> { name; message_hex }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "message_hex" string ~enc:(fun v -> v.message_hex) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "message_hex" Field.string ~enc:(fun v -> v.message_hex) |> finish)) let parse_hbt_vectors () = - match Csv.decode_file hbt_codec (trace "heartbeat_vectors.csv") with + match Csv.of_file hbt_codec (trace "heartbeat_vectors.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse heartbeat_vectors.csv: %s" e + | Error e -> + Alcotest.failf "failed to parse heartbeat_vectors.csv: %a" Csv.Error.pp e let hbt_encode vec () = let got = Tml.encode_heartbeat () in @@ -121,16 +123,17 @@ let ctx_codec = Row.( obj (fun ctx_name heartbeat dead_factor ctx_message_hex -> { ctx_name; heartbeat; dead_factor; ctx_message_hex }) - |> col "name" string ~enc:(fun v -> v.ctx_name) - |> col "heartbeat" int ~enc:(fun v -> v.heartbeat) - |> col "dead_factor" int ~enc:(fun v -> v.dead_factor) - |> col "message_hex" string ~enc:(fun v -> v.ctx_message_hex) + |> col "name" Field.string ~enc:(fun v -> v.ctx_name) + |> col "heartbeat" Field.int ~enc:(fun v -> v.heartbeat) + |> col "dead_factor" Field.int ~enc:(fun v -> v.dead_factor) + |> col "message_hex" Field.string ~enc:(fun v -> v.ctx_message_hex) |> finish)) let parse_ctx_vectors () = - match Csv.decode_file ctx_codec (trace "context_vectors.csv") with + match Csv.of_file ctx_codec (trace "context_vectors.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse context_vectors.csv: %s" e + | Error e -> + Alcotest.failf "failed to parse context_vectors.csv: %a" Csv.Error.pp e let ctx_encode vec () = let ctx = diff --git a/ocaml-space-packet/test/interop/spacepackets/test.ml b/ocaml-space-packet/test/interop/spacepackets/test.ml index 86b04255cb..bc90361a37 100644 --- a/ocaml-space-packet/test/interop/spacepackets/test.ml +++ b/ocaml-space-packet/test/interop/spacepackets/test.ml @@ -23,14 +23,14 @@ let packet_codec = Row.( obj (fun name ptype apid shf seq_flags seq_count data_hex packet_hex -> { name; ptype; apid; shf; seq_flags; seq_count; data_hex; packet_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "type" string ~enc:(fun r -> r.ptype) - |> col "apid" int ~enc:(fun r -> r.apid) - |> col "shf" bool ~enc:(fun r -> r.shf) - |> col "seq_flags" string ~enc:(fun r -> r.seq_flags) - |> col "seq_count" int ~enc:(fun r -> r.seq_count) - |> col "data_hex" string ~enc:(fun r -> r.data_hex) - |> col "packet_hex" string ~enc:(fun r -> r.packet_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "type" Field.string ~enc:(fun r -> r.ptype) + |> col "apid" Field.int ~enc:(fun r -> r.apid) + |> col "shf" Field.bool ~enc:(fun r -> r.shf) + |> col "seq_flags" Field.string ~enc:(fun r -> r.seq_flags) + |> col "seq_count" Field.int ~enc:(fun r -> r.seq_count) + |> col "data_hex" Field.string ~enc:(fun r -> r.data_hex) + |> col "packet_hex" Field.string ~enc:(fun r -> r.packet_hex) |> finish)) (* {1 Helpers} *) @@ -51,9 +51,9 @@ let ptype_of_string = function let decode_reference_packets () = let rows = - match Csv.decode_file packet_codec (trace "packets.csv") with + match Csv.of_file packet_codec (trace "packets.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : packet_row) -> @@ -72,9 +72,9 @@ let decode_reference_packets () = let encode_matches_reference () = let rows = - match Csv.decode_file packet_codec (trace "packets.csv") with + match Csv.of_file packet_codec (trace "packets.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e in List.iter (fun (r : packet_row) -> diff --git a/ocaml-squashfs/test/interop/squashfs-tools/test.ml b/ocaml-squashfs/test/interop/squashfs-tools/test.ml index ecc46c0412..f7d61845ab 100644 --- a/ocaml-squashfs/test/interop/squashfs-tools/test.ml +++ b/ocaml-squashfs/test/interop/squashfs-tools/test.ml @@ -21,9 +21,9 @@ let row_codec = Csv.( Row.( obj (fun kind path payload_hex -> { kind; path; payload_hex }) - |> col "kind" string ~enc:(fun r -> r.kind) - |> col "path" string ~enc:(fun r -> r.path) - |> col "payload_hex" string ~enc:(fun r -> r.payload_hex) + |> col "kind" Field.string ~enc:(fun r -> r.kind) + |> col "path" Field.string ~enc:(fun r -> r.path) + |> col "payload_hex" Field.string ~enc:(fun r -> r.payload_hex) |> finish)) let unhex s = @@ -32,9 +32,9 @@ let unhex s = Char.chr (Fmt.kstr int_of_string "0x%s" (String.sub s (2 * i) 2))) let manifest () = - match Csv.decode_file row_codec (trace "manifest.csv") with + match Csv.of_file row_codec (trace "manifest.csv") with | Ok rows -> rows - | Error msg -> Alcotest.failf "manifest.csv: %s" msg + | Error e -> Alcotest.failf "manifest.csv: %a" Csv.Error.pp e (* --- our reader vs a real mksquashfs image --- *) diff --git a/ocaml-ssh/test/interop/paramiko/test.ml b/ocaml-ssh/test/interop/paramiko/test.ml index 4f7698c677..a17d78a0cc 100644 --- a/ocaml-ssh/test/interop/paramiko/test.ml +++ b/ocaml-ssh/test/interop/paramiko/test.ml @@ -14,9 +14,9 @@ let row_codec = Csv.( Row.( obj (fun name msg_type body_hex -> { name; msg_type; body_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "msg_type" int ~enc:(fun r -> r.msg_type) - |> col "body_hex" string ~enc:(fun r -> r.body_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "msg_type" Field.int ~enc:(fun r -> r.msg_type) + |> col "body_hex" Field.string ~enc:(fun r -> r.body_hex) |> finish)) let trace = Filename.concat "traces" "messages.csv" @@ -50,8 +50,8 @@ let check_row (r : row) = r.body_hex (hex_of_string re_encoded) let messages () = - match Csv.decode_file row_codec trace with - | Error msg -> Alcotest.failf "load %s: %s" trace msg + match Csv.of_file row_codec trace with + | Error e -> Alcotest.failf "load %s: %a" trace Csv.Error.pp e | Ok rows -> Alcotest.(check bool) "trace not empty" true (List.length rows > 0); List.iter check_row rows diff --git a/ocaml-stats/test/interop/numpy/test.ml b/ocaml-stats/test/interop/numpy/test.ml index 046bda8068..60a2a8c2b6 100644 --- a/ocaml-stats/test/interop/numpy/test.ml +++ b/ocaml-stats/test/interop/numpy/test.ml @@ -13,9 +13,9 @@ let trace path = Filename.concat "traces" path let load codec path = - match Csv.decode_file codec (trace path) with + match Csv.of_file codec (trace path) with | Ok rows -> rows - | Error msg -> Alcotest.failf "%s: %s" path msg + | Error e -> Alcotest.failf "%s: %a" path Csv.Error.pp e let floats s = List.map float_of_string (String.split_on_char ';' s) @@ -37,10 +37,10 @@ let quantile_codec = Csv.( Row.( obj (fun name values q value -> { name; values; q; value }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "values" string ~enc:(fun r -> r.values) - |> col "q" float ~enc:(fun r -> r.q) - |> col "value" float ~enc:(fun r -> r.value) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "values" Field.string ~enc:(fun r -> r.values) + |> col "q" Field.float ~enc:(fun r -> r.q) + |> col "value" Field.float ~enc:(fun r -> r.value) |> finish)) let test_quantile () = @@ -96,14 +96,14 @@ let descriptive_codec = Row.( obj (fun dname dvalues mean variance stddev dmin dmax total -> { dname; dvalues; mean; variance; stddev; dmin; dmax; total }) - |> col "name" string ~enc:(fun r -> r.dname) - |> col "values" string ~enc:(fun r -> r.dvalues) - |> col "mean" float ~enc:(fun r -> r.mean) - |> col "variance" float ~enc:(fun r -> r.variance) - |> col "stddev" float ~enc:(fun r -> r.stddev) - |> col "min" float ~enc:(fun r -> r.dmin) - |> col "max" float ~enc:(fun r -> r.dmax) - |> col "sum" float ~enc:(fun r -> r.total) + |> col "name" Field.string ~enc:(fun r -> r.dname) + |> col "values" Field.string ~enc:(fun r -> r.dvalues) + |> col "mean" Field.float ~enc:(fun r -> r.mean) + |> col "variance" Field.float ~enc:(fun r -> r.variance) + |> col "stddev" Field.float ~enc:(fun r -> r.stddev) + |> col "min" Field.float ~enc:(fun r -> r.dmin) + |> col "max" Field.float ~enc:(fun r -> r.dmax) + |> col "sum" Field.float ~enc:(fun r -> r.total) |> finish)) let get name = function @@ -182,11 +182,11 @@ let weighted_codec = Row.( obj (fun wname wvalues weights wq wvalue -> { wname; wvalues; weights; wq; wvalue }) - |> col "name" string ~enc:(fun r -> r.wname) - |> col "values" string ~enc:(fun r -> r.wvalues) - |> col "weights" string ~enc:(fun r -> r.weights) - |> col "q" float ~enc:(fun r -> r.wq) - |> col "value" float ~enc:(fun r -> r.wvalue) + |> col "name" Field.string ~enc:(fun r -> r.wname) + |> col "values" Field.string ~enc:(fun r -> r.wvalues) + |> col "weights" Field.string ~enc:(fun r -> r.weights) + |> col "q" Field.float ~enc:(fun r -> r.wq) + |> col "value" Field.float ~enc:(fun r -> r.wvalue) |> finish)) let test_weighted_quantile () = diff --git a/ocaml-stats/test/interop/scipy/test.ml b/ocaml-stats/test/interop/scipy/test.ml index 1c11157a25..3605d14608 100644 --- a/ocaml-stats/test/interop/scipy/test.ml +++ b/ocaml-stats/test/interop/scipy/test.ml @@ -18,9 +18,9 @@ let trace path = Filename.concat "traces" path let load codec path = - match Csv.decode_file codec (trace path) with + match Csv.of_file codec (trace path) with | Ok rows -> rows - | Error msg -> Alcotest.failf "%s: %s" path msg + | Error e -> Alcotest.failf "%s: %a" path Csv.Error.pp e let floats s = List.map float_of_string (String.split_on_char ';' s) @@ -48,13 +48,13 @@ let regression_codec = Row.( obj (fun name xs ys slope intercept r stderr -> { name; xs; ys; slope; intercept; r; stderr }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "xs" string ~enc:(fun r -> r.xs) - |> col "ys" string ~enc:(fun r -> r.ys) - |> col "slope" float ~enc:(fun r -> r.slope) - |> col "intercept" float ~enc:(fun r -> r.intercept) - |> col "r" float ~enc:(fun r -> r.r) - |> col "stderr" float ~enc:(fun r -> r.stderr) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "xs" Field.string ~enc:(fun r -> r.xs) + |> col "ys" Field.string ~enc:(fun r -> r.ys) + |> col "slope" Field.float ~enc:(fun r -> r.slope) + |> col "intercept" Field.float ~enc:(fun r -> r.intercept) + |> col "r" Field.float ~enc:(fun r -> r.r) + |> col "stderr" Field.float ~enc:(fun r -> r.stderr) |> finish)) let points r = List.combine (floats r.xs) (floats r.ys) @@ -123,10 +123,10 @@ let ranked_codec = Csv.( Row.( obj (fun rname rxs rys rho -> { rname; rxs; rys; rho }) - |> col "name" string ~enc:(fun r -> r.rname) - |> col "xs" string ~enc:(fun r -> r.rxs) - |> col "ys" string ~enc:(fun r -> r.rys) - |> col "rho" float ~enc:(fun r -> r.rho) + |> col "name" Field.string ~enc:(fun r -> r.rname) + |> col "xs" Field.string ~enc:(fun r -> r.rxs) + |> col "ys" Field.string ~enc:(fun r -> r.rys) + |> col "rho" Field.float ~enc:(fun r -> r.rho) |> finish)) let test_spearman () = diff --git a/ocaml-tc/test/interop/dariol83/test.ml b/ocaml-tc/test/interop/dariol83/test.ml index 96f4be8543..c543b055c0 100644 --- a/ocaml-tc/test/interop/dariol83/test.ml +++ b/ocaml-tc/test/interop/dariol83/test.ml @@ -50,22 +50,22 @@ let vector_codec = with_fecf = bool_of_int with_fecf; frame_hex; }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "bypass" int ~enc:(fun v -> if v.bypass then 1 else 0) - |> col "ctrl_cmd" int ~enc:(fun v -> if v.ctrl_cmd then 1 else 0) - |> col "scid" int ~enc:(fun v -> v.scid) - |> col "vcid" int ~enc:(fun v -> v.vcid) - |> col "frame_len" int ~enc:(fun v -> v.frame_len) - |> col "seq_num" int ~enc:(fun v -> v.seq_num) - |> col "data_hex" string ~enc:(fun v -> v.data_hex) - |> col "with_fecf" int ~enc:(fun v -> if v.with_fecf then 1 else 0) - |> col "frame_hex" string ~enc:(fun v -> v.frame_hex) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "bypass" Field.int ~enc:(fun v -> if v.bypass then 1 else 0) + |> col "ctrl_cmd" Field.int ~enc:(fun v -> if v.ctrl_cmd then 1 else 0) + |> col "scid" Field.int ~enc:(fun v -> v.scid) + |> col "vcid" Field.int ~enc:(fun v -> v.vcid) + |> col "frame_len" Field.int ~enc:(fun v -> v.frame_len) + |> col "seq_num" Field.int ~enc:(fun v -> v.seq_num) + |> col "data_hex" Field.string ~enc:(fun v -> v.data_hex) + |> col "with_fecf" Field.int ~enc:(fun v -> if v.with_fecf then 1 else 0) + |> col "frame_hex" Field.string ~enc:(fun v -> v.frame_hex) |> finish)) let parse_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse vectors.csv: %s" e + | Error e -> Alcotest.failf "failed to parse vectors.csv: %a" Csv.Error.pp e let decode vec () = let frame_bytes = Hex.decode vec.frame_hex in diff --git a/ocaml-tcf/test/interop/spacepackets/test.ml b/ocaml-tcf/test/interop/spacepackets/test.ml index 022f7ec68b..f0e78e551f 100644 --- a/ocaml-tcf/test/interop/spacepackets/test.ml +++ b/ocaml-tcf/test/interop/spacepackets/test.ml @@ -56,18 +56,18 @@ let cds_codec = time_field_hex; pfield_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "ccsds_days" int ~enc:(fun r -> r.ccsds_days) - |> col "ms_of_day" int ~enc:(fun r -> r.ms_of_day) - |> col "packed_hex" string ~enc:(fun r -> r.packed_hex) - |> col "time_field_hex" string ~enc:(fun r -> r.time_field_hex) - |> col "pfield_hex" string ~enc:(fun r -> r.pfield_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "ccsds_days" Field.int ~enc:(fun r -> r.ccsds_days) + |> col "ms_of_day" Field.int ~enc:(fun r -> r.ms_of_day) + |> col "packed_hex" Field.string ~enc:(fun r -> r.packed_hex) + |> col "time_field_hex" Field.string ~enc:(fun r -> r.time_field_hex) + |> col "pfield_hex" Field.string ~enc:(fun r -> r.pfield_hex) |> finish)) let load_vectors () = - match Csv.decode_file cds_codec (trace "cds_short.csv") with + match Csv.of_file cds_codec (trace "cds_short.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e (* {1 Tests} *) diff --git a/ocaml-tcp/test/interop/lwip/test.ml b/ocaml-tcp/test/interop/lwip/test.ml index 614ac374f7..57938a1753 100644 --- a/ocaml-tcp/test/interop/lwip/test.ml +++ b/ocaml-tcp/test/interop/lwip/test.ml @@ -32,14 +32,14 @@ let row_codec = Csv.( Row.( obj (fun label hex -> (label, of_hex hex)) - |> col "label" string ~enc:fst - |> col "hex" string ~enc:(fun _ -> "") + |> col "label" Field.string ~enc:fst + |> col "hex" Field.string ~enc:(fun _ -> "") |> finish)) let traces () = - match Csv.decode_file row_codec "traces/exchange.csv" with + match Csv.of_file row_codec "traces/exchange.csv" with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e let lwip_segment traces label = match Tcp.Segment.of_string ~src:sip ~dst:cip (List.assoc label traces) with diff --git a/ocaml-tcp/test/interop/mirage/test.ml b/ocaml-tcp/test/interop/mirage/test.ml index 103c3f8ecc..7b7d6af75a 100644 --- a/ocaml-tcp/test/interop/mirage/test.ml +++ b/ocaml-tcp/test/interop/mirage/test.ml @@ -31,15 +31,15 @@ let row_codec = Row.( obj (fun label nox mirage -> { label; nox = of_hex nox; mirage = of_hex mirage }) - |> col "label" string ~enc:(fun r -> r.label) - |> col "nox_hex" string ~enc:(fun _ -> "") - |> col "mirage_hex" string ~enc:(fun _ -> "") + |> col "label" Field.string ~enc:(fun r -> r.label) + |> col "nox_hex" Field.string ~enc:(fun _ -> "") + |> col "mirage_hex" Field.string ~enc:(fun _ -> "") |> finish)) let rows () = - match Csv.decode_file row_codec "traces/exchange.csv" with + match Csv.of_file row_codec "traces/exchange.csv" with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e let decode label which s = match Tcp.Segment.of_string ~src:cip ~dst:sip s with diff --git a/ocaml-tcp/test/interop/utcp/test.ml b/ocaml-tcp/test/interop/utcp/test.ml index 00766f2ce8..3d2f3891ad 100644 --- a/ocaml-tcp/test/interop/utcp/test.ml +++ b/ocaml-tcp/test/interop/utcp/test.ml @@ -32,14 +32,14 @@ let row_codec = Csv.( Row.( obj (fun label hex -> (label, of_hex hex)) - |> col "label" string ~enc:fst - |> col "hex" string ~enc:(fun _ -> "") + |> col "label" Field.string ~enc:fst + |> col "hex" Field.string ~enc:(fun _ -> "") |> finish)) let traces () = - match Csv.decode_file row_codec "traces/exchange.csv" with + match Csv.of_file row_codec "traces/exchange.csv" with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e let utcp_segment traces label = match Tcp.Segment.of_string ~src:sip ~dst:cip (List.assoc label traces) with diff --git a/ocaml-tcpcl/test/interop/dtn7-go/test.ml b/ocaml-tcpcl/test/interop/dtn7-go/test.ml index fe9bb13e2b..7e47b02ba4 100644 --- a/ocaml-tcpcl/test/interop/dtn7-go/test.ml +++ b/ocaml-tcpcl/test/interop/dtn7-go/test.ml @@ -30,15 +30,15 @@ let codec = Csv.( Row.( obj (fun name kind encoded_hex -> { name; kind; encoded_hex }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "kind" string ~enc:(fun v -> v.kind) - |> col "encoded_hex" string ~enc:(fun v -> v.encoded_hex) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "kind" Field.string ~enc:(fun v -> v.kind) + |> col "encoded_hex" Field.string ~enc:(fun v -> v.encoded_hex) |> finish)) let parse_vectors () = - match Csv.decode_file codec (trace "messages.csv") with + match Csv.of_file codec (trace "messages.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse messages.csv: %s" e + | Error e -> Alcotest.failf "failed to parse messages.csv: %a" Csv.Error.pp e (* The message variant name a vector's [name] is expected to decode to. *) let msg_tag = function diff --git a/ocaml-tcpcl/test/interop/ion/test.ml b/ocaml-tcpcl/test/interop/ion/test.ml index 8fcadf8bdc..fca07eeaca 100644 --- a/ocaml-tcpcl/test/interop/ion/test.ml +++ b/ocaml-tcpcl/test/interop/ion/test.ml @@ -46,20 +46,21 @@ let contact_codec = eid; encoded_hex; }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "request_ack" bool ~enc:(fun v -> v.request_ack) - |> col "reactive_frag" bool ~enc:(fun v -> v.reactive_frag) - |> col "allow_refusal" bool ~enc:(fun v -> v.allow_refusal) - |> col "request_length" bool ~enc:(fun v -> v.request_length) - |> col "keepalive" int ~enc:(fun v -> v.keepalive) - |> col "eid" string ~enc:(fun v -> v.eid) - |> col "encoded_hex" string ~enc:(fun v -> v.encoded_hex) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "request_ack" Field.bool ~enc:(fun v -> v.request_ack) + |> col "reactive_frag" Field.bool ~enc:(fun v -> v.reactive_frag) + |> col "allow_refusal" Field.bool ~enc:(fun v -> v.allow_refusal) + |> col "request_length" Field.bool ~enc:(fun v -> v.request_length) + |> col "keepalive" Field.int ~enc:(fun v -> v.keepalive) + |> col "eid" Field.string ~enc:(fun v -> v.eid) + |> col "encoded_hex" Field.string ~enc:(fun v -> v.encoded_hex) |> finish)) let parse_contact_vectors () = - match Csv.decode_file contact_codec (trace "contact_headers.csv") with + match Csv.of_file contact_codec (trace "contact_headers.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse contact_headers.csv: %s" e + | Error e -> + Alcotest.failf "failed to parse contact_headers.csv: %a" Csv.Error.pp e (* --- Contact header: encode and compare bytes --- *) @@ -138,15 +139,15 @@ let msg_codec = Csv.( Row.( obj (fun name msg_type encoded_hex -> { name; msg_type; encoded_hex }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "msg_type" string ~enc:(fun v -> v.msg_type) - |> col "encoded_hex" string ~enc:(fun v -> v.encoded_hex) + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "msg_type" Field.string ~enc:(fun v -> v.msg_type) + |> col "encoded_hex" Field.string ~enc:(fun v -> v.encoded_hex) |> finish)) let parse_msg_vectors () = - match Csv.decode_file msg_codec (trace "messages.csv") with + match Csv.of_file msg_codec (trace "messages.csv") with | Ok vs -> vs - | Error e -> Alcotest.failf "failed to parse messages.csv: %s" e + | Error e -> Alcotest.failf "failed to parse messages.csv: %a" Csv.Error.pp e (* --- Message: decode and verify type --- *) diff --git a/ocaml-tdm/test/interop/orekit/test.ml b/ocaml-tdm/test/interop/orekit/test.ml index 0f3f9cb3e7..612b5bb66e 100644 --- a/ocaml-tdm/test/interop/orekit/test.ml +++ b/ocaml-tdm/test/interop/orekit/test.ml @@ -48,21 +48,21 @@ let index_codec = obs_epochs; obs_values; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "file" string ~enc:(fun r -> r.file) - |> col "participant_1" string ~enc:(fun r -> r.participant_1) - |> col "participant_2" string ~enc:(fun r -> r.participant_2) - |> col "participant_3" string ~enc:(fun r -> r.participant_3) - |> col "num_observations" int ~enc:(fun r -> r.num_observations) - |> col "obs_keywords" string ~enc:(fun r -> r.obs_keywords) - |> col "obs_epochs" string ~enc:(fun r -> r.obs_epochs) - |> col "obs_values" string ~enc:(fun r -> r.obs_values) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "file" Field.string ~enc:(fun r -> r.file) + |> col "participant_1" Field.string ~enc:(fun r -> r.participant_1) + |> col "participant_2" Field.string ~enc:(fun r -> r.participant_2) + |> col "participant_3" Field.string ~enc:(fun r -> r.participant_3) + |> col "num_observations" Field.int ~enc:(fun r -> r.num_observations) + |> col "obs_keywords" Field.string ~enc:(fun r -> r.obs_keywords) + |> col "obs_epochs" Field.string ~enc:(fun r -> r.obs_epochs) + |> col "obs_values" Field.string ~enc:(fun r -> r.obs_values) |> finish)) let parse_index () = - match Csv.decode_file index_codec (trace "index.csv") with + match Csv.of_file index_codec (trace "index.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV index: %s" e + | Error e -> Alcotest.failf "CSV index: %a" Csv.Error.pp e (* -- Helpers --------------------------------------------------------- *) diff --git a/ocaml-tiff/test/interop/gdal/test.ml b/ocaml-tiff/test/interop/gdal/test.ml index 97e3066066..9c0222c60d 100644 --- a/ocaml-tiff/test/interop/gdal/test.ml +++ b/ocaml-tiff/test/interop/gdal/test.ml @@ -79,25 +79,25 @@ let crop_codec = min; max; }) - |> col "file" string ~enc:(fun c -> c.file) - |> col "width" int ~enc:(fun c -> c.width) - |> col "height" int ~enc:(fun c -> c.height) - |> col "bands" int ~enc:(fun c -> c.bands) - |> col "data_type" string ~enc:(fun c -> c.data_type) - |> col "epsg" int ~enc:(fun c -> c.epsg) - |> col "origin_x" float ~enc:(fun c -> c.origin_x) - |> col "origin_y" float ~enc:(fun c -> c.origin_y) - |> col "pixel_width" float ~enc:(fun c -> c.pixel_width) - |> col "pixel_height" float ~enc:(fun c -> c.pixel_height) - |> col "nodata" float ~enc:(fun c -> c.nodata) - |> col "area_or_point" string ~enc:(fun c -> c.area_or_point) - |> col "compression" string ~enc:(fun c -> c.compression) - |> col "predictor" int ~enc:(fun c -> c.predictor) - |> col "block_width" int ~enc:(fun c -> c.block_width) - |> col "block_height" int ~enc:(fun c -> c.block_height) - |> col "sum" int ~enc:(fun c -> c.sum) - |> col "min" int ~enc:(fun c -> c.min) - |> col "max" int ~enc:(fun c -> c.max) + |> col "file" Field.string ~enc:(fun c -> c.file) + |> col "width" Field.int ~enc:(fun c -> c.width) + |> col "height" Field.int ~enc:(fun c -> c.height) + |> col "bands" Field.int ~enc:(fun c -> c.bands) + |> col "data_type" Field.string ~enc:(fun c -> c.data_type) + |> col "epsg" Field.int ~enc:(fun c -> c.epsg) + |> col "origin_x" Field.float ~enc:(fun c -> c.origin_x) + |> col "origin_y" Field.float ~enc:(fun c -> c.origin_y) + |> col "pixel_width" Field.float ~enc:(fun c -> c.pixel_width) + |> col "pixel_height" Field.float ~enc:(fun c -> c.pixel_height) + |> col "nodata" Field.float ~enc:(fun c -> c.nodata) + |> col "area_or_point" Field.string ~enc:(fun c -> c.area_or_point) + |> col "compression" Field.string ~enc:(fun c -> c.compression) + |> col "predictor" Field.int ~enc:(fun c -> c.predictor) + |> col "block_width" Field.int ~enc:(fun c -> c.block_width) + |> col "block_height" Field.int ~enc:(fun c -> c.block_height) + |> col "sum" Field.int ~enc:(fun c -> c.sum) + |> col "min" Field.int ~enc:(fun c -> c.min) + |> col "max" Field.int ~enc:(fun c -> c.max) |> finish)) type sample = { s_file : string; x : int; y : int; value : int } @@ -106,16 +106,16 @@ let sample_codec = Csv.( Row.( obj (fun s_file x y value -> { s_file; x; y; value }) - |> col "file" string ~enc:(fun s -> s.s_file) - |> col "x" int ~enc:(fun s -> s.x) - |> col "y" int ~enc:(fun s -> s.y) - |> col "value" int ~enc:(fun s -> s.value) + |> col "file" Field.string ~enc:(fun s -> s.s_file) + |> col "x" Field.int ~enc:(fun s -> s.x) + |> col "y" Field.int ~enc:(fun s -> s.y) + |> col "value" Field.int ~enc:(fun s -> s.value) |> finish)) let load codec path = - match Csv.decode_file codec path with + match Csv.of_file codec path with | Ok vs -> vs - | Error e -> Alcotest.failf "reading %s: %s" path e + | Error e -> Alcotest.failf "reading %s: %a" path Csv.Error.pp e let crops = lazy (load crop_codec "traces/crops.csv") let samples = lazy (load sample_codec "traces/samples.csv") diff --git a/ocaml-tm/test/interop/dariol83/test.ml b/ocaml-tm/test/interop/dariol83/test.ml index 4dd4f901f0..9eebd8ffc1 100644 --- a/ocaml-tm/test/interop/dariol83/test.ml +++ b/ocaml-tm/test/interop/dariol83/test.ml @@ -74,31 +74,33 @@ let vector_codec = expect_fecf = bool_of_int expect_fecf; frame_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "frame_len" int ~enc:(fun r -> r.frame_len) - |> col "scid" int ~enc:(fun r -> r.scid) - |> col "vcid" int ~enc:(fun r -> r.vcid) - |> col "ocf_flag" int ~enc:(fun r -> if r.ocf_flag then 1 else 0) - |> col "mcfc" int ~enc:(fun r -> r.mcfc) - |> col "vcfc" int ~enc:(fun r -> r.vcfc) - |> col "sec_hdr" int ~enc:(fun r -> if r.sec_hdr then 1 else 0) - |> col "sync_flag" int ~enc:(fun r -> if r.sync_flag then 1 else 0) - |> col "pkt_order" int ~enc:(fun r -> if r.pkt_order then 1 else 0) - |> col "seg_len_id" int ~enc:(fun r -> r.seg_len_id) - |> col "first_hdr_ptr" int ~enc:(fun r -> r.first_hdr_ptr) - |> col "data_hex" string ~enc:(fun r -> r.data_hex) - |> col "ocf_hex" string ~enc:(fun r -> r.ocf_hex) - |> col "expect_ocf" int ~enc:(fun r -> if r.expect_ocf then 1 else 0) - |> col "expect_fecf" int ~enc:(fun r -> if r.expect_fecf then 1 else 0) - |> col "frame_hex" string ~enc:(fun r -> r.frame_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "frame_len" Field.int ~enc:(fun r -> r.frame_len) + |> col "scid" Field.int ~enc:(fun r -> r.scid) + |> col "vcid" Field.int ~enc:(fun r -> r.vcid) + |> col "ocf_flag" Field.int ~enc:(fun r -> if r.ocf_flag then 1 else 0) + |> col "mcfc" Field.int ~enc:(fun r -> r.mcfc) + |> col "vcfc" Field.int ~enc:(fun r -> r.vcfc) + |> col "sec_hdr" Field.int ~enc:(fun r -> if r.sec_hdr then 1 else 0) + |> col "sync_flag" Field.int ~enc:(fun r -> if r.sync_flag then 1 else 0) + |> col "pkt_order" Field.int ~enc:(fun r -> if r.pkt_order then 1 else 0) + |> col "seg_len_id" Field.int ~enc:(fun r -> r.seg_len_id) + |> col "first_hdr_ptr" Field.int ~enc:(fun r -> r.first_hdr_ptr) + |> col "data_hex" Field.string ~enc:(fun r -> r.data_hex) + |> col "ocf_hex" Field.string ~enc:(fun r -> r.ocf_hex) + |> col "expect_ocf" Field.int ~enc:(fun r -> + if r.expect_ocf then 1 else 0) + |> col "expect_fecf" Field.int ~enc:(fun r -> + if r.expect_fecf then 1 else 0) + |> col "frame_hex" Field.string ~enc:(fun r -> r.frame_hex) |> finish)) (* {1 Helpers} *) let load_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e (* {1 Tests} *) diff --git a/ocaml-tpm/test/interop/go-tpm/test.ml b/ocaml-tpm/test/interop/go-tpm/test.ml index 668b2cc134..199c0fbd48 100644 --- a/ocaml-tpm/test/interop/go-tpm/test.ml +++ b/ocaml-tpm/test/interop/go-tpm/test.ml @@ -23,16 +23,16 @@ let row_codec = Row.( obj (fun name command_hex response_hex -> { name; command_hex; response_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "command_hex" string ~enc:(fun r -> r.command_hex) - |> col "response_hex" string ~enc:(fun r -> r.response_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "command_hex" Field.string ~enc:(fun r -> r.command_hex) + |> col "response_hex" Field.string ~enc:(fun r -> r.response_hex) |> finish)) let rows = lazy - (match Csv.decode_file row_codec "traces/operations.csv" with + (match Csv.of_file row_codec "traces/operations.csv" with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV parse: %s" e) + | Error e -> Alcotest.failf "CSV parse: %a" Csv.Error.pp e) (* The ocaml-tpm command builder for each captured operation. *) let ocaml_command = function diff --git a/ocaml-turbo/test/interop/aff3ct/test.ml b/ocaml-turbo/test/interop/aff3ct/test.ml index e0bb6b5856..de753946f1 100644 --- a/ocaml-turbo/test/interop/aff3ct/test.ml +++ b/ocaml-turbo/test/interop/aff3ct/test.ml @@ -18,18 +18,18 @@ let vector_codec = Row.( obj (fun name rate block_size info_hex encoded_hex -> { name; rate; block_size; info_hex; encoded_hex }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "rate" string ~enc:(fun r -> r.rate) - |> col "block_size" int ~enc:(fun r -> r.block_size) - |> col "info_hex" string ~enc:(fun r -> r.info_hex) - |> col "encoded_hex" string ~enc:(fun r -> r.encoded_hex) + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "rate" Field.string ~enc:(fun r -> r.rate) + |> col "block_size" Field.int ~enc:(fun r -> r.block_size) + |> col "info_hex" Field.string ~enc:(fun r -> r.info_hex) + |> col "encoded_hex" Field.string ~enc:(fun r -> r.encoded_hex) |> finish)) let encode () = let rows = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e in List.iter (fun (v : vector) -> diff --git a/ocaml-uslp/test/interop/spacepackets/test.ml b/ocaml-uslp/test/interop/spacepackets/test.ml index eebbc7749d..eb9afc2a59 100644 --- a/ocaml-uslp/test/interop/spacepackets/test.ml +++ b/ocaml-uslp/test/interop/spacepackets/test.ml @@ -90,29 +90,31 @@ let frame_codec = ocf_hex; frame_hex; }) - |> col "name" string ~enc:(fun r -> r.name) - |> col "scid" int ~enc:(fun r -> r.scid) - |> col "src_or_dest" string ~enc:(fun r -> r.src_or_dest) - |> col "vcid" int ~enc:(fun r -> r.vcid) - |> col "map_id" int ~enc:(fun r -> r.map_id) - |> col "eofph" int ~enc:(fun r -> if r.eofph then 1 else 0) - |> col "bypass_flag" int ~enc:(fun r -> if r.bypass_flag then 1 else 0) - |> col "prot_ctrl_cmd" int ~enc:(fun r -> + |> col "name" Field.string ~enc:(fun r -> r.name) + |> col "scid" Field.int ~enc:(fun r -> r.scid) + |> col "src_or_dest" Field.string ~enc:(fun r -> r.src_or_dest) + |> col "vcid" Field.int ~enc:(fun r -> r.vcid) + |> col "map_id" Field.int ~enc:(fun r -> r.map_id) + |> col "eofph" Field.int ~enc:(fun r -> if r.eofph then 1 else 0) + |> col "bypass_flag" Field.int ~enc:(fun r -> + if r.bypass_flag then 1 else 0) + |> col "prot_ctrl_cmd" Field.int ~enc:(fun r -> if r.prot_ctrl_cmd then 1 else 0) - |> col "expect_ocf" int ~enc:(fun r -> if r.expect_ocf then 1 else 0) - |> col "expect_fecf" string ~enc:(fun r -> r.expect_fecf) - |> col "vcfc_len" int ~enc:(fun r -> r.vcfc_len) - |> col "vcfc" int ~enc:(fun r -> r.vcfc) - |> col "insert_zone_len" int ~enc:(fun r -> r.insert_zone_len) - |> col "data_hex" string ~enc:(fun r -> r.data_hex) - |> col "ocf_hex" string ~enc:(fun r -> r.ocf_hex) - |> col "frame_hex" string ~enc:(fun r -> r.frame_hex) + |> col "expect_ocf" Field.int ~enc:(fun r -> + if r.expect_ocf then 1 else 0) + |> col "expect_fecf" Field.string ~enc:(fun r -> r.expect_fecf) + |> col "vcfc_len" Field.int ~enc:(fun r -> r.vcfc_len) + |> col "vcfc" Field.int ~enc:(fun r -> r.vcfc) + |> col "insert_zone_len" Field.int ~enc:(fun r -> r.insert_zone_len) + |> col "data_hex" Field.string ~enc:(fun r -> r.data_hex) + |> col "ocf_hex" Field.string ~enc:(fun r -> r.ocf_hex) + |> col "frame_hex" Field.string ~enc:(fun r -> r.frame_hex) |> finish)) let load_vectors () = - match Csv.decode_file frame_codec (trace "frames.csv") with + match Csv.of_file frame_codec (trace "frames.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV decode: %s" e + | Error e -> Alcotest.failf "CSV decode: %a" Csv.Error.pp e (* {1 Tests} *) diff --git a/ocaml-vaccel/test/interop/vaccel-rust/test.ml b/ocaml-vaccel/test/interop/vaccel-rust/test.ml index 9b7b0cece1..64ae33a77f 100644 --- a/ocaml-vaccel/test/interop/vaccel-rust/test.ml +++ b/ocaml-vaccel/test/interop/vaccel-rust/test.ml @@ -42,17 +42,17 @@ let call_codec = Row.( obj (fun meth request_hex status response_hex -> { meth; request_hex; status; response_hex }) - |> col "method" string ~enc:(fun r -> r.meth) - |> col "request_hex" string ~enc:(fun r -> r.request_hex) - |> col "status" string ~enc:(fun r -> r.status) - |> col "response_hex" string ~enc:(fun r -> r.response_hex) + |> col "method" Field.string ~enc:(fun r -> r.meth) + |> col "request_hex" Field.string ~enc:(fun r -> r.request_hex) + |> col "status" Field.string ~enc:(fun r -> r.status) + |> col "response_hex" Field.string ~enc:(fun r -> r.response_hex) |> finish)) let calls = lazy - (match Csv.decode_file call_codec trace with + (match Csv.of_file call_codec trace with | Ok rows -> rows - | Error msg -> Alcotest.failf "%s: %s" trace msg) + | Error e -> Alcotest.failf "%s: %a" trace Csv.Error.pp e) let get meth = match diff --git a/ocaml-visvalingam/test/interop/mapshaper/test.ml b/ocaml-visvalingam/test/interop/mapshaper/test.ml index beb25a5dca..d9cef97851 100644 --- a/ocaml-visvalingam/test/interop/mapshaper/test.ml +++ b/ocaml-visvalingam/test/interop/mapshaper/test.ml @@ -29,10 +29,10 @@ let vertex_codec = Csv.( Row.( obj (fun ring seq x y -> { ring; seq; x; y }) - |> col "ring" string ~enc:(fun r -> r.ring) - |> col "seq" int ~enc:(fun r -> r.seq) - |> col "x" float ~enc:(fun r -> r.x) - |> col "y" float ~enc:(fun r -> r.y) + |> col "ring" Field.string ~enc:(fun r -> r.ring) + |> col "seq" Field.int ~enc:(fun r -> r.seq) + |> col "x" Field.float ~enc:(fun r -> r.x) + |> col "y" Field.float ~enc:(fun r -> r.y) |> finish)) type simplified = { threshold : string; vertex : vertex } @@ -42,19 +42,19 @@ let simplified_codec = Row.( obj (fun threshold ring seq x y -> { threshold; vertex = { ring; seq; x; y } }) - |> col "threshold" string ~enc:(fun r -> r.threshold) - |> col "ring" string ~enc:(fun r -> r.vertex.ring) - |> col "seq" int ~enc:(fun r -> r.vertex.seq) - |> col "x" float ~enc:(fun r -> r.vertex.x) - |> col "y" float ~enc:(fun r -> r.vertex.y) + |> col "threshold" Field.string ~enc:(fun r -> r.threshold) + |> col "ring" Field.string ~enc:(fun r -> r.vertex.ring) + |> col "seq" Field.int ~enc:(fun r -> r.vertex.seq) + |> col "x" Field.float ~enc:(fun r -> r.vertex.x) + |> col "y" Field.float ~enc:(fun r -> r.vertex.y) |> finish)) let trace path = Filename.concat "traces" path let load codec path = - match Csv.decode_file codec (trace path) with + match Csv.of_file codec (trace path) with | Ok rows -> rows - | Error msg -> Alcotest.failf "%s: %s" path msg + | Error e -> Alcotest.failf "%s: %a" path Csv.Error.pp e (* Rings, in the order mapshaper names them, each as its vertex sequence. *) let group vertices = diff --git a/ocaml-viterbi/test/interop/commpy/test.ml b/ocaml-viterbi/test/interop/commpy/test.ml index 89f5bc23bb..f15170c0a1 100644 --- a/ocaml-viterbi/test/interop/commpy/test.ml +++ b/ocaml-viterbi/test/interop/commpy/test.ml @@ -18,16 +18,16 @@ let vector_codec = input = bytes_of_hex input_hex; expected_coded = bytes_of_hex encoded_hex; }) - |> col "name" string ~enc:(fun v -> v.name) - |> col "input_hex" string ~enc:(fun v -> Bytes.to_string v.input) - |> col "encoded_hex" string ~enc:(fun v -> + |> col "name" Field.string ~enc:(fun v -> v.name) + |> col "input_hex" Field.string ~enc:(fun v -> Bytes.to_string v.input) + |> col "encoded_hex" Field.string ~enc:(fun v -> Bytes.to_string v.expected_coded) |> finish)) let parse_vectors () = - match Csv.decode_file vector_codec (trace "vectors.csv") with + match Csv.of_file vector_codec (trace "vectors.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "CSV: %s" e + | Error e -> Alcotest.failf "CSV: %a" Csv.Error.pp e let ccsds = Viterbi.ccsds diff --git a/ocaml-xen/test/interop/xenstored/test.ml b/ocaml-xen/test/interop/xenstored/test.ml index 256d90f207..36ed4d9946 100644 --- a/ocaml-xen/test/interop/xenstored/test.ml +++ b/ocaml-xen/test/interop/xenstored/test.ml @@ -66,18 +66,18 @@ let row_codec = Row.( obj (fun step op path value request_hex response_hex -> { step; op; path; value; request_hex; response_hex }) - |> col "step" int ~enc:(fun r -> r.step) - |> col "op" string ~enc:(fun r -> r.op) - |> col "path" string ~enc:(fun r -> r.path) - |> col "value" string ~enc:(fun r -> r.value) - |> col "request_hex" string ~enc:(fun r -> r.request_hex) - |> col "response_hex" string ~enc:(fun r -> r.response_hex) + |> col "step" Field.int ~enc:(fun r -> r.step) + |> col "op" Field.string ~enc:(fun r -> r.op) + |> col "path" Field.string ~enc:(fun r -> r.path) + |> col "value" Field.string ~enc:(fun r -> r.value) + |> col "request_hex" Field.string ~enc:(fun r -> r.request_hex) + |> col "response_hex" Field.string ~enc:(fun r -> r.response_hex) |> finish)) let rows () = - match Csv.decode_file row_codec (trace "operations.csv") with + match Csv.of_file row_codec (trace "operations.csv") with | Ok rows -> rows - | Error e -> Alcotest.failf "operations.csv: %s" e + | Error e -> Alcotest.failf "operations.csv: %a" Csv.Error.pp e let of_string_exn what bytes = match Xs.of_string bytes ~pos:0 with diff --git a/ocaml-xlsx/test/interop/xlrd/test.ml b/ocaml-xlsx/test/interop/xlrd/test.ml index 8acd231dd0..8fed661cb0 100644 --- a/ocaml-xlsx/test/interop/xlrd/test.ml +++ b/ocaml-xlsx/test/interop/xlrd/test.ml @@ -29,19 +29,19 @@ let cell_codec = Row.( obj (fun book sheet_index sheet_name row col kind value -> { book; sheet_index; sheet_name; row; col; kind; value }) - |> col "book" string ~enc:(fun r -> r.book) - |> col "sheet_index" int ~enc:(fun r -> r.sheet_index) - |> col "sheet_name" string ~enc:(fun r -> r.sheet_name) - |> col "row" int ~enc:(fun r -> r.row) - |> col "col" int ~enc:(fun r -> r.col) - |> col "kind" string ~enc:(fun r -> r.kind) - |> col "value" string ~enc:(fun r -> r.value) + |> col "book" Field.string ~enc:(fun r -> r.book) + |> col "sheet_index" Field.int ~enc:(fun r -> r.sheet_index) + |> col "sheet_name" Field.string ~enc:(fun r -> r.sheet_name) + |> col "row" Field.int ~enc:(fun r -> r.row) + |> col "col" Field.int ~enc:(fun r -> r.col) + |> col "kind" Field.string ~enc:(fun r -> r.kind) + |> col "value" Field.string ~enc:(fun r -> r.value) |> finish)) let expected () = - match Csv.decode_file cell_codec (trace "cells.csv") with + match Csv.of_file cell_codec (trace "cells.csv") with | Ok rows -> rows - | Error msg -> Alcotest.failf "cells.csv: %s" msg + | Error e -> Alcotest.failf "cells.csv: %a" Csv.Error.pp e let read_file path = let ic = open_in_bin path in diff --git a/ocaml-xtce/test/interop/yamcs/test.ml b/ocaml-xtce/test/interop/yamcs/test.ml index 00efeb26bb..a8859c85a9 100644 --- a/ocaml-xtce/test/interop/yamcs/test.ml +++ b/ocaml-xtce/test/interop/yamcs/test.ml @@ -28,18 +28,18 @@ let row_codec = Row.( obj (fun packet container parameter raw engineering -> { packet; container; parameter; raw; engineering }) - |> col "packet" string ~enc:(fun r -> r.packet) - |> col "container" string ~enc:(fun r -> r.container) - |> col "parameter" string ~enc:(fun r -> r.parameter) - |> col "raw" string ~enc:(fun r -> r.raw) - |> col "engineering" string ~enc:(fun r -> r.engineering) + |> col "packet" Field.string ~enc:(fun r -> r.packet) + |> col "container" Field.string ~enc:(fun r -> r.container) + |> col "parameter" Field.string ~enc:(fun r -> r.parameter) + |> col "raw" Field.string ~enc:(fun r -> r.raw) + |> col "engineering" Field.string ~enc:(fun r -> r.engineering) |> finish)) let oracle = lazy - (match Csv.decode_file row_codec "traces/oracle.csv" with + (match Csv.of_file row_codec "traces/oracle.csv" with | Ok rows -> rows - | Error e -> Alcotest.failf "reading the Yamcs traces: %s" e) + | Error e -> Alcotest.failf "reading the Yamcs traces: %a" Csv.Error.pp e) let database = lazy -- 2.51.2