Ticket #4651: some_dojo_doctests.patch

File some_dojo_doctests.patch, 8.5 KB (added by wolfram, 5 years ago)

Added some doctests for dojo._base, modified some existing examples into doctests

  • number.js

     
    8585        // value: the number to round 
    8686        // places: the number of decimal places where rounding takes place 
    8787        // multiple: rounds next place to nearest multiple 
    88  
     88        // 
     89        // examples: 
     90        //      >>> dojo.number.round(1.2345, 3) 
     91        //      1.235 
     92        //      >>> dojo.number.round(1.2345) 
     93        //      1.2345 
     94        //      >>> dojo.number.round(1.2345, 2, 3) 
     95        //      1.235 
     96        //      >>> dojo.number.round(1) 
     97        //      1 
     98        //      >>> dojo.number.round(1.0) 
     99        //      1 
     100        //      >>> dojo.number.round(1.0, 1) 
     101        //      1 
     102        //      >>> dojo.number.round(1.99, 1) 
     103        //      2 
     104        //      >>> dojo.number.round(1.50, 1) 
     105        //      1.5 
     106        //      >>> dojo.number.round(1.50000000000000000001, 1) 
     107        //      1.5 
     108        //      >>> dojo.number.round(1.2499999999999999999, 1) 
     109        //      1.3 
     110        //      >>> dojo.number.round(1.2499999999999999999, 3) 
     111        //      1.25 
     112        //      >>> dojo.number.round(1.2499999999999999999, 2) 
     113        //      1.25 
     114        //      >>> dojo.number.round(1.2499999999999999999, 4) 
     115        //      1.25 
     116        //      >>> dojo.number.round(1.2499999999999999999, 5) 
     117        //      1.25 
     118        //      >>> dojo.number.round(1.24999, 5) 
     119        //      1.24999 
     120        //      >>> dojo.number.round(1.249999, 5) 
     121        //      1.25 
    89122        var pieces = String(value).split("."); 
    90123        var length = (pieces[1] && pieces[1].length) || 0; 
    91124        if(length > places){ 

  • _base/array.js

     
    5353                        //              corresponds (and wraps) the JavaScript 1.6 forEach method. For 
    5454                        //              more details, see: 
    5555                        //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:forEach 
     56                        // examples: 
     57                        //              >>> var result = "" 
     58                        //              >>> dojo.forEach(["one", 2], function(el) {result+=el+" "}) 
     59                        //              >>> result 
     60                        //              "one 2 " 
     61                        // 
     62                        //              >>> var result = [] 
     63                        //              >>> dojo.forEach([], function(el) {result.push(el)}) 
     64                        //              >>> result 
     65                        //              [] 
     66                        // 
     67                        //              >>> var result = [] 
     68                        //              >>> dojo.forEach([1,2,3,4,5,6], function(el) {result.push(el)}) 
     69                        //              >>> result 
     70                        //              [1, 2, 3, 4, 5, 6] 
     71                        // 
    5672 
    5773                        // match the behavior of the built-in forEach WRT empty arrs 
    5874                        if(!arr || !arr.length){ return; } 
    … …  
    84100                        //              from the JavaScript 1.6 Array.every() function. More 
    85101                        //              information on this can be found here: 
    86102                        //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every 
    87                         // usage: 
    88                         //              dojo.every([1, 2, 3, 4], function(item){ return item>1; }); 
    89                         //              // returns false 
    90                         //              dojo.every([1, 2, 3, 4], function(item){ return item>0; }); 
    91                         //              // returns true  
     103                        // examples: 
     104                        //              >>> dojo.every([1, 2, 3, 4], function(item){ return item>1; }); 
     105                        //              false 
     106                        //              >>> dojo.every([1, 2, 3, 4], function(item){ return item>0; }); 
     107                        //              true 
     108                        // 
    92109                        return this._everyOrSome(true, arr, callback, thisObject); // Boolean 
    93110                }, 
    94111 
    … …  
    101118                        //              information on this can be found here: 
    102119                        //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some 
    103120                        // examples: 
    104                         //              dojo.some([1, 2, 3, 4], function(item){ return item>1; }); 
    105                         //              // returns true 
    106                         //              dojo.some([1, 2, 3, 4], function(item){ return item<1; }); 
    107                         //              // returns false 
     121                        //              >>> dojo.some([1, 2, 3, 4], function(item){ return item>1; }); 
     122                        //              true 
     123                        //              >>> dojo.some([1, 2, 3, 4], function(item){ return item<1; }); 
     124                        //              false 
    108125                        return this._everyOrSome(false, arr, callback, thisObject); // Boolean 
    109126                }, 
    110127 
    … …  
    120137                        //              function is a passthrough to the built-in map() function 
    121138                        //              provided by Array instances. For details on this, see: 
    122139                        //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:map 
    123                         // usage: 
    124                         //              dojo.map([1, 2, 3, 4], function(item){ return item+1 }); 
    125                         //              // returns [2, 3, 4, 5] 
     140                        // examples: 
     141                        //              >>> dojo.map([1, 2, 3, 4], function(item){ return item+1 }); 
     142                        //              [2, 3, 4, 5] 
    126143                        var _p = _getParts(arr, obj, func); arr = _p[0]; 
    127144                        var outArr = ((arguments[3]) ? (new arguments[3]()) : []); 
    128145                        for(var i=0;i<arr.length;++i){ 
    … …  
    141158                        //              More information on the JS 1.6 API can be found here: 
    142159                        //                      http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:filter 
    143160                        // examples: 
    144                         //              dojo.filter([1, 2, 3, 4], function(item){ return item>1; }); 
    145                         //              // returns [2, 3, 4] 
    146  
     161                        //              >>> dojo.filter([1, 2, 3, 4], function(item){ return item>1; }); 
     162                        //              [2, 3, 4] 
    147163                        var _p = _getParts(arr, obj, callback); arr = _p[0]; 
    148164                        var outArr = []; 
    149165                        for(var i = 0; i < arr.length; i++){ 

  • _base/lang.js

     
    44 
    55dojo.isString = function(/*anything*/ it){ 
    66        // summary:     Return true if it is a String 
     7        // examples: 
     8        //              >>> dojo.isString("") 
     9        //              true 
     10        //              >>> dojo.isString(new String("jo")) 
     11        //              true 
     12        //              >>> dojo.isString(1) 
     13        //              false 
     14        //              >>> dojo.isString({}) 
     15        //              false 
     16        //              >>> dojo.isString("string? what's that?") 
     17        //              true 
     18        //              >>> dojo.isString("{}") 
     19        //              true 
     20        //              >>> dojo.isString(1.3) 
     21        //              false 
     22        //              >>> dojo.isString(null) 
     23        //              false 
     24        //              >>> dojo.isString(undefined) 
     25        //              false 
     26        //              >>> dojo.isString(new Object) 
     27        //              false 
     28        //              >>> dojo.isString(Error) 
     29        //              false 
    730        return typeof it == "string" || it instanceof String; // Boolean 
    831} 
    932 
    1033dojo.isArray = function(/*anything*/ it){ 
    1134        // summary: Return true if it is an Array 
     35        // examples: 
     36        //              >>> dojo.isArray([]) 
     37        //              true 
     38        //              >>> dojo.isArray([1,2,3]) 
     39        //              true 
     40        //              >>> dojo.isArray({}) 
     41        //              false 
     42        //              >>> dojo.isArray("array? what's that?") 
     43        //              false 
     44        //              >>> dojo.isArray("{}") 
     45        //              false 
     46        //              >>> dojo.isArray(1.3) 
     47        //              false 
     48        //              >>> dojo.isArray(null) 
     49        //              false 
     50        //              >>> dojo.isArray(undefined) 
     51        //              false 
     52        //              >>> dojo.isArray(new Object) 
     53        //              false 
     54        //              >>> dojo.isArray(Error) 
     55        //              false 
    1256        return it && it instanceof Array || typeof it == "array" || 
    1357                (dojo.NodeList && it instanceof dojo.NodeList); // Boolean 
    1458} 
    … …  
    2165=====*/ 
    2266 
    2367dojo.isFunction = (function(){ 
     68        // examples: 
     69        //              >>> dojo.isFunction(function() {}) 
     70        //              true 
     71        //              >>> dojo.isFunction(window.setTimeout) 
     72        //              true 
     73        //              >>> dojo.isFunction(dojo.isFunction) 
     74        //              true 
     75        //              >>> dojo.isFunction({}) 
     76        //              false 
     77        //              >>> dojo.isFunction("array? what's that?") 
     78        //              false 
     79        //              >>> dojo.isFunction("{}") 
     80        //              false 
     81        //              >>> dojo.isFunction(1.3) 
     82        //              false 
     83        //              >>> dojo.isFunction(null) 
     84        //              false 
     85        //              >>> dojo.isFunction(undefined) 
     86        //              false 
     87        //              >>> dojo.isFunction(new Object) 
     88        //              false 
    2489        var _isFunction = function(/*anything*/ it){ 
    2590                return typeof it == "function" || it instanceof Function; // Boolean 
    2691        }; 
    … …  
    36101dojo.isObject = function(/*anything*/ it){ 
    37102        // summary:  
    38103        //              Returns true if it is a JavaScript object (or an Array, a Function or null) 
     104        // examples: 
     105        //              >>> dojo.isObject({}) 
     106        //              true 
     107        //              >>> dojo.isObject(new Object) 
     108        //              true 
     109        //              >>> dojo.isObject({one:1, two:2}) 
     110        //              true 
     111        //              >>> dojo.isObject(function() {}) 
     112        //              true 
     113        //              >>> dojo.isObject([]) 
     114        //              true 
     115        //              >>> dojo.isObject(null) 
     116        //              true 
     117        //              >>> dojo.isObject("not an object") 
     118        //              false 
     119        //              >>> dojo.isObject(1.3) 
     120        //              false 
     121        //              >>> dojo.isObject(undefined) 
     122        //              false 
    39123        return it !== undefined && 
    40124                (it === null || typeof it == "object" || dojo.isArray(it) || dojo.isFunction(it)); // Boolean 
    41125} 
    … …  
    43127dojo.isArrayLike = function(/*anything*/ it){ 
    44128        // return: 
    45129        //              If it walks like a duck and quicks like a duck, return true 
     130        // examples: 
     131        //              >>> dojo.isArrayLike([]) 
     132        //              true 
     133        //              >>> dojo.isArrayLike({one:1, two:2}) 
     134        //              false 
     135        //              >>> dojo.isArrayLike([1,2,3,4]) 
     136        //              true 
    46137        var d = dojo; 
    47138        return it && it !== undefined && 
    48139                // keep out built-in constructors (Number, String, ...) which have length 
    … …  
    217308        //      due to its compact size and relatively good performance (see Steven Levithan's blog:  
    218309        //      http://blog.stevenlevithan.com/archives/faster-trim-javascript). 
    219310        //      The fastest but longest version of this function is going to be placed in dojo.string. 
     311        // examples: 
     312        //      >>> dojo.trim(" trim me ") 
     313        //      "trim me" 
     314        //      >>> dojo.trim("\t\ttrim me ") 
     315        //      "trim me" 
     316        //      >>> dojo.trim(" \t\t trim me \t ") 
     317        //      "trim me" 
     318        //      >>> dojo.trim("trim me") 
     319        //      "trim me" 
     320        //      >>> dojo.trim(" trim me") 
     321        //      "trim me" 
     322        //      >>> dojo.trim("trim me ") 
     323        //      "trim me" 
     324        //      >>> dojo.trim("") 
     325        //      "" 
    220326        return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // String 
    221327}