-11

test/interop/python/dune

reviewed

··· 1 1 - (rule 2 2 - (deps 3 3 - (source_tree scripts)) 4 4 - (targets vectors_packets.csv vectors_instructions.csv vectors_crc.csv) 5 5 - (action 6 6 - (run python3 scripts/generate.py vectors))) 7 7 - 8 8 - (test 9 9 - (name test) 10 10 - (libraries spacewire csvt alcotest) 11 11 - (deps vectors_packets.csv vectors_instructions.csv vectors_crc.csv))

-301

test/interop/python/scripts/generate.py

reviewed

··· 1 1 - #!/usr/bin/env python3 2 2 - """Generate SpaceWire / RMAP interop traces for ocaml-spacewire. 3 3 - 4 4 - Oracle: Python (no deps needed for bitfield packing from the specs) 5 5 - Install: no dependencies 6 6 - 7 7 - Tests SpaceWire packet encoding (ECSS-E-ST-50-12C), RMAP instruction byte 8 8 - encoding and RMAP CRC-8 (ECSS-E-ST-50-52C). 9 9 - 10 10 - SpaceWire Packet wire format: 11 11 - [addr_count : 1 byte] 12 12 - [addr_bytes : addr_count bytes] 13 13 - [eop_marker : 1 byte] (0x00 = EOP, 0x01 = EEP) 14 14 - [cargo : remaining bytes] 15 15 - 16 16 - RMAP Instruction byte (1 byte): 17 17 - Bit 7: reserved (0) 18 18 - Bit 6: command (1) / reply (0) 19 19 - Bit 5: write (1) / read (0) 20 20 - Bit 4: verify (1) / no verify (0) 21 21 - Bit 3: ack (1) / no ack (0) 22 22 - Bit 2: increment (1) / no increment (0) 23 23 - Bits 1-0: reply address length (0-3, in 4-byte units) 24 24 - 25 25 - RMAP CRC-8: Polynomial x^8 + x^2 + x + 1 (0x07). 26 26 - Per ECSS-E-ST-50-52C Annex A. 27 27 - 28 28 - Traces are committed to git. Only re-run when changing inputs 29 29 - or upgrading the oracle. 30 30 - """ 31 31 - import csv 32 32 - import os 33 33 - import sys 34 34 - 35 35 - 36 36 - # --------------------------------------------------------------------------- 37 37 - # SpaceWire packet encoding 38 38 - # --------------------------------------------------------------------------- 39 39 - 40 40 - def encode_packet(address, cargo, eop): 41 41 - """Encode a SpaceWire packet to bytes. 42 42 - 43 43 - address: list of int (0-255) 44 44 - cargo: bytes 45 45 - eop: "EOP" or "EEP" 46 46 - """ 47 47 - addr_count = len(address) 48 48 - eop_byte = 0x00 if eop == "EOP" else 0x01 49 49 - buf = bytes([addr_count]) + bytes(address) + bytes([eop_byte]) + cargo 50 50 - return buf 51 51 - 52 52 - 53 53 - # --------------------------------------------------------------------------- 54 54 - # RMAP CRC-8 55 55 - # --------------------------------------------------------------------------- 56 56 - 57 57 - def rmap_crc8_table(): 58 58 - """Build the CRC-8 lookup table for polynomial 0x07.""" 59 59 - table = [] 60 60 - for i in range(256): 61 61 - crc = i 62 62 - for _ in range(8): 63 63 - if crc & 0x80: 64 64 - crc = ((crc << 1) ^ 0x07) & 0xFF 65 65 - else: 66 66 - crc = (crc << 1) & 0xFF 67 67 - table.append(crc) 68 68 - return table 69 69 - 70 70 - CRC_TABLE = rmap_crc8_table() 71 71 - 72 72 - 73 73 - def rmap_crc8(data): 74 74 - """Compute RMAP CRC-8 over bytes.""" 75 75 - crc = 0 76 76 - for b in data: 77 77 - crc = CRC_TABLE[crc ^ b] 78 78 - return crc 79 79 - 80 80 - 81 81 - # --------------------------------------------------------------------------- 82 82 - # RMAP instruction byte 83 83 - # --------------------------------------------------------------------------- 84 84 - 85 85 - def encode_instruction(is_command, is_write, is_verify, is_ack, is_increment, 86 86 - reply_addr_len): 87 87 - """Encode the RMAP instruction byte. 88 88 - 89 89 - reply_addr_len: 0-3 (in 4-byte units) 90 90 - """ 91 91 - byte = 0 92 92 - # bit 7: reserved (0) 93 93 - if is_command: 94 94 - byte |= (1 << 6) 95 95 - if is_write: 96 96 - byte |= (1 << 5) 97 97 - if is_verify: 98 98 - byte |= (1 << 4) 99 99 - if is_ack: 100 100 - byte |= (1 << 3) 101 101 - if is_increment: 102 102 - byte |= (1 << 2) 103 103 - byte |= (reply_addr_len & 0x03) 104 104 - return byte 105 105 - 106 106 - 107 107 - # --------------------------------------------------------------------------- 108 108 - # Test vectors 109 109 - # --------------------------------------------------------------------------- 110 110 - 111 111 - # 1. Packet encoding vectors 112 112 - packet_vectors = [ 113 113 - { 114 114 - "name": "no_addr_eop", 115 115 - "address": [], 116 116 - "cargo": b"\xDE\xAD", 117 117 - "eop": "EOP", 118 118 - }, 119 119 - { 120 120 - "name": "no_addr_eep", 121 121 - "address": [], 122 122 - "cargo": b"\xBE\xEF", 123 123 - "eop": "EEP", 124 124 - }, 125 125 - { 126 126 - "name": "single_addr", 127 127 - "address": [42], 128 128 - "cargo": b"\x01\x02\x03", 129 129 - "eop": "EOP", 130 130 - }, 131 131 - { 132 132 - "name": "three_addr_eop", 133 133 - "address": [5, 17, 200], 134 134 - "cargo": b"\xCA\xFE\xBA\xBE", 135 135 - "eop": "EOP", 136 136 - }, 137 137 - { 138 138 - "name": "three_addr_eep", 139 139 - "address": [0, 128, 255], 140 140 - "cargo": b"\x42", 141 141 - "eop": "EEP", 142 142 - }, 143 143 - { 144 144 - "name": "single_byte_cargo", 145 145 - "address": [1], 146 146 - "cargo": b"\xFF", 147 147 - "eop": "EOP", 148 148 - }, 149 149 - { 150 150 - "name": "binary_cargo_256", 151 151 - "address": [10], 152 152 - "cargo": bytes(range(256)), 153 153 - "eop": "EOP", 154 154 - }, 155 155 - { 156 156 - "name": "max_addr_byte", 157 157 - "address": [255], 158 158 - "cargo": b"\xAA\xBB", 159 159 - "eop": "EEP", 160 160 - }, 161 161 - ] 162 162 - 163 163 - # 2. RMAP instruction byte vectors 164 164 - instruction_vectors = [ 165 165 - { 166 166 - "name": "read_no_ack_no_inc", 167 167 - "is_command": True, "is_write": False, "is_verify": False, 168 168 - "is_ack": False, "is_increment": False, "reply_addr_len": 0, 169 169 - }, 170 170 - { 171 171 - "name": "read_ack_inc", 172 172 - "is_command": True, "is_write": False, "is_verify": False, 173 173 - "is_ack": True, "is_increment": True, "reply_addr_len": 0, 174 174 - }, 175 175 - { 176 176 - "name": "write_ack_inc", 177 177 - "is_command": True, "is_write": True, "is_verify": False, 178 178 - "is_ack": True, "is_increment": True, "reply_addr_len": 0, 179 179 - }, 180 180 - { 181 181 - "name": "write_verify_ack_inc", 182 182 - "is_command": True, "is_write": True, "is_verify": True, 183 183 - "is_ack": True, "is_increment": True, "reply_addr_len": 0, 184 184 - }, 185 185 - { 186 186 - "name": "rmw_ack_inc", 187 187 - "is_command": True, "is_write": False, "is_verify": True, 188 188 - "is_ack": True, "is_increment": True, "reply_addr_len": 0, 189 189 - }, 190 190 - { 191 191 - "name": "read_reply", 192 192 - "is_command": False, "is_write": False, "is_verify": False, 193 193 - "is_ack": True, "is_increment": True, "reply_addr_len": 0, 194 194 - }, 195 195 - { 196 196 - "name": "write_reply", 197 197 - "is_command": False, "is_write": True, "is_verify": False, 198 198 - "is_ack": True, "is_increment": True, "reply_addr_len": 0, 199 199 - }, 200 200 - { 201 201 - "name": "cmd_reply_addr_1", 202 202 - "is_command": True, "is_write": False, "is_verify": False, 203 203 - "is_ack": True, "is_increment": True, "reply_addr_len": 1, 204 204 - }, 205 205 - { 206 206 - "name": "cmd_reply_addr_3", 207 207 - "is_command": True, "is_write": True, "is_verify": True, 208 208 - "is_ack": True, "is_increment": True, "reply_addr_len": 3, 209 209 - }, 210 210 - { 211 211 - "name": "all_zero", 212 212 - "is_command": False, "is_write": False, "is_verify": False, 213 213 - "is_ack": False, "is_increment": False, "reply_addr_len": 0, 214 214 - }, 215 215 - { 216 216 - "name": "cmd_write_no_ack_no_inc", 217 217 - "is_command": True, "is_write": True, "is_verify": False, 218 218 - "is_ack": False, "is_increment": False, "reply_addr_len": 2, 219 219 - }, 220 220 - ] 221 221 - 222 222 - # 3. RMAP CRC-8 vectors 223 223 - # Known test vectors from ECSS-E-ST-50-52C Annex A Table A-1 224 224 - crc_vectors = [ 225 225 - {"name": "empty", "data": b""}, 226 226 - {"name": "single_zero", "data": b"\x00"}, 227 227 - {"name": "single_ff", "data": b"\xFF"}, 228 228 - {"name": "single_01", "data": b"\x01"}, 229 229 - {"name": "two_bytes", "data": b"\x01\x02"}, 230 230 - {"name": "three_bytes", "data": b"\x01\x02\x03"}, 231 231 - {"name": "ascending_8", "data": bytes(range(8))}, 232 232 - {"name": "ascending_16", "data": bytes(range(16))}, 233 233 - {"name": "all_ff_4", "data": b"\xFF\xFF\xFF\xFF"}, 234 234 - {"name": "all_ff_8", "data": b"\xFF" * 8}, 235 235 - {"name": "alternating", "data": b"\xAA\x55\xAA\x55"}, 236 236 - {"name": "rmap_header_like", "data": b"\xFE\x01\x6C\x00\x67\x00\x00"}, 237 237 - {"name": "long_payload", "data": bytes(range(256))}, 238 238 - ] 239 239 - 240 240 - 241 241 - # --------------------------------------------------------------------------- 242 242 - # Trace writing 243 243 - # --------------------------------------------------------------------------- 244 244 - 245 245 - def write_traces(base_path): 246 246 - os.makedirs(os.path.dirname(base_path) or ".", exist_ok=True) 247 247 - 248 248 - # Packet vectors 249 249 - pkt_path = base_path + "_packets.csv" 250 250 - with open(pkt_path, "w", newline="") as fh: 251 251 - w = csv.writer(fh) 252 252 - w.writerow(["name", "address", "cargo_hex", "eop", "encoded_hex"]) 253 253 - for v in packet_vectors: 254 254 - addr_str = ";".join(str(a) for a in v["address"]) 255 255 - cargo_hex = v["cargo"].hex() 256 256 - encoded = encode_packet(v["address"], v["cargo"], v["eop"]) 257 257 - w.writerow([ 258 258 - v["name"], addr_str, cargo_hex, v["eop"], encoded.hex() 259 259 - ]) 260 260 - print(f"Generated {len(packet_vectors)} packet traces -> {pkt_path}") 261 261 - 262 262 - # Instruction byte vectors 263 263 - instr_path = base_path + "_instructions.csv" 264 264 - with open(instr_path, "w", newline="") as fh: 265 265 - w = csv.writer(fh) 266 266 - w.writerow(["name", "is_command", "is_write", "is_verify", 267 267 - "is_ack", "is_increment", "reply_addr_len", "byte_hex"]) 268 268 - for v in instruction_vectors: 269 269 - byte = encode_instruction( 270 270 - v["is_command"], v["is_write"], v["is_verify"], 271 271 - v["is_ack"], v["is_increment"], v["reply_addr_len"] 272 272 - ) 273 273 - w.writerow([ 274 274 - v["name"], 275 275 - 1 if v["is_command"] else 0, 276 276 - 1 if v["is_write"] else 0, 277 277 - 1 if v["is_verify"] else 0, 278 278 - 1 if v["is_ack"] else 0, 279 279 - 1 if v["is_increment"] else 0, 280 280 - v["reply_addr_len"], 281 281 - "%02x" % byte, 282 282 - ]) 283 283 - print(f"Generated {len(instruction_vectors)} instruction traces -> {instr_path}") 284 284 - 285 285 - # CRC-8 vectors 286 286 - crc_path = base_path + "_crc.csv" 287 287 - with open(crc_path, "w", newline="") as fh: 288 288 - w = csv.writer(fh) 289 289 - w.writerow(["name", "data_hex", "crc_hex"]) 290 290 - for v in crc_vectors: 291 291 - crc = rmap_crc8(v["data"]) 292 292 - w.writerow([v["name"], v["data"].hex(), "%02x" % crc]) 293 293 - print(f"Generated {len(crc_vectors)} CRC traces -> {crc_path}") 294 294 - 295 295 - 296 296 - if __name__ == "__main__": 297 297 - if len(sys.argv) > 1: 298 298 - base = sys.argv[1] 299 299 - else: 300 300 - base = os.path.join(os.path.dirname(__file__), "..", "vectors") 301 301 - write_traces(base)

-364

test/interop/python/test.ml

reviewed

··· 1 1 - (** Python interop tests for ocaml-spacewire. 2 2 - 3 3 - Tests SpaceWire packet encoding and RMAP instruction byte / CRC-8 against a 4 4 - Python reference implementation of ECSS-E-ST-50-12C and ECSS-E-ST-50-52C. 5 5 - 6 6 - Traces generated by: Python (ECSS-E-ST-50-12C / ECSS-E-ST-50-52C reference) 7 7 - Regenerate: dune build ocaml-spacewire/test/interop/python (runs 8 8 - automatically) *) 9 9 - 10 10 - (* {1 Helpers} *) 11 11 - 12 12 - let hex_to_string hex = 13 13 - let len = String.length hex / 2 in 14 14 - String.init len (fun i -> 15 15 - let digit c = 16 16 - if c >= '0' && c <= '9' then Char.code c - Char.code '0' 17 17 - else if c >= 'a' && c <= 'f' then Char.code c - Char.code 'a' + 10 18 18 - else Char.code c - Char.code 'A' + 10 19 19 - in 20 20 - Char.chr ((digit hex.[i * 2] lsl 4) lor digit hex.[(i * 2) + 1])) 21 21 - 22 22 - let string_to_hex s = 23 23 - let buf = Buffer.create (String.length s * 2) in 24 24 - String.iter 25 25 - (fun c -> Buffer.add_string buf (Printf.sprintf "%02x" (Char.code c))) 26 26 - s; 27 27 - Buffer.contents buf 28 28 - 29 29 - let parse_address s = 30 30 - if String.length s = 0 then [] 31 31 - else String.split_on_char ';' s |> List.map int_of_string 32 32 - 33 33 - (* {1 Packet Vectors} *) 34 34 - 35 35 - type packet_vector = { 36 36 - name : string; 37 37 - address : string; 38 38 - cargo_hex : string; 39 39 - eop : string; 40 40 - encoded_hex : string; 41 41 - } 42 42 - 43 43 - let packet_codec = 44 44 - Csvt.( 45 45 - Row.( 46 46 - obj (fun name address cargo_hex eop encoded_hex -> 47 47 - { name; address; cargo_hex; eop; encoded_hex }) 48 48 - |> col "name" string ~enc:(fun r -> r.name) 49 49 - |> col "address" string ~enc:(fun r -> r.address) 50 50 - |> col "cargo_hex" string ~enc:(fun r -> r.cargo_hex) 51 51 - |> col "eop" string ~enc:(fun r -> r.eop) 52 52 - |> col "encoded_hex" string ~enc:(fun r -> r.encoded_hex) 53 53 - |> finish)) 54 54 - 55 55 - let load_packet_vectors () = 56 56 - match Csvt.decode_file packet_codec "vectors_packets.csv" with 57 57 - | Ok rows -> rows 58 58 - | Error e -> Alcotest.failf "CSV decode: %a" Csvt.pp_error e 59 59 - 60 60 - let eop_of_string = function 61 61 - | "EOP" -> Spacewire.EOP 62 62 - | "EEP" -> Spacewire.EEP 63 63 - | s -> Alcotest.failf "bad eop: %s" s 64 64 - 65 65 - let test_packet_encode vectors () = 66 66 - List.iter 67 67 - (fun (v : packet_vector) -> 68 68 - let address = parse_address v.address in 69 69 - let cargo = hex_to_string v.cargo_hex in 70 70 - let eop = eop_of_string v.eop in 71 71 - let p = Spacewire.packet_exn ~address ~cargo eop in 72 72 - let encoded = Spacewire.encode_packet p in 73 73 - let got_hex = string_to_hex encoded in 74 74 - Alcotest.(check string) (v.name ^ ": encode") v.encoded_hex got_hex) 75 75 - vectors 76 76 - 77 77 - let test_packet_decode vectors () = 78 78 - List.iter 79 79 - (fun (v : packet_vector) -> 80 80 - let buf = hex_to_string v.encoded_hex in 81 81 - match Spacewire.decode_packet buf with 82 82 - | Error `Truncated -> 83 83 - Alcotest.failf "%s: decode returned Truncated" v.name 84 84 - | Error `Cargo_empty -> 85 85 - Alcotest.failf "%s: decode returned Cargo_empty" v.name 86 86 - | Ok p -> 87 87 - let expected_addr = parse_address v.address in 88 88 - Alcotest.(check (list int)) 89 89 - (v.name ^ ": address") expected_addr (Spacewire.address p); 90 90 - let expected_cargo = hex_to_string v.cargo_hex in 91 91 - Alcotest.(check string) 92 92 - (v.name ^ ": cargo") expected_cargo (Spacewire.cargo p); 93 93 - let expected_eop = eop_of_string v.eop in 94 94 - Alcotest.(check bool) 95 95 - (v.name ^ ": eop") true 96 96 - (Spacewire.eop p = expected_eop)) 97 97 - vectors 98 98 - 99 99 - let test_packet_roundtrip vectors () = 100 100 - List.iter 101 101 - (fun (v : packet_vector) -> 102 102 - let address = parse_address v.address in 103 103 - let cargo = hex_to_string v.cargo_hex in 104 104 - let eop = eop_of_string v.eop in 105 105 - let p = Spacewire.packet_exn ~address ~cargo eop in 106 106 - let encoded = Spacewire.encode_packet p in 107 107 - match Spacewire.decode_packet encoded with 108 108 - | Error _ -> Alcotest.failf "%s: roundtrip decode failed" v.name 109 109 - | Ok decoded -> 110 110 - Alcotest.(check bool) 111 111 - (v.name ^ ": roundtrip") true 112 112 - (Spacewire.equal_packet p decoded)) 113 113 - vectors 114 114 - 115 115 - (* {1 RMAP Instruction Vectors} *) 116 116 - 117 117 - type instruction_vector = { 118 118 - instr_name : string; 119 119 - is_command : bool; 120 120 - is_write : bool; 121 121 - is_verify : bool; 122 122 - is_ack : bool; 123 123 - is_increment : bool; 124 124 - reply_addr_len : int; 125 125 - byte_hex : string; 126 126 - } 127 127 - 128 128 - let instruction_codec = 129 129 - Csvt.( 130 130 - Row.( 131 131 - obj 132 132 - (fun 133 133 - instr_name 134 134 - is_command 135 135 - is_write 136 136 - is_verify 137 137 - is_ack 138 138 - is_increment 139 139 - reply_addr_len 140 140 - byte_hex 141 141 - -> 142 142 - { 143 143 - instr_name; 144 144 - is_command; 145 145 - is_write; 146 146 - is_verify; 147 147 - is_ack; 148 148 - is_increment; 149 149 - reply_addr_len; 150 150 - byte_hex; 151 151 - }) 152 152 - |> col "name" string ~enc:(fun r -> r.instr_name) 153 153 - |> col "is_command" bool ~enc:(fun r -> r.is_command) 154 154 - |> col "is_write" bool ~enc:(fun r -> r.is_write) 155 155 - |> col "is_verify" bool ~enc:(fun r -> r.is_verify) 156 156 - |> col "is_ack" bool ~enc:(fun r -> r.is_ack) 157 157 - |> col "is_increment" bool ~enc:(fun r -> r.is_increment) 158 158 - |> col "reply_addr_len" int ~enc:(fun r -> r.reply_addr_len) 159 159 - |> col "byte_hex" string ~enc:(fun r -> r.byte_hex) 160 160 - |> finish)) 161 161 - 162 162 - let load_instruction_vectors () = 163 163 - match Csvt.decode_file instruction_codec "vectors_instructions.csv" with 164 164 - | Ok rows -> rows 165 165 - | Error e -> Alcotest.failf "CSV decode: %a" Csvt.pp_error e 166 166 - 167 167 - (* Build an rmap_command with the given flags, just for instruction encoding. 168 168 - We use dummy values for fields that don't affect the instruction byte. *) 169 169 - let make_test_command ~is_write ~is_verify ~is_ack ~is_increment ~reply_addr_len 170 170 - = 171 171 - let command : Spacewire.rmap_command_code = 172 172 - match (is_write, is_verify) with 173 173 - | false, false -> Read 174 174 - | true, false -> Write 175 175 - | true, true -> Write_verify 176 176 - | false, true -> Read_modify_write 177 177 - in 178 178 - let ack : Spacewire.rmap_ack = if is_ack then Ack else No_ack in 179 179 - let increment : Spacewire.rmap_increment = 180 180 - if is_increment then Increment else No_increment 181 181 - in 182 182 - (* reply_addr_len is in 4-byte units; create that many dummy bytes *) 183 183 - let reply_address = List.init (reply_addr_len * 4) (fun _ -> 1) in 184 184 - Spacewire.rmap_command_exn ~command ~ack ~increment ~key:0 ~reply_address 185 185 - ~initiator_logical_address:0 ~transaction_id:0 ~address:0L ~data_length:0 () 186 186 - 187 187 - let test_instruction_encode_via_command vectors () = 188 188 - (* For command instructions (is_command=true), we can test via 189 189 - encode_rmap_command and check byte 2 of the output. *) 190 190 - List.iter 191 191 - (fun (v : instruction_vector) -> 192 192 - if v.is_command then begin 193 193 - let cmd = 194 194 - make_test_command ~is_write:v.is_write ~is_verify:v.is_verify 195 195 - ~is_ack:v.is_ack ~is_increment:v.is_increment 196 196 - ~reply_addr_len:v.reply_addr_len 197 197 - in 198 198 - let encoded = 199 199 - Spacewire.encode_rmap_command ~target_logical_address:0 cmd 200 200 - in 201 201 - (* Byte 2 is the instruction byte *) 202 202 - let got = Char.code encoded.[2] in 203 203 - let expected = int_of_string ("0x" ^ v.byte_hex) in 204 204 - Alcotest.(check int) (v.instr_name ^ ": instruction byte") expected got 205 205 - end) 206 206 - vectors 207 207 - 208 208 - let test_instruction_encode_via_reply vectors () = 209 209 - (* For reply instructions (is_command=false), we test via 210 210 - encode_rmap_reply and check byte 2 of the output. 211 211 - Note: encode_rmap_reply hardcodes ack=true, increment=true, 212 212 - reply_addr_len=0, so we only check vectors matching those. *) 213 213 - List.iter 214 214 - (fun (v : instruction_vector) -> 215 215 - if 216 216 - (not v.is_command) && v.is_ack && v.is_increment && v.reply_addr_len = 0 217 217 - then begin 218 218 - let command : Spacewire.rmap_command_code = 219 219 - match (v.is_write, v.is_verify) with 220 220 - | false, false -> Read 221 221 - | true, false -> Write 222 222 - | true, true -> Write_verify 223 223 - | false, true -> Read_modify_write 224 224 - in 225 225 - let rpl = 226 226 - Spacewire.rmap_reply ~command ~status:Success 227 227 - ~initiator_logical_address:0 ~transaction_id:0 () 228 228 - in 229 229 - let encoded = 230 230 - Spacewire.encode_rmap_reply ~target_logical_address:0 rpl 231 231 - in 232 232 - let got = Char.code encoded.[2] in 233 233 - let expected = int_of_string ("0x" ^ v.byte_hex) in 234 234 - Alcotest.(check int) 235 235 - (v.instr_name ^ ": reply instruction byte") 236 236 - expected got 237 237 - end) 238 238 - vectors 239 239 - 240 240 - let test_instruction_decode_via_command vectors () = 241 241 - (* For command instructions, encode then decode and verify fields match. *) 242 242 - List.iter 243 243 - (fun (v : instruction_vector) -> 244 244 - if v.is_command then begin 245 245 - let cmd = 246 246 - make_test_command ~is_write:v.is_write ~is_verify:v.is_verify 247 247 - ~is_ack:v.is_ack ~is_increment:v.is_increment 248 248 - ~reply_addr_len:v.reply_addr_len 249 249 - in 250 250 - let encoded = 251 251 - Spacewire.encode_rmap_command ~target_logical_address:0xFE cmd 252 252 - in 253 253 - match Spacewire.decode_rmap_command encoded with 254 254 - | Error _ -> 255 255 - Alcotest.failf "%s: decode_rmap_command failed" v.instr_name 256 256 - | Ok (target, decoded) -> 257 257 - Alcotest.(check int) (v.instr_name ^ ": target") 0xFE target; 258 258 - let expected_code : Spacewire.rmap_command_code = 259 259 - match (v.is_write, v.is_verify) with 260 260 - | false, false -> Read 261 261 - | true, false -> Write 262 262 - | true, true -> Write_verify 263 263 - | false, true -> Read_modify_write 264 264 - in 265 265 - Alcotest.(check bool) 266 266 - (v.instr_name ^ ": cmd_code") 267 267 - true 268 268 - (Spacewire.rmap_cmd_code decoded = expected_code); 269 269 - let expected_ack : Spacewire.rmap_ack = 270 270 - if v.is_ack then Ack else No_ack 271 271 - in 272 272 - Alcotest.(check bool) 273 273 - (v.instr_name ^ ": ack") true 274 274 - (Spacewire.rmap_cmd_ack decoded = expected_ack); 275 275 - let expected_inc : Spacewire.rmap_increment = 276 276 - if v.is_increment then Increment else No_increment 277 277 - in 278 278 - Alcotest.(check bool) 279 279 - (v.instr_name ^ ": increment") 280 280 - true 281 281 - (Spacewire.rmap_cmd_increment decoded = expected_inc) 282 282 - end) 283 283 - vectors 284 284 - 285 285 - (* {1 RMAP CRC-8 Vectors} *) 286 286 - 287 287 - type crc_vector = { crc_name : string; data_hex : string; crc_hex : string } 288 288 - 289 289 - let crc_codec = 290 290 - Csvt.( 291 291 - Row.( 292 292 - obj (fun crc_name data_hex crc_hex -> { crc_name; data_hex; crc_hex }) 293 293 - |> col "name" string ~enc:(fun r -> r.crc_name) 294 294 - |> col "data_hex" string ~enc:(fun r -> r.data_hex) 295 295 - |> col "crc_hex" string ~enc:(fun r -> r.crc_hex) 296 296 - |> finish)) 297 297 - 298 298 - let load_crc_vectors () = 299 299 - match Csvt.decode_file crc_codec "vectors_crc.csv" with 300 300 - | Ok rows -> rows 301 301 - | Error e -> Alcotest.failf "CSV decode: %a" Csvt.pp_error e 302 302 - 303 303 - let test_crc vectors () = 304 304 - List.iter 305 305 - (fun (v : crc_vector) -> 306 306 - let data = hex_to_string v.data_hex in 307 307 - let got = Spacewire.rmap_crc data in 308 308 - let expected = int_of_string ("0x" ^ v.crc_hex) in 309 309 - Alcotest.(check int) (v.crc_name ^ ": crc8") expected got) 310 310 - vectors 311 311 - 312 312 - let test_crc_bytes vectors () = 313 313 - List.iter 314 314 - (fun (v : crc_vector) -> 315 315 - let data = hex_to_string v.data_hex in 316 316 - let buf = Bytes.of_string data in 317 317 - let got = Spacewire.rmap_crc_bytes buf 0 (Bytes.length buf) in 318 318 - let expected = int_of_string ("0x" ^ v.crc_hex) in 319 319 - Alcotest.(check int) (v.crc_name ^ ": crc8_bytes") expected got) 320 320 - vectors 321 321 - 322 322 - (* {1 Runner} *) 323 323 - 324 324 - let () = 325 325 - let pkt_vectors = load_packet_vectors () in 326 326 - let instr_vectors = load_instruction_vectors () in 327 327 - let crc_vectors = load_crc_vectors () in 328 328 - Alcotest.run "spacewire-interop-python" 329 329 - [ 330 330 - ( "packet-encode", 331 331 - [ 332 332 - Alcotest.test_case "encode matches reference" `Quick 333 333 - (test_packet_encode pkt_vectors); 334 334 - ] ); 335 335 - ( "packet-decode", 336 336 - [ 337 337 - Alcotest.test_case "decode reference packets" `Quick 338 338 - (test_packet_decode pkt_vectors); 339 339 - ] ); 340 340 - ( "packet-roundtrip", 341 341 - [ 342 342 - Alcotest.test_case "encode-decode roundtrip" `Quick 343 343 - (test_packet_roundtrip pkt_vectors); 344 344 - ] ); 345 345 - ( "rmap-instruction-encode", 346 346 - [ 347 347 - Alcotest.test_case "command instruction byte" `Quick 348 348 - (test_instruction_encode_via_command instr_vectors); 349 349 - Alcotest.test_case "reply instruction byte" `Quick 350 350 - (test_instruction_encode_via_reply instr_vectors); 351 351 - ] ); 352 352 - ( "rmap-instruction-decode", 353 353 - [ 354 354 - Alcotest.test_case "command roundtrip decode" `Quick 355 355 - (test_instruction_decode_via_command instr_vectors); 356 356 - ] ); 357 357 - ( "rmap-crc8", 358 358 - [ 359 359 - Alcotest.test_case "rmap_crc matches reference" `Quick 360 360 - (test_crc crc_vectors); 361 361 - Alcotest.test_case "rmap_crc_bytes matches reference" `Quick 362 362 - (test_crc_bytes crc_vectors); 363 363 - ] ); 364 364 - ]