tests/pickle_tests.ml

   1 (*pp deriving *)
   2
   3 open Defs
   4
   5 module Test (S : Pickle.Pickle) =
   6 struct
   7   let test v = S.E.eq (S.from_string (S.to_string v)) v
   8 end
   9
  10 let sum =
  11   begin
  12     let test = let module T = Test(Pickle_sum) in T.test in
  13       assert (test S0);
  14       assert (test (S1 3));
  15       assert (test (S2 (10,2.0)));
  16       assert (test (Sunit ()));
  17       assert (test (Stup (10,2.0)));
  18       assert (test (Stup1 3));
  19   end
  20
  21 let nullsum =
  22   begin
  23     let test = let module T = Test(Pickle_nullsum) in T.test in
  24       assert (test N0);
  25       assert (test N1);
  26       assert (test N2);
  27       assert (test N3);
  28   end
  29
  30 let r1 =
  31   begin
  32     let test = let module T = Test(Pickle_r1) in T.test in
  33       assert (test {r1_l1 = 10; r1_l2 = 20});
  34       assert (test {r1_l1 = min_int; r1_l2 = max_int});
  35       assert (test {r1_l1 = max_int; r1_l2 = min_int});
  36   end
  37
  38 let r2 =
  39   begin
  40     let v = { r2_l1 = 10;
  41               r2_l2 = 14 } in
  42       assert (not (Eq_r2.eq
  43                      (Pickle_r2.from_string
  44                         (Pickle_r2.to_string v)) v));
  45       assert (Pickle_r2.from_string
  46                 (Pickle_r2.to_string v) = v);
  47   end
  48
  49 let r3 =
  50   begin
  51     let v = { r3_l1 = 10;
  52               r3_l2 = 14 } in
  53       assert (not (Eq_r3.eq
  54                      (Pickle_r3.from_string
  55                         (Pickle_r3.to_string v)) v));
  56       assert (Pickle_r3.from_string
  57                 (Pickle_r3.to_string v) = v);
  58   end
  59
  60 let intseq =
  61   begin
  62     let test = let module T = Test(Pickle_intseq) in T.test in
  63       assert (test INil);
  64       assert (test (ICons (10, ICons (20, ICons (30, ICons (40, INil))))));
  65       assert (test (ICons (max_int, ICons (min_int, INil))));
  66   end
  67
  68 let seq =
  69   begin
  70     let test = let module T = Test(Pickle_seq(Pickle.Pickle_bool)) in T.test in
  71     let test' = let module T = Test(Pickle_seq(Pickle_seq(Pickle.Pickle_bool))) in T.test in
  72
  73       assert (test Nil);
  74       assert (test (Cons (false, Cons (true, Cons (false, Nil)))));
  75       assert (test' Nil);
  76       assert (test' (Cons (Cons (false, Cons (true, Nil)),
  77                            Cons (Cons (true, Cons (false, Nil)),
  78                                  Nil))));
  79   end
  80
  81 let uses_seqs =
  82   begin
  83     let test = let module T = Test(Pickle_uses_seqs) in T.test in
  84       assert (test (INil, Nil));
  85       assert (test (INil, Cons (0.0, Cons(10.0, Nil))));
  86       assert (test (ICons (10, ICons(20, INil)), Nil));
  87       assert (test (ICons (10, ICons(20, INil)),
  88                     Cons (0.0, Cons(10.0, Nil))));
  89   end
  90
  91 type permute0 = [`T3 | `T1 | `T2 | `T0] deriving (Typeable, Eq, Pickle)
  92 let poly0 =
  93   begin
  94     let test v = Eq_permute0.eq (Pickle_permute0.from_string (Pickle_poly0.to_string v)) v in
  95       assert (test `T0);
  96       assert (test `T1);
  97       assert (test `T2);
  98       assert (test `T3);
  99   end
 100
 101 type permute3 = [`Nil | `Cons of int * permute3] deriving (Typeable, Eq, Pickle)
 102 let _ =
 103   begin
 104     let test v = Eq_permute3.eq (Pickle_permute3.from_string (Pickle_poly3.to_string v)) v in
 105       assert (test `Nil);
 106       assert (test (`Cons (0, `Cons (1, `Cons (2, `Nil)))));
 107   end
 108
 109 let poly3b =
 110   begin
 111     let test = let module T = Test(Pickle_poly3b) in T.test in
 112       assert (test (10, `Nil, `F));
 113       assert (test (10, `Cons (10, `Cons (-20, `Nil)), `F));
 114   end
 115
 116 let _ =
 117   begin
 118     let test = let module T = Test(Pickle_poly7(Pickle.Pickle_bool)) in T.test
 119     and test' = let module T = Test(Pickle_poly8(Pickle.Pickle_int)) in T.test in
 120       assert (test (Foo (`F true)));
 121       assert (test (Foo (`F false)));
 122       assert (test' {x = `G (`H (`I (Foo (`F (max_int - 1)))))});
 123       assert (test' {x = `G (`H (`I (Foo (`F (min_int + 1)))))});
 124   end
 125
 126 let _ =
 127   begin
 128     let test = let module T = Test(Pickle_poly10) in T.test in
 129       assert (test `F);
 130       assert (test `Nil);
 131       assert (test (`Cons (12, `Cons (14, `Nil))));
 132   end
 133
 134 let mutrec =
 135   begin
 136     let module A = Test(Pickle_mutrec_a) in
 137     let module B = Test(Pickle_mutrec_b) in
 138     let module C = Test(Pickle_mutrec_c) in
 139     let module D = Test(Pickle_mutrec_d) in
 140     let a = N in
 141     let b = { l1 = S (3, a); l2 = a } in
 142     let c = S (3, S (4, S (5, N))) in
 143     let d = `T b in
 144       assert (A.test a);
 145       assert (B.test b);
 146       assert (C.test c);
 147       assert (D.test d);
 148   end
 149
 150 let pmutrec =
 151   begin
 152     (*
 153       type ('a,'b) pmutrec_a = ('a,'b) pmutrec_c
 154       and ('a,'b) pmutrec_b = { pl1 : ('a,'b) pmutrec_c ; pl2 : ('a,'b) pmutrec_a }
 155       and ('a,'b) pmutrec_c = SS of 'a * ('a,'b) pmutrec_a * 'b
 156       and ('a,'b) pmutrec_d = [`T of ('a,'b) pmutrec_b]
 157     *)
 158   end
 159
 160 let ff1 =
 161   begin
 162     let test = let module T = Test(Pickle_ff1(Pickle.Pickle_bool)) in T.test in
 163       assert (test (F (true,false)));
 164       assert (test (G 435));
 165   end
 166
 167 let ff2 =
 168   begin
 169     let test = let module T = Test(Pickle_ff2(Pickle.Pickle_bool)(Pickle.Pickle_int)) in T.test in
 170       assert (test (F1 (F2 (Nil, 10, None))));
 171       assert (test (F1 (F2 (Cons (true, Cons (false, Nil)), 10, Some 14))));
 172   end
 173
 174 let unit =
 175   begin
 176     let test = let module T = Test(Pickle_unit) in T.test in
 177       assert (test ());
 178   end
 179
 180 let tup2 =
 181   begin
 182     let test = let module T = Test(Pickle_tup2) in T.test in
 183       assert (test (-10,12e4));
 184       assert (test (max_int,12e4));
 185   end
 186
 187 let tup3 =
 188   begin
 189     let test = let module T = Test(Pickle_tup3) in T.test in
 190       assert (test (0,12.3,true));
 191       assert (test (min_int,-12.3,false));
 192   end
 193
 194 let tup4 =
 195   begin
 196     let test = let module T = Test(Pickle_tup4) in T.test in
 197       assert (test (0,0,true,()));
 198       assert (test (min_int,max_int,false,()));
 199   end
 200
 201 let withref =
 202   begin
 203     let v = WR (10, ref 20) in
 204       assert (not
 205                 (Eq_withref.eq (Pickle_withref.from_string
 206                                   (Pickle_withref.to_string v)) v));
 207       assert (Pickle_withref.from_string
 208                 (Pickle_withref.to_string v) = v);
 209   end
 210
 211 let t =
 212   begin
 213     let test v = Eq_int.eq (Pickle_int.from_string (Pickle_t.to_string v)) v in
 214       assert (test min_int);
 215       assert (test max_int);
 216       assert (test 10);
 217  end
 218
 219 type refobj = A | B of refobj ref
 220   deriving (Eq, Typeable, Pickle)
 221
 222 let circular =
 223   let s = ref A in
 224   let r = B s in
 225      s := r;
 226     r
 227
 228 let _ =
 229   let v = Pickle_refobj.from_string (Pickle_refobj.to_string circular) in
 230   let (B {contents =
 231            B {contents =
 232                B {contents =
 233                    B {contents =
 234                        B {contents =
 235                            B {contents =
 236                                B {contents = _ }}}}}}}) = v in
 237     ()
 238
 239
 240 type mut = {
 241   mutable x : mut option;
 242   mutable y : mut option;
 243   z : int;
 244 } deriving (Eq, Typeable, Pickle)
 245
 246 let circularm =
 247   let i = {z = 1; x = None; y = None} in
 248   let j = {z = 2; x = None; y = Some i} in
 249     i.x <- Some j;
 250     i.y <- Some i;
 251     j.x <- Some j;
 252     i
 253
 254 let _ =
 255   let v = Pickle_mut.from_string (Pickle_mut.to_string circularm) in
 256   let {z = 1;
 257        x = Some {z = 2; x = Some {z = 2;
 258                                   x = Some _;
 259                                   y = Some _};
 260                  y = Some _};
 261        y = Some {z = 1;
 262                  x = Some {z = 2; x = Some {z = 2;
 263                                             x = Some {z = 2;
 264                                                       x = Some _;
 265                                                       y = Some _};
 266                                             y = Some _};
 267                        y = Some _};
 268                  y = Some _}} = v in
 269     ()
 270
 271 type t1 = { mutable x : t2 option }
 272 and  t2 = { y : t1 option }
 273     deriving (Eq, Typeable, Pickle)
 274
 275 let circular_a =
 276   let a = { x = None } in
 277   let b = { y = Some a } in
 278     a.x <- Some b;
 279     a
 280
 281 let _ =
 282   let {x = Some {y = Some
 283            {x = Some {y = Some
 284                 {x = Some {y = Some
 285                      {x = Some {y = Some _}}}}}}}} =
 286     Pickle_t1.from_string (Pickle_t1.to_string circular_a) in
 287     ()