text stringlengths 12 786k |
|---|
let child mcast_addr join fd = if join then Lwt_unix . mcast_add_membership fd ( Unix . inet_addr_of_string mcast_addr ) ; let buf = Bytes . create 50 in Lwt_unix . with_timeout 1 . ( fun ( ) -> Lwt_unix . read fd buf 0 ( Bytes . length buf ) ) >>= fun n -> if debug then Printf .... |
let parent mcast_addr mcast_port set_loop fd = Lwt_unix . mcast_set_loop fd set_loop ; let addr = Lwt_unix . ADDR_INET ( Unix . inet_addr_of_string mcast_addr , mcast_port ) in Lwt_unix . sendto fd hello 0 ( Bytes . length hello ) [ ] addr >>= fun _ -> if debug then Printf . printf " ... |
let test_mcast name join set_loop = test name ~ only_if ( : fun ( ) -> not Sys . win32 ) begin fun ( ) -> let mcast_addr = mcast_addr ( ) in let mcast_port = mcast_port ( ) in let should_timeout = not join || not set_loop in let fd1 = Lwt_unix . ( socket PF_INET SOCK_DGRAM 0 ) in ... |
let suite = suite " unix_mcast " [ test_mcast " mcast - join - loop " true true ; test_mcast " mcast - nojoin - loop " false true ; test_mcast " mcast - join - noloop " true false ; test_mcast " mcast - nojoin - noloop " false false ; ] |
let test ( type t ) ( t : t ) ( module M : Binable . S with type t = t ) = print_s [ % sexp ( digest_bin_prot M . bin_writer_t t : Md5 . t ) ] in test ( ) ( module Unit ) ; test 1337 ( module Int ) ; [ % expect { | 93b885adfe0da089cdf634904fd59f71 22eaa1d1a43daf2a... |
let with_log_group ? closed msg f = Console . group ? closed msg ; f ( ) ; Console . group_end ( ) |
let dump_track t = with_log_group ~ closed : true Console . [ str " Track " ; : t ] @@ fun ( ) -> if Jv . has " getCapabilities " t then Console . ( log [ str " Caps " ; : Media . Track . get_capabilities t ] ) else Console . ( log [ str " Caps : getCapabilities... |
let dump_stream av = with_log_group Console . [ str " Stream " ; : av ] @@ fun ( ) -> List . iter dump_track ( Media . Stream . get_tracks av ) |
let dump_devices ds = with_log_group Console . ( [ str " Devices " ] ) @@ fun ( ) -> List . iter ( fun d -> Console . ( log [ d ] ) ) ds |
let handle_error ~ view = function let err = Jv . Error . message e in let ui_msg = match Jv . Error . enum e with | ` Not_allowed_error -> Jstr . v " Can ' t do anything without your permission ! " | ` Not_found_error -> Jstr . v " Don ' t have a camera ? " | _ -> Jstr . v " ... |
let button ? at onclick label = let but = El . button ? at [ El . txt ( Jstr . v label ) ] in Ev . listen Ev . click ( fun _e -> onclick ( ) ) ( El . as_target but ) ; but |
let fullscreen_button ~ view video = let no_fullscreen = not ( Document . fullscreen_available G . document ) in let at = At . add_if no_fullscreen At . disabled [ ] in let onclick ( ) = ignore @@ Fut . map ( handle_error ~ view ) ( El . request_fullscreen video ) in button ~ at ... |
let stop_stream ~ view s = List . iter Media . Track . stop ( Media . Stream . get_tracks s ) ; El . set_children view [ ] |
let play_stream ~ view s = let at = [ At . true ' ( Jstr . v " playsinline " ) ] in let video = El . video ~ at [ El . txt ' " No video stream . " ] in let m = Media . El . of_el video in let fullscreen = fullscreen_button ~ view video in let stop = button ( fun ( ) ... |
let test_stream ~ view kind stream ( ) = let get_media = match kind with | ` Camera -> Media . Devices . get_user_media | ` Screen -> Media . Devices . get_display_media in ignore @@ Fut . map ( handle_error ~ view ) @@ let md = Media . Devices . of_navigator G . navigator in let ... |
let main ( ) = let h1 = El . h1 [ El . txt ' " Media test " ] in let info = El . txt ' " Media information is dumped in the browser console . " in let stream = ref None in let view = El . p [ ] in let cam = button ( test_stream ~ view ` Camera stream ) " Open camera " ... |
let ( ) = main ( ) |
( module struct let count = ref 0 let f = general ~ cache_size_bound : 3 ( fun i -> incr count ; i ) ; ; let % test _ = f 0 = 0 let % test _ = ! count = 1 let % test _ = f 1 = 1 let % test _ = ! count = 2 let % test _ = f 0 = 0 let % test _ = ! count = 2 let % tes... |
let create_block2 ctxt = Context . add ctxt [ " a " ; " b " ] ( Bytes . of_string " Novembre " ) >>= fun ctxt -> Context . add ctxt [ " a " ; " c " ] ( Bytes . of_string " Juin " ) >>= fun ctxt -> Context . add ctxt [ " version " ] ( Bytes . of_stri... |
let create_block3a ctxt = Context . remove ctxt [ " a " ; " b " ] >>= fun ctxt -> Context . add ctxt [ " a " ; " d " ] ( Bytes . of_string " Mars " ) >>= fun ctxt -> Lwt . return ctxt |
let create_block3b ctxt = Context . remove ctxt [ " a " ; " c " ] >>= fun ctxt -> Context . add ctxt [ " a " ; " d " ] ( Bytes . of_string " Février " ) >>= fun ctxt -> Lwt . return ctxt |
type t = { genesis : Context . t ; block2 : Context . t ; block3a : Context . t ; block3b : Context . t ; } |
let wrap_context_init f _ ( ) = let genesis = Memory_context . empty in create_block2 genesis >>= fun block2 -> create_block3a block2 >>= fun block3a -> create_block3b block2 >>= fun block3b -> f { genesis ; block2 ; block3a ; block3b } >>= fun result -> Lwt . return result |
let c = function None -> None | Some s -> Some ( Bytes . to_string s ) |
let test_simple { block2 = ctxt ; _ } = Context . find ctxt [ " version " ] >>= fun version -> Assert . equal_string_option ~ msg : __LOC__ ( c version ) ( Some " 0 . 0 " ) ; Context . find ctxt [ " a " ; " b " ] >>= fun novembre -> Assert . equal_string_o... |
let test_continuation { block3a = ctxt ; _ } = Context . find ctxt [ " version " ] >>= fun version -> Assert . equal_string_option ~ msg : __LOC__ ( Some " 0 . 0 " ) ( c version ) ; Context . find ctxt [ " a " ; " b " ] >>= fun novembre -> Assert . is_none... |
let test_fork { block3b = ctxt ; _ } = Context . find ctxt [ " version " ] >>= fun version -> Assert . equal_string_option ~ msg : __LOC__ ( Some " 0 . 0 " ) ( c version ) ; Context . find ctxt [ " a " ; " b " ] >>= fun novembre -> Assert . equal_string_op... |
let test_replay { genesis = ctxt0 ; _ } = Context . add ctxt0 [ " version " ] ( Bytes . of_string " 0 . 0 " ) >>= fun ctxt1 -> Context . add ctxt1 [ " a " ; " b " ] ( Bytes . of_string " Novembre " ) >>= fun ctxt2 -> Context . add ctxt2 [ " a " ; ... |
let fold_keys s root ~ init ~ f = Context . fold s root ~ order ` : Sorted ~ init ~ f ( : fun k v acc -> match Context . Tree . kind v with | ` Value -> f ( root @ k ) acc | ` Tree -> Lwt . return acc ) |
let keys t = fold_keys t ~ init [ ] : ~ f ( : fun k acc -> Lwt . return ( k :: acc ) ) |
let test_fold_keys { genesis = ctxt ; _ } = Context . add ctxt [ " a " ; " b " ] ( Bytes . of_string " Novembre " ) >>= fun ctxt -> Context . add ctxt [ " a " ; " c " ] ( Bytes . of_string " Juin " ) >>= fun ctxt -> Context . add ctxt [ " a " ; ... |
let test_fold { genesis = ctxt ; _ } = let foo1 = Bytes . of_string " foo1 " in let foo2 = Bytes . of_string " foo2 " in Context . add ctxt [ " foo " ; " toto " ] foo1 >>= fun ctxt -> Context . add ctxt [ " foo " ; " bar " ; " toto " ] foo2 >>= fun ctxt -... |
let steps = [ " 00 " ; " 01 " ; " 02 " ; " 03 " ; " 05 " ; " 06 " ; " 07 " ; " 09 " ; " 0a " ; " 0b " ; " 0c " ; " 0e " ; " 0f " ; " 10 " ; " 11 " ; " 12 " ; " 13 " ; " 14 " ; " 15 " ; ... |
let bindings = let zero = Bytes . make 10 ' 0 ' in List . map ( fun x -> ( [ " root " ; x ] , zero ) ) steps |
let test_fold_order { genesis = ctxt ; _ } = Lwt_list . fold_left_s ( fun ctxt ( k , v ) -> Context . add ctxt k v ) ctxt bindings >>= fun ctxt -> fold_keys ctxt [ " root " ] ~ init [ ] : ~ f ( : fun k acc -> Lwt . return ( k :: acc ) ) >>= fun bs -> let bs = Lis... |
let test_trees { genesis = ctxt ; _ } = Context . Tree . fold ~ depth ( ` : Eq 1 ) ~ order ` : Sorted ~ init ( ) : ( Context . Tree . empty ctxt ) [ ] ~ f ( : fun k _ ( ) -> assert ( Compare . List_length_with . ( k = 1 ) ) ; Assert . fail_msg " ... |
module StringListOrd : Stdlib . Set . OrderedType with type t = string list = struct type t = string list let compare = Stdlib . compare end |
module StringListSet = Set . Make ( StringListOrd ) |
module PP = struct let key ppf k = let atom_pp fmt s = Format . fprintf fmt " % s " s in Format . pp_print_list atom_pp ppf ~ pp_sep ( : fun fmt ( ) -> Format . fprintf fmt " " ) -> k let domain ppf d = let l = StringListSet . to_seq d |> List . of_seq in Format . pp_print_list ke... |
let domain ctxt = keys ctxt [ ] |
let check_eq_domains d1 d2 = let eq d d ' = StringListSet . subset d d ' && StringListSet . subset d ' d in Assert . equal ~ eq ~ prn : PP . domain_to_string d1 d2 |
let test_domain0 ( ) = let b0 = Bytes . of_string " 0 " in let k1 = [ " a " ] in let k2 = [ " b " ] in let k3 = [ " c " ] in let ctxt = Memory_context . empty in Context . add ctxt k1 b0 >>= fun ctxt -> Context . add ctxt k2 b0 >>= fun ctxt -> Context . add ctxt k3 b... |
let test_domain1 ( ) = let b0 = Bytes . of_string " 0 " in let k1 = [ " a " ; " b " ] in let k2 = [ " a " ; " c " ; " d " ] in let ctxt = Memory_context . empty in Context . add ctxt k1 b0 >>= fun ctxt -> Context . add ctxt k2 b0 >>= fun ctxt -> let expected_d... |
let test_domain2 ( ) = let b0 = Bytes . of_string " 0 " in let k1 = [ " a " ; " b " ] in let k2 = [ " a " ; " c " ; " d " ] in let k3 = [ " a " ; " c " ; " e " ] in let k4 = [ " x " ] in let ctxt = Memory_context . empty in Context . ad... |
let tests = [ ( " simple " , test_simple ) ; ( " continuation " , test_continuation ) ; ( " fork " , test_fork ) ; ( " replay " , test_replay ) ; ( " fold_keys " , test_fold_keys ) ; ( " fold " , test_fold ) ; ( " fold order " , test_fol... |
let domain_tests = [ ( " domain0 " , test_domain0 ) ; ( " domain1 " , test_domain1 ) ; ( " domain2 " , test_domain2 ) ; ] |
let tests = List . map ( fun ( n , f ) -> Alcotest_lwt . test_case n ` Quick ( wrap_context_init f ) ) tests @ List . map ( fun ( n , f ) -> Alcotest_lwt . test_case n ` Quick ( fun _ _ -> f ( ) ) ) domain_tests |
let equal_key : key -> key -> bool = fun ( a : string list ) ( b : string list ) -> Stdlib . ( = ) a b |
let key_arb = QCheck . small_list QCheck . string |
let value_arb = QCheck . map ~ rev : Bytes . to_string Bytes . of_string QCheck . string |
let key_value_arb = QCheck . pair key_arb value_arb |
let context_arb : Context . t QCheck . arbitrary = let set_all key_value_list = Lwt_main . run @@ Lwt_list . fold_left_s ( fun ctxt ( k , v ) -> Context . add ctxt k v ) Memory_context . empty key_value_list in let rev ctxt = let keys = Lwt_main . run @@ Test_mem_context . domain ctxt ... |
let pp_print_value fmt v = Format . fprintf fmt " % s " ( Bytes . to_string v ) |
let test_domain_spec ( ctxt , k ) = if k = [ ] then QCheck . assume_fail ( ) else let domain = Lwt_main . run @@ Test_mem_context . domain ctxt in qcheck_eq ~ pp : Format . pp_print_bool ( Lwt_main . run @@ Context . mem ctxt k ) ( List . mem ~ equal : equal_key k domain ) |
let test_get_set ( ctxt , ( k , v ) ) = let ctxt ' = Lwt_main . run @@ Context . add ctxt k v in let at_k = Lwt_main . run @@ Context . find ctxt ' k in qcheck_eq ' ~ pp ( : Format . pp_print_option pp_print_value ) ~ expected ( : Some v ) ~ actual : at_k ( ) |
let test_get_set_other ( ctxt , ( k1 , v ) ) = let ctxt ' = Lwt_main . run @@ Context . add ctxt k1 v in let keys = Lwt_main . run @@ Test_mem_context . domain ctxt ' in let check_key k2 = if k1 = k2 then true else let v_before = Lwt_main . run @@ Context . find ctxt k2 in let v_aft... |
let test_set_domain ( ctxt , ( k , v ) ) = let domain = Lwt_main . run @@ Test_mem_context . domain ctxt in let ctxt ' = Lwt_main . run @@ Context . add ctxt k v in let domain ' = Lwt_main . run @@ Test_mem_context . domain ctxt ' in List . for_all ( fun in_domain ' -> equal_... |
let ( ) = let test_domain = QCheck . Test . make ~ name " : Test_mem_context . domain ' s specification " ( QCheck . pair context_arb key_arb ) test_domain_spec in let test_set = QCheck . Test . make ~ name " : get ( set m k v ) k = v " ( QCheck . pair context_arb key_value... |
module Storage = Storage . Make_Storage ( Core ) |
let ba_of_hex h = Hex . to_bytes_exn ( ` Hex h ) |
let ba_of_hex_be h = let reverse s = let l = Bytes . length s in let res = Bytes . create l in Bytes . fill res 0 ( Bytes . length res ) ' 0 ' ; for i = 0 to l - 1 do Bytes . set res ( l - 1 - i ) ( Bytes . get s i ) done ; res in reverse ( ba_of_hex h ) |
let test_hash ( ) = let open R in let a = to_hash ( ba_of_hex_be " 87a086ae7d2252d58729b30263fb7b66308bf94ef59a76c9c86e7ea016536505 " ) in let b = to_hash ( ba_of_hex_be " a75b84a125b2353da7e8d96ee2a15efe4de23df9601b9d9564ba59de57130406 " ) in let result = to_hash ( ba_of_hex_be " 5bf43b573... |
let test_merkle ( ) = let open Storage . Tree in let hash1 = Core . Commitment . of_bytes_exn @@ ba_of_hex " 87a086ae7d2252d58729b30263fb7b66308bf94ef59a76c9c86e7ea016536505 " in let hash2 = Core . Commitment . of_bytes_exn @@ ba_of_hex " a75b84a125b2353da7e8d96ee2a15efe4de23df9601b9d9564ba59d... |
let test_merkle2 ( ) = let open Storage . Tree in let uncommitted_cm = Core . Hash . of_bytes_exn @@ ba_of_hex " 0100000000000000000000000000000000000000000000000000000000000000 " in let witness_unflat = Array . make 32 uncommitted_cm in Array . iteri ( fun i x -> if i < 31 then witness_unf... |
let test_merkle3 ( ) = let open Storage . Tree in let cm = Core . Hash . ( to_commitment @@ uncommitted ~ height : 0 ) in let runs = 200L in assert ( get_root empty = Core . Hash . uncommitted ~ height : 32 ) ; let rec loop t pos = if pos > runs then ( ) else let t = add t [ ... |
let test_batch_insertion ( ) = let open Storage . Tree in let random_cm ( ) = Core . Commitment . of_bytes_exn ( Hacl . Rand . gen 32 ) in let random_cms = List . init 33 ( fun _ -> random_cm ( ) ) in let partial_trees = List . fold_left ( fun list_tree cm -> add ( List . ... |
let bench_batch_insertion ( ) = let open Storage . Tree in let random_cm ( ) = Core . Commitment . of_bytes_exn ( Hacl . Rand . gen 32 ) in let random_cms = List . init 33 ( fun _ -> random_cm ( ) ) in let start = Unix . gettimeofday ( ) in let single_insert = List . fol... |
let tests = [ ( " hash " , ` Quick , test_hash ) ; ( " merkle " , ` Quick , test_merkle ) ; ( " merkle2 " , ` Quick , test_merkle2 ) ; ( " merkle3 " , ` Quick , test_merkle3 ) ; ( " test_batch_insertion " , ` Quick , test_batch_insertion ) ... |
let ( ) = Alcotest . run " sapling " [ ( " merkle " , tests ) ] |
let pp_ident_reply ppf reply = [ % yojson_of : Merlin . ident_reply ] reply |> Yojson . Safe . to_string |> pp_print_string ppf |
let occurrences ~ pos merlin code = Merlin . occurrences merlin code ~ pos |> Lwt_main . run |
let test_occurrences ctxt = let require ? msg x y = assert_equal ~ ctxt ~ printer [ :% show : ident_reply list ] ? msg x y in let merlin = Merlin . create ( ) in let code = " let _ = Lwt_m " in let expected = Merlin . ( [ { id_start = { id_line = 1 ; id_col = 8 ; } ; id... |
let test_abs_position ctxt = let require ? msg x y = assert_equal ~ ctxt ~ printer [ :% show : int ] ? msg x y in let code = " let x = 15 \ nlet y = 42 \ nlet z = Lwt_m \ nlet w = 123 " in let actual = Merlin . ( abs_position code { id_line = 1 ; id_col = 0 ; } ) in require... |
let pp_reply ppf reply = [ % yojson_of : Merlin . reply ] reply |> Yojson . Safe . to_string |> fprintf ppf " % s " |
let complete ? doc ? types merlin ~ pos code = let reply = Lwt_main . run ( Merlin . complete ? doc ? types ~ pos merlin code ) in Merlin . ( { reply with cmpl_candidates = List . sort compare reply . cmpl_candidates } ) |
let test_complete ctxt = let require ? msg x y = assert_equal ~ ctxt ~ printer [ :% show : reply ] ? msg x y in let merlin = Merlin . create ( ) in let code = " List " in let expected = Merlin . { cmpl_start = 0 ; cmpl_end = 4 ; cmpl_candidates = [ { cmpl_name = " List " ;... |
let suite = " Merlin " >::: [ " occurrences " >:: test_occurrences ; " abs_position " >:: test_abs_position ; " complete " >:: test_complete ; ] |
let test_extract_prefix = let test ~ msg ~ input ~ expected_output _ = let parsed = M . extract_prefix input in assert_equal ~ msg parsed expected_output in " test_extract_prefix " >::: [ " test_no_prefix " >:: test ~ msg " : Parsing a message with no prefix " ~ input " : PING : server ... |
let test_extract_trail = let test ~ msg ~ input ~ expected_output _ = let parsed = M . extract_trail input in assert_equal ~ msg parsed expected_output in " test_extract_trail " >::: [ " test_no_trail " >:: test ~ msg " : Parsing a message with no trail " ~ input " : PING " ~ expected... |
let test_full_parser = let test ~ msg ~ input ~ expected_output _ = let parsed = M . parse input in assert_equal ~ msg parsed expected_output in " test_full_parser " >::: [ " test_parse_ping " >:: test ~ msg " : Parsing a PING message " ~ input " : PING : abc . def " ~ expected_out... |
let suite = " test_message " >::: [ test_extract_prefix ; test_extract_trail ; test_full_parser ; ] |
module Enum = struct module E = ( val enum " Enum " ) let one = E . constant " one " 1_l let two = E . constant " two " 2_l end |
module Small = struct module S = ( val message " Small " ) let s = S . optional string " small_s " 100 let i = S . optional int64 " small_i " 200 end |
module TwoString = struct module T = ( val message " TwoString " ) let s = T . required string " two_s " 1000 let b = T . required string " two_b " 2000 end |
module Comprehensive = struct module C = ( val message " Comprehensive " ) let repeated_uint32 = C . repeated uint32 " repeated_uint32 " 1 let required_int32 = C . required int32 " required_int32 " 2 let required_Small = C . required ( msg Small . S . t ) " required_Small " 3 l... |
module type S = sig val recv : unit -> string list val send : string list -> unit end |
module MakeMockChannel ( Mock : S ) = Message_channel . Make ( Jupyter . Shell ) ( struct type t = unit and input = string list and output = string list let create ~ ctx : _ ~ kind : _ _ = ( ) let close ( ) = Lwt . return_unit let recv ( ) = Lwt . return @@ Mock . recv ( ... |
let test_recv ctxt = let open Fixture . KernelInfoRequest in let module Channel = MakeMockChannel ( struct let send _ = assert false let recv ( ) = zmq_ids @ [ " < IDS | MSG " ; > hmac ; header ; parent_header ; metadata ; content ; ] @ buffers end ) in let channel = Channel . ... |
let test_send ctxt = let open Fixture . KernelInfoReply in let module Channel = MakeMockChannel ( struct let recv ( ) = assert false let send = function | [ " < IDS | MSG " ; > hm ; hdr ; par ; meta ; cnt ] -> assert_equal ~ ctxt ~ printer [ :% show : string ] hmac hm ; asse... |
let suite = " MessageChannel " >::: [ " recv " >:: test_recv ; " send " >:: test_send ; ] |
let print expr : string = expr |> Micheline_printer . printable ( fun s -> s ) |> Format . asprintf " % a " Micheline_printer . print_expr |
let assert_expands ( original : ( Micheline_parser . location , string ) Micheline . node ) ( expanded : ( Micheline_parser . location , string ) Micheline . node ) = let ( { Michelson_v1_parser . expanded = expansion ; _ } , errors ) = let source = print ( Micheline .... |
let left_branch = Seq ( zero_loc , [ Prim ( zero_loc , " SWAP " , [ ] , [ ] ) ] ) |
let right_branch = Seq ( zero_loc , [ ] ) |
let assert_compare_macro prim_name compare_name = assert_expands ( Prim ( zero_loc , prim_name , [ ] , [ ] ) ) ( Seq ( zero_loc , [ Prim ( zero_loc , " COMPARE " , [ ] , [ ] ) ; Prim ( zero_loc , compare_name , [ ] , [ ] ) ; ] ) ) |
let test_compare_marco_expansion ( ) = assert_compare_macro " CMPEQ " " EQ " >>? fun ( ) -> assert_compare_macro " CMPNEQ " " NEQ " >>? fun ( ) -> assert_compare_macro " CMPLT " " LT " >>? fun ( ) -> assert_compare_macro " CMPGT " " GT " >>? fun ( ) -> assert... |
let assert_if_macro prim_name compare_name = assert_expands ( Prim ( zero_loc , prim_name , [ left_branch ; right_branch ] , [ ] ) ) ( Seq ( zero_loc , [ Prim ( zero_loc , compare_name , [ ] , [ ] ) ; Prim ( zero_loc , " IF " , [ left_branch ; right_bra... |
let test_if_compare_macros_expansion ( ) = assert_if_macro " IFEQ " " EQ " >>? fun ( ) -> assert_if_macro " IFNEQ " " NEQ " >>? fun ( ) -> assert_if_macro " IFLT " " LT " >>? fun ( ) -> assert_if_macro " IFGT " " GT " >>? fun ( ) -> assert_if_macro " IFLE "... |
let assert_if_cmp_macros prim_name compare_name = assert_expands ( Prim ( zero_loc , prim_name , [ left_branch ; right_branch ] , [ ] ) ) ( Seq ( zero_loc , [ Prim ( zero_loc , " COMPARE " , [ ] , [ ] ) ; Prim ( zero_loc , compare_name , [ ] , [ ] ... |
let test_if_cmp_macros_expansion ( ) = assert_if_cmp_macros " IFCMPEQ " " EQ " >>? fun ( ) -> assert_if_cmp_macros " IFCMPNEQ " " NEQ " >>? fun ( ) -> assert_if_cmp_macros " IFCMPLT " " LT " >>? fun ( ) -> assert_if_cmp_macros " IFCMPGT " " GT " >>? fun ( ) -... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.