text stringlengths 12 786k |
|---|
let run_tests = [ test " Lwt_main . run : nested call " ~ sequential : true begin fun ( ) -> Lwt . pause ( ) >>= fun ( ) -> try Lwt_main . run ( Lwt . return ( ) ) ; Lwt . return false with Failure _ -> Lwt . return true end ; ] |
let tests = tests @ run_tests |
let suite = suite " lwt_engine " tests |
let suite = suite " lwt_event " [ test " to_stream " ( fun ( ) -> let event , push = React . E . create ( ) in let stream = Lwt_react . E . to_stream event in let t = Lwt_stream . next stream in assert ( state t = Sleep ) ; push 42 ; return ( state t = Return 42 ) ) ... |
let testchan ( ) = let b = Buffer . create 6 in let f buf ofs len = let bytes = Bytes . create len in Lwt_bytes . blit_to_bytes buf ofs bytes 0 len ; Buffer . add_bytes b bytes ; Lwt . return len in let oc = Lwt_io . make ~ mode : Output f in let fmt = Lwt_fmt . of_channel oc in fmt , ... |
let suite = suite " lwt_fmt " [ test " flushing " ( fun ( ) -> let fmt , f = testchan ( ) in Lwt_fmt . fprintf fmt " % s % i % s " %! " bla " 3 " blo " >>= fun ( ) -> Lwt . return ( f ( ) = { | bla3blo } ) | ) ; test " with combinator " ( fun ... |
let local = let last_port = ref 4321 in fun ( ) -> incr last_port ; Unix . ADDR_INET ( Unix . inet_addr_loopback , ! last_port ) |
module Establish_server = struct let with_client f = let local = local ( ) in let handler_finished , notify_handler_finished = Lwt . wait ( ) in Lwt_io . establish_server_with_client_address local ( fun _client_address channels -> Lwt . finalize ( fun ( ) -> f channels ) ( fun ( ) ... |
let suite = suite " lwt_io " [ test " auto - flush " ~ sequential : true ( fun ( ) -> let sent = ref [ ] in let oc = Lwt_io . make ~ mode : Lwt_io . output ( fun buf ofs len -> let bytes = Bytes . create len in Lwt_bytes . blit_to_bytes buf ofs bytes 0 len ; sent := bytes :... |
let file_contents = " test file content " |
let suite = suite " lwt_io non blocking io " [ test ~ sequential : true " file does not exist " ( fun ( ) -> Lwt_unix . file_exists test_file >|= fun r -> not r ) ; test ~ sequential : true " file does not exist ( invalid path ) " ( fun ( ) -> Lwt_unix . file_exists ( te... |
let test_sqrt _ = Lwt_main . run Lwt . ( ( Bindings . sqrt 9 . 0 ) . Generated_bindings . lwt >>= fun x -> return ( assert ( x = 3 . 0 ) ) ) |
let test_object_lifetime _ = let call = let open Bigarray_compat in let b = Array1 . create int32 c_layout 3 in begin b . { 0 } <- 1l ; b . { 1 } <- 2l ; b . { 2 } <- 3l ; end ; ( Bindings . sum_int_array ( bigarray_start array1 b ) ( Unsigned . Size_t . of_int 3 ... |
let test_string_lifetime _ = let s = make Structures . stat in let call = ( Bindings . stat ( Bytes . to_string ( Bytes . of_string " . " ) ) ( addr s ) ) . Generated_bindings . lwt in begin Gc . compact ( ) ; Gc . compact ( ) ; Lwt_main . run ( Lwt . ( call... |
let test_six_args _ = let open Lwt . Infix in Lwt_main . run ( ( Bindings . sixargs 1 2 3 4 5 6 ) . Generated_bindings . lwt >>= fun i -> assert_equal ( 1 + 2 + 3 + 4 + 5 + 6 ) i ; Lwt . return ( ) ) |
let test_no_args _ = let open Lwt . Infix in Lwt_main . run ( ( Bindings . return_10 ( ) ) . Generated_bindings . lwt >>= fun i -> assert_equal 10 i ; Lwt . return ( ) ) |
let test_return_void _ = let open Lwt . Infix in Lwt_main . run ( let x_p = allocate_n ~ count : 1 int in ( Bindings . return_void x_p ) . Generated_bindings . lwt >>= fun ( ) -> assert_equal 10 ( !@ x_p ) ; Lwt . return ( ) ) |
let suite = " Lwt job tests " >::: [ " calling sqrt " >:: test_sqrt ; " object lifetime " >:: test_object_lifetime ; " string lifetime " >:: test_string_lifetime ; " functions with many arguments " >:: test_six_args ; " functions with no arguments " >:: test_no_args ; " func... |
let _ = run_test_tt_main suite |
let ( ) <=> v v ' = assert ( Lwt . state v = v ' ) |
let test_iter f test_list = let incr_ x = Lwt . return ( incr x ) in let ( ) = let l = [ ref 0 ; ref 0 ; ref 0 ] in let t = f incr_ l in t <=> Lwt . Return ( ) ; List . iter2 ( fun v r -> assert ( v = ! r ) ) [ 1 ; 1 ; 1 ] l in let ( ) = let l = [ ref 0... |
let test_exception list_combinator = let module E = struct exception Exception end in let open E in let number_of_callback_calls = ref 0 in let callback _ = incr number_of_callback_calls ; match ! number_of_callback_calls with | 2 -> raise Exception | _ -> Lwt . return ( ) in let p = try list_comb... |
let test_map f test_list = let t , w = Lwt . wait ( ) in let t ' , _ = Lwt . task ( ) in let get = let r = ref 0 in let c = ref 0 in fun ( ) -> let th = incr c ; match ! c with | 5 -> t | 8 -> t ' | _ -> Lwt . return ( ) in th >>= ( fun ( ) -> incr r ; Lwt ... |
let test_parallelism map = let t , w = Lwt . wait ( ) in let g _ = Lwt . wakeup_later w ( ) ; Lwt . return ( ) in let f x = if x = 0 then t >>= ( fun _ -> Lwt . return ( ) ) else g x in let p = map f [ 0 ; 1 ] in p >>= ( fun _ -> Lwt . return_true ) |
let test_serialization ( ? rev = false ) map = let other_ran = ref false in let k = if rev then 1 else 0 in let f x = if x = k then Lwt . pause ( ) >>= fun ( ) -> assert ( not ! other_ran ) ; Lwt . return ( ) else begin other_ran := true ; Lwt . return ( ) end in let p = ... |
let test_for_all_true f = let l = [ true ; true ] in f ( fun x -> Lwt . return ( x = true ) ) l |
let test_for_all_false f = let l = [ true ; true ] in f ( fun x -> Lwt . return ( x = false ) ) l >>= fun b -> Lwt . return ( not b ) |
let test_exists_true f = let l = [ true ; false ] in f ( fun x -> Lwt . return ( x = true ) ) l >>= fun b -> Lwt . return b |
let test_exists_false f = let l = [ true ; true ] in f ( fun x -> Lwt . return ( x = false ) ) l >>= fun b -> Lwt . return ( not b ) |
let test_filter f = let l = [ 1 ; 2 ; 3 ; 4 ] in f ( fun x -> Lwt . return ( x mod 2 = 0 ) ) l >>= fun after -> Lwt . return ( after = [ 2 ; 4 ] ) |
let test_partition f = let l = [ 1 ; 2 ; 3 ; 4 ] in f ( fun x -> Lwt . return ( x <= 2 ) ) l >>= fun ( a , b ) -> Lwt . return ( a = [ 1 ; 2 ] && b = [ 3 ; 4 ] ) |
let test_filter_map f = let l = [ 1 ; 2 ; 3 ; 4 ] in let fn = ( fun x -> if x mod 2 = 0 then Lwt . return_some ( x * 2 ) else Lwt . return_none ) in f fn l >>= fun after -> Lwt . return ( after = [ 4 ; 8 ] ) |
let test_iter_i f = let count = ref 0 in let l = [ 1 ; 2 ; 3 ] in f ( fun i n -> count := ! count + i + n ; Lwt . return_unit ) l >>= fun ( ) -> Lwt . return ( ! count = 9 ) |
let test_map_i f = let l = [ 0 ; 0 ; 0 ] in f ( fun i n -> Lwt . return ( i + n ) ) l >>= fun after -> Lwt . return ( after = [ 0 ; 1 ; 2 ] ) |
let test_rev_map f = let l = [ 1 ; 2 ; 3 ] in f ( fun n -> Lwt . return ( n * 2 ) ) l >>= fun after -> Lwt . return ( after = [ 6 ; 4 ; 2 ] ) |
let suite_primary = suite " lwt_list " [ test " iter_p " begin fun ( ) -> test_iter Lwt_list . iter_p [ 1 ; 0 ; 1 ] ; test_exception Lwt_list . iter_p ; Lwt . return true end ; test " iter_s " begin fun ( ) -> test_iter Lwt_list . iter_s [ 1 ; 0 ; 0 ] ; tes... |
let test_big_list m = let make_list n = Array . to_list @@ Array . init n ( fun x -> x ) in let f _ = Lwt . return ( ) in m f ( make_list 10_000_000 ) >>= ( fun _ -> Lwt . return_true ) |
let suite_intensive = suite " lwt_list big lists " ~ only_if ( : fun ( ) -> try Sys . getenv " LWT_STRESS_TEST " = " true " with | Not_found -> false ) [ test " iter_p big list " begin fun ( ) -> test_big_list Lwt_list . iter_p end ; test " iter_s big list " begin fun ( ... |
let suite = suite " lwt_mutex " [ test " cancel " ( fun ( ) -> let mutex = Lwt_mutex . create ( ) in let thread_1_wait , resume_thread_1 = Lwt . wait ( ) in let thread_1 = Lwt_mutex . with_lock mutex ( fun ( ) -> thread_1_wait ) in let thread_2_locked_mutex = ref false in ... |
let suite = suite " lwt_mvar " [ test " basic take " begin fun ( ) -> let x = Lwt_mvar . create 0 in let y = Lwt_mvar . take x in state_is ( Lwt . Return 0 ) y end ; test " take_available ( full ) " begin fun ( ) -> let x = Lwt_mvar . create 0 in let y = Lwt_mvar . ta... |
module Bounded = struct let rec producer queue = function | 0 -> Lwt . return_unit | n -> Lwt_pipe . Bounded . push queue ( ) >>= fun ( ) -> producer queue ( pred n ) let rec consumer queue = function | 0 -> Lwt . return_unit | n -> Lwt_pipe . Bounded . pop queue >>= fun _ -> c... |
module Unbounded = struct let rec producer queue = function | 0 -> Lwt . return_unit | n -> Lwt_pipe . Unbounded . push queue ( ) ; producer queue ( pred n ) let rec consumer queue = function | 0 -> Lwt . return_unit | n -> Lwt_pipe . Unbounded . pop queue >>= fun _ -> consumer que... |
let with_timeout t f ( ) = let timeout = Lwt_unix . sleep t >|= fun ( ) -> Error ( ) in let main = f ( ) >|= fun ( ) -> Ok ( ) in Lwt . pick [ main ; timeout ] >|= function Ok ( ) -> ( ) | Error ( ) -> assert false |
let ( ) = Lwt_main . run @@ Alcotest_lwt . run " Lwt_pipe " [ ( " Bounded " , [ ( " push - pop " , ` Quick , with_timeout 0 . 2 Bounded . push_pop ) ; ( " push - pop - all " , ` Quick , with_timeout 0 . 5 Bounded . push_pop_all ) ; ( " count ... |
let suite = suite " lwt_pool " [ test " basic create - use " begin fun ( ) -> let gen = fun ( ) -> Lwt . return ( ) in let p = Lwt_pool . create 1 gen in Lwt . return ( Lwt . state ( Lwt_pool . use p Lwt . return ) = Lwt . Return ( ) ) end ; test " creator exc... |
let expected = " the quick brown fox jumps over the lazy dog " |
let suite = suite " lwt_process " [ test " lazy_undefined " ~ only_if ( : fun ( ) -> not Sys . win32 ) ( fun ( ) -> Lwt_process . with_process_in ~ timeout : 1 . ( " sleep " , [ | " sleep " ; " 2 " ] ) | ( fun p -> Lwt . catch ( fun ( ) -> Lwt... |
module Result = struct type ( ' + a , ' + b ) t = ( ' a , ' b ) result = | Ok of ' a | Error of ' b end |
let suite = suite " lwt_result " [ test " maps " ( fun ( ) -> let x = Lwt_result . return 0 in let correct = Lwt_result . return 1 in Lwt . return ( Lwt_result . map ( ( ) + 1 ) x = correct ) ) ; test " >|= is a variant of map " ( fun ( ) -> let x = Lwt_resu... |
let l = [ 1 ; 2 ; 3 ; 4 ; 5 ] |
let a = Lwt_seq . of_list l |
let rec pause n = if n <= 0 then Lwt . return_unit else let * ( ) = Lwt . pause ( ) in pause ( n - 1 ) |
let pause n = pause ( n mod 5 ) |
let b = Lwt_seq . unfold_lwt ( function | [ ] -> let + ( ) = pause 2 in None | x :: xs -> let + ( ) = pause ( x + 2 ) in Some ( x , xs ) ) l |
let suite_base = suite " lwt_seq " [ test " fold_left " begin fun ( ) -> let n = ref 1 in Lwt_seq . fold_left ( fun acc x -> let r = x = ! n && acc in incr n ; r ) true a end ; test " fold_left_s " begin fun ( ) -> let n = ref 1 in Lwt_seq . fold_left_s ( fun acc x -> le... |
let fs = [ ( ) ; + ( ) ; - ( fun x _ -> x ) ; min ; max ] |
let ls = [ [ ] ; l ; l @ l @ l ; List . rev l ; [ 0 ; 0 ; 0 ] ; [ max_int ; 0 ; min_int ] ; [ max_int ; max_int ] ; ] |
let with_flc test = Lwt_list . for_all_s ( fun f -> Lwt_list . for_all_s ( fun l -> Lwt_list . for_all_s ( fun c -> test f l c ) cs ) ls ) fs |
let equals l1 seq2 = let * l2 = Lwt_seq . to_list seq2 in Lwt . return ( l1 = l2 ) |
let commutes lf sf l = equals ( lf l ) ( sf ( Lwt_seq . of_list l ) ) |
let suite_fuzzing = suite " lwt_seq ( pseudo - fuzzing ) " [ test " map " begin fun ( ) -> with_flc ( fun f l c -> let lf = List . map ( fun x -> f x c ) in let sf = Lwt_seq . map ( fun x -> f x c ) in commutes lf sf l ) end ; test " map_s " begin fun ( ) -> with_flc... |
let filled_sequence ( ) = let s = Lwt_sequence . create ( ) in let _ = Lwt_sequence . add_r 1 s in let _ = Lwt_sequence . add_r 2 s in let _ = Lwt_sequence . add_r 3 s in let _ = Lwt_sequence . add_r 4 s in let _ = Lwt_sequence . add_r 5 s in let _ = Lwt_sequence . add_r 6 s in... |
let transfer_sequence ( ) = let s = Lwt_sequence . create ( ) in let _ = Lwt_sequence . add_r 7 s in let _ = Lwt_sequence . add_r 8 s in s |
let l_filled_array = [ | 1 ; 2 ; 3 ; 4 ; 5 ; 6 ] | |
let r_filled_array = [ | 6 ; 5 ; 4 ; 3 ; 2 ; 1 ] | |
let test_iter iter_f array_values seq = let index = ref 0 in Lwt . catch ( fun ( ) -> iter_f ( fun v -> assert ( v = array_values . ( ! index ) ) ; index := ( ! index + 1 ) ) seq ; Lwt . return_true ) ( function _ -> Lwt . return_false ) |
let test_iter_node iter_f array_values seq = let index = ref 0 in Lwt . catch ( fun ( ) -> iter_f ( fun n -> assert ( ( Lwt_sequence . get n ) = array_values . ( ! index ) ) ; index := ( ! index + 1 ) ) seq ; Lwt . return_true ) ( function _ -> Lwt . return_false... |
let test_iter_rem iter_f array_values seq = let index = ref 0 in Lwt . catch ( fun ( ) -> iter_f ( fun n -> assert ( ( Lwt_sequence . get n ) = array_values . ( ! index ) ) ; Lwt_sequence . remove n ; index := ( ! index + 1 ) ) seq ; Lwt . return_true ) ( functio... |
let suite = suite " lwt_sequence " [ test " create " begin fun ( ) -> let s = Lwt_sequence . create ( ) in let _ = assert ( Lwt_sequence . is_empty s ) in let len = Lwt_sequence . length s in Lwt . return ( len = 0 ) end ; test " add_l " begin fun ( ) -> let s = Lwt... |
let suite = suite " lwt_signal " [ test " limit " ( fun ( ) -> let s , push = React . S . create 0 in let cond = Lwt_condition . create ( ) in let s ' = Lwt_react . S . limit ( fun ( ) -> Lwt_condition . wait cond ) s in let l = ref [ ] in let e = React . E . ... |
module Result = struct type ( ' + a , ' + b ) t = ( ' a , ' b ) result = | Ok of ' a | Error of ' b end |
let expect_exit f = Lwt . catch ( fun ( ) -> f ( ) >>= fun _ -> Lwt . return_false ) ( function | Exit -> Lwt . return_true | e -> Lwt . fail e ) |
let suite = suite " lwt_stream " [ test " from " ( fun ( ) -> let mvar = Lwt_mvar . create_empty ( ) in let stream = Lwt_stream . from ( fun ( ) -> Lwt_mvar . take mvar >>= fun x -> return ( Some x ) ) in let t1 = Lwt_stream . next stream in let t2 = Lwt_stream . next ... |
let suite = suite " lwt_switch " [ test " turn_off , add_hook " ( fun ( ) -> let hook_1_calls = ref 0 in let hook_2_calls = ref 0 in let hook call_counter ( ) = call_counter := ! call_counter + 1 ; Lwt . return_unit in let switch = Lwt_switch . create ( ) in Lwt_switch . ad... |
let suite = suite " Lwt_timeout " [ test " basic " begin fun ( ) -> let p , r = Lwt . wait ( ) in let start_time = Unix . gettimeofday ( ) in let timeout = Lwt_timeout . create 1 ( fun ( ) -> let delta = Unix . gettimeofday ( ) . - start_time in Lwt . wakeup_later ... |
let ( ) = match Sys . argv with | [ | _ ; " -- child " ] | -> exit 42 | _ -> ( ) |
let wait_tests = [ test " wait " ~ sequential : true ~ only_if ( : fun ( ) -> not Sys . win32 ) begin fun ( ) -> match Lwt_unix . fork ( ) with | 0 -> Unix . execv Sys . argv . ( 0 ) [ " " ; | " -- child " ] | | child_pid -> Lwt_unix . wait ( ) >|... |
let ( ) = let is_fd_open fd = let fd = ( Obj . magic ( int_of_string fd ) : Unix . file_descr ) in let buf = Bytes . create 1 in try ignore ( Unix . read fd buf 0 1 ) ; true with Unix . Unix_error ( Unix . EBADF , _ , _ ) -> false in match Sys . argv with | [ | _ ... |
let test_cloexec ~ closed flags = Lwt_unix . openfile " / dev / zero " ( Unix . O_RDONLY :: flags ) 0o644 >>= fun fd -> match Lwt_unix . fork ( ) with | 0 -> let fd = string_of_int ( Obj . magic ( Lwt_unix . unix_file_descr fd ) ) in let expected_status = if closed then " -... |
let openfile_tests = [ test " openfile : O_CLOEXEC " ~ only_if ( : fun ( ) -> not Sys . win32 ) ( fun ( ) -> test_cloexec ~ closed : true [ Unix . O_CLOEXEC ] ) ; test " openfile : O_CLOEXEC not given " ~ only_if ( : fun ( ) -> not Sys . win32 ) ( fun ( ) ... |
let utimes_tests = [ test " utimes : basic " ( fun ( ) -> let temporary_file = Test_unix . temp_file ( ) in Lwt_unix . utimes temporary_file 1 . 2 . >>= fun ( ) -> let stat = Unix . stat temporary_file in let c1 = stat . Unix . st_atime = 1 . in let c2 = stat . Unix . ... |
let readdir_tests = let populate n = let path = Test_unix . temp_directory ( ) in let filenames = let rec loop n acc = if n <= 0 then acc else loop ( n - 1 ) ( ( string_of_int n ) :: acc ) in loop n [ ] in List . iter ( fun filename -> let fd = Unix . ( openfile ( Filename . ... |
let io_vectors_byte_count_tests = let open Lwt_unix . IO_vectors in [ test " io_vector_byte_count : basic " ( fun ( ) -> let iov = create ( ) in append_bytes iov ( Bytes . create 10 ) 0 10 ; append_bigarray iov ( Lwt_bytes . create 10 ) 0 10 ; Lwt . return ( byte_count io... |
let readv_tests = let make_io_vectors vecs = let open Lwt_unix . IO_vectors in let io_vectors = create ( ) in let underlying = List . map ( function | ` Bytes ( prefix , slice_length , suffix ) -> let buffer = Bytes . make ( prefix + slice_length + suffix ) ' _ ' in append_bytes ... |
let writev_tests = let make_io_vectors vecs = let open Lwt_unix . IO_vectors in let io_vectors = create ( ) in List . iter ( function | ` Bytes ( s , offset , length ) -> append_bytes io_vectors ( Bytes . unsafe_of_string s ) offset length | ` Bigarray ( s , offset , length ) ... |
let send_recv_msg_tests = [ test " send_msg , recv_msg " ~ only_if ( : fun ( ) -> not Sys . win32 ) begin fun ( ) -> let socket_1 , socket_2 = Lwt_unix . ( socketpair PF_UNIX SOCK_STREAM 0 ) in let pipe_read , pipe_write = Lwt_unix . pipe ~ cloexec : true ( ) in let sourc... |
let bind_tests_address = Unix . ( ADDR_INET ( inet_addr_loopback , 56100 ) ) |
let bind_tests = let directory_exists dir = try Sys . is_directory dir with Sys_error _ -> false in [ test " bind : basic " ( fun ( ) -> let socket = Lwt_unix . ( socket PF_INET SOCK_STREAM 0 ) in Lwt . finalize ( fun ( ) -> Lwt_unix . bind socket bind_tests_address >>= fun ( )... |
let dir_tests = [ test " getcwd " ( fun ( ) -> Lwt_unix . getcwd ( ) >>= fun ( _ : string ) -> Lwt . return_true ) ; test " getcwd and chdir " ( fun ( ) -> Lwt_unix . getcwd ( ) >>= fun here -> Lwt_unix . chdir here >>= fun ( ) -> Lwt_unix . getcwd ( ) ... |
let lwt_preemptive_tests = [ test " run_in_main " begin fun ( ) -> let f ( ) = Lwt_preemptive . run_in_main ( fun ( ) -> Lwt_unix . sleep 0 . 01 >>= fun ( ) -> Lwt . return 42 ) in Lwt_preemptive . detach f ( ) >>= fun x -> Lwt . return ( x = 42 ) end ; ] |
let getlogin_works = if Sys . win32 then false else match Unix . getlogin ( ) with | _ -> true | exception Unix . Unix_error _ -> false |
let lwt_user_tests = [ test " getlogin and Unix . getlogin " ~ only_if ( : fun ( ) -> getlogin_works ) begin fun ( ) -> let unix_user = Unix . getlogin ( ) in Lwt_unix . getlogin ( ) >>= fun user -> Lwt . return ( user = unix_user ) end ; test " getpwnam and Unix . g... |
let file_suffix = let last_file_suffix = ref 0 in fun ( ) -> incr last_file_suffix ; ! last_file_suffix |
let test_filename name = Printf . sprintf " % s_ % i " name ( file_suffix ( ) ) |
let pread_tests ~ blocking = let test_file = test_filename " test_pread_pwrite " in let file_contents = " 01234567890123456789 " in let blocking_string = if blocking then " blocking " else " nonblocking " in [ test ~ sequential : true ( " basic pread " ^ blocking_string ) ( fun ( ... |
let dup_tests ~ blocking = let test_file = test_filename " test_dup " in let file_contents = " 01234567890123456789 " in let len = String . length file_contents in let buf = Bytes . make len ' \ x00 ' in let blocking_string = if blocking then " blocking " else " nonblocking " in [ tes... |
let suite = suite " lwt_unix " ( wait_tests @ openfile_tests @ utimes_tests @ readdir_tests @ io_vectors_byte_count_tests @ readv_tests @ writev_tests @ send_recv_msg_tests @ bind_tests @ dir_tests @ lwt_preemptive_tests @ lwt_user_tests @ pread_tests ~ blocking : true @ pread_tests ~ blocking :... |
let test_string_rt ( ) = let addrs = [ ( " ca : fe : ba : be : ee : ee " , ' ' ) ; : ( " ca - fe - ba - be - ee - ee " , ' ' ) - ] in List . iter ( fun ( addr , sep ) -> let os = of_string_exn addr in let ts = to_string ~ sep os in assert_equal ~ msg ( ... |
let assert_result_failure ~ msg a = match a with Ok _ -> assert_failure msg | Error ( ` Msg _ ) -> ( ) |
let test_string_rt_bad ( ) = let addrs = [ " ca : fe : ba : be : ee : e " ; " ca : fe : ba : be : ee : eee " ; " ca : fe : ba : be : eeee " ; " ca : fe : ba : be : ee :: ee " ; " ca : fe : ba : be : e : eee " ; " ca : fe : ba : be : ee - ee " ; ] ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.