git.pond.sub.org Git - eow/blob - static/dojo-release-1.1.1/dojo/tests/DeferredList.js

   1 if(!dojo._hasResource["tests.DeferredList"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
   2 dojo._hasResource["tests.DeferredList"] = true;
   3 dojo.provide("tests.DeferredList");
   4
   5 dojo.require("dojo.DeferredList");
   6
   7 doh.register("tests.DeferredList",
   8         [
   9                 function callback(t){
  10                         var d1 = new dojo.Deferred();
  11                         var d2 = new dojo.Deferred();
  12                         var dl = new dojo.DeferredList([d1, d2]);
  13                         var fired = false;
  14
  15                         dl.addCallback(function(res){
  16                                 doh.debug("debug from dojo.DeferredList callback");
  17                                 return res;
  18                         });
  19                         dl.addCallback(function(res){
  20                                 console.log("res: ", res, res.length);
  21                                 t.assertTrue(res.length == 2);
  22                                 t.assertTrue(res[0][0]);
  23                                 t.assertEqual(res[0][1], "foo");
  24                                 t.assertTrue(res[1][0]);
  25                                 t.assertEqual(res[1][1], "bar");
  26                                 fired = true;
  27                                 return res;
  28                         });
  29                         d1.callback("foo");
  30                         d2.callback("bar");
  31                         t.assertTrue(fired);
  32                 },
  33
  34                 function errback(t){
  35                         var d1 = new dojo.Deferred();
  36                         var d2 = new dojo.Deferred();
  37                         var dl = new dojo.DeferredList([d1, d2]);
  38                         var fired = false;
  39                         var e1 = new Error("foo");
  40                         var e2 = new Error("bar");
  41
  42                         dl.addCallback(function(res){
  43                                 doh.debug("debug from dojo.DeferredList callback");
  44                                 return res;
  45                         });
  46                         dl.addCallback(function(res){
  47                                 t.assertTrue(res.length == 2);
  48                                 t.assertTrue(!res[0][0]);
  49
  50                                 t.assertEqual(res[0][1], e1);
  51                                 t.assertTrue(!res[1][0]);
  52                                 t.assertEqual(res[1][1], e2);
  53                                 fired = true;
  54                                 return res;
  55                         });
  56                         d1.errback(e1);
  57                         d2.errback(e2);
  58                         t.assertTrue(fired);
  59                 },
  60
  61
  62                 function mixed(t){
  63                         var d1 = new dojo.Deferred();
  64                         var d2 = new dojo.Deferred();
  65             var dl = new dojo.DeferredList([d1, d2]);
  66             var fired = false;
  67             var e = new Error("foo");
  68
  69                         dl.addCallback(function(res){
  70                                 doh.debug("debug from dojo.DeferredList callback");
  71                                 return res;
  72                         });
  73                         dl.addCallback(function(res){
  74                 t.assertTrue(res.length == 2);
  75                 t.assertTrue(!res[0][0]);
  76
  77                 t.assertEqual(res[0][1], e);
  78                 t.assertTrue(res[1][0]);
  79                 t.assertEqual(res[1][1], "bar");
  80                 fired = true;
  81                                 return res;
  82                         });
  83                         d1.errback(e);
  84                         d2.callback("bar");
  85             t.assertTrue(fired);
  86                 },
  87
  88         function gather(t){
  89                         var d1 = new dojo.Deferred();
  90                         var d2 = new dojo.Deferred();
  91             var dl = dojo.DeferredList.prototype.gatherResults([d1, d2]);
  92             var fired = false;
  93                         dl.addCallback(function(res){
  94                 t.assertEqual(res[0], "foo");
  95                 t.assertEqual(res[1], "bar");
  96                 fired = true;
  97                                 return res;
  98                         });
  99                         d1.callback("foo");
 100                         d2.callback("bar");
 101             t.assertTrue(fired);
 102         }
 103         ]
 104 );
 105 dojo.provide("tests.DeferredList");
 106
 107 dojo.require("dojo.DeferredList");
 108
 109 doh.register("tests.DeferredList",
 110         [
 111                 function callback(t){
 112                         var d1 = new dojo.Deferred();
 113                         var d2 = new dojo.Deferred();
 114             var dl = new dojo.DeferredList([d1, d2]);
 115             var fired = false;
 116                         dl.addCallback(function(res){
 117                                 doh.debug("debug from dojo.DeferredList callback");
 118                                 return res;
 119                         });
 120                         dl.addCallback(function(res){
 121                 t.assertTrue(res.length == 2);
 122                 t.assertTrue(res[0][0]);
 123                 t.assertEqual(res[0][1], "foo");
 124                 t.assertTrue(res[1][0]);
 125                 t.assertEqual(res[1][1], "bar");
 126                 fired = true;
 127                                 return res;
 128                         });
 129                         d1.callback("foo");
 130                         d2.callback("bar");
 131             t.assertTrue(fired);
 132                 },
 133
 134                 function errback(t){
 135                         var d1 = new dojo.Deferred();
 136                         var d2 = new dojo.Deferred();
 137             var dl = new dojo.DeferredList([d1, d2]);
 138             var fired = false;
 139             var e1 = new Error("foo");
 140             var e2 = new Error("bar");
 141
 142                         dl.addCallback(function(res){
 143                                 doh.debug("debug from dojo.DeferredList callback");
 144                                 return res;
 145                         });
 146                         dl.addCallback(function(res){
 147                 t.assertTrue(res.length == 2);
 148                 t.assertTrue(!res[0][0]);
 149
 150                 t.assertEqual(res[0][1], e1);
 151                 t.assertTrue(!res[1][0]);
 152                 t.assertEqual(res[1][1], e2);
 153                 fired = true;
 154                                 return res;
 155                         });
 156                         d1.errback(e1);
 157                         d2.errback(e2);
 158             t.assertTrue(fired);
 159                 },
 160
 161
 162                 function mixed(t){
 163                         var d1 = new dojo.Deferred();
 164                         var d2 = new dojo.Deferred();
 165             var dl = new dojo.DeferredList([d1, d2]);
 166             var fired = false;
 167             var e = new Error("foo");
 168
 169                         dl.addCallback(function(res){
 170                                 doh.debug("debug from dojo.DeferredList callback");
 171                                 return res;
 172                         });
 173                         dl.addCallback(function(res){
 174                 t.assertTrue(res.length == 2);
 175                 t.assertTrue(!res[0][0]);
 176
 177                 t.assertEqual(res[0][1], e);
 178                 t.assertTrue(res[1][0]);
 179                 t.assertEqual(res[1][1], "bar");
 180                 fired = true;
 181                                 return res;
 182                         });
 183                         d1.errback(e);
 184                         d2.callback("bar");
 185             t.assertTrue(fired);
 186                 },
 187
 188         function gather(t){
 189                         var d1 = new dojo.Deferred();
 190                         var d2 = new dojo.Deferred();
 191             var dl = dojo.DeferredList.prototype.gatherResults([d1, d2]);
 192             var fired = false;
 193                         dl.addCallback(function(res){
 194                 t.assertEqual(res[0], "foo");
 195                 t.assertEqual(res[1], "bar");
 196                 fired = true;
 197                                 return res;
 198                         });
 199                         d1.callback("foo");
 200                         d2.callback("bar");
 201             t.assertTrue(fired);
 202         }
 203         ]
 204 );
 205
 206 }