|
1 load("app/frame/Dumper.js"); |
|
2 function symbolize(opt) { |
|
3 symbols = null; |
|
4 JSDOC.JsDoc(opt); |
|
5 symbols = JSDOC.JsDoc.symbolSet; |
|
6 } |
|
7 |
|
8 var testCases = [ |
|
9 function() { |
|
10 symbolize({a:true, p:true, _: [SYS.pwd+"test/overview.js"]}); |
|
11 //print(Dumper.dump(symbols)); |
|
12 is('symbols.getSymbolByName("My Cool Library").name', 'My Cool Library', 'File overview can be found by alias.'); |
|
13 } |
|
14 , |
|
15 function() { |
|
16 symbolize({_: [SYS.pwd+"test/name.js"]}); |
|
17 |
|
18 is('symbols.getSymbol("Response").name', "Response", 'Virtual class name is found.'); |
|
19 is('symbols.getSymbol("Response#text").alias', "Response#text", 'Virtual method name is found.'); |
|
20 is('symbols.getSymbol("Response#text").memberOf', "Response", 'Virtual method parent name is found.'); |
|
21 } |
|
22 , |
|
23 function() { |
|
24 symbolize({a:true, p:true, _: [SYS.pwd+"test/prototype.js"]}); |
|
25 |
|
26 is('symbols.getSymbol("Article").name', "Article", 'Function set to constructor prototype with inner constructor name is found.'); |
|
27 is('symbols.getSymbol("Article").hasMethod("init")', true, 'The initializer method name of prototype function is correct.'); |
|
28 is('symbols.getSymbol("Article").hasMember("counter")', true, 'A static property set in the prototype definition is found.'); |
|
29 is('symbols.getSymbol("Article").hasMember("title")', true, 'An instance property set in the prototype is found.'); |
|
30 is('symbols.getSymbol("Article#title").isStatic', false, 'An instance property has isStatic set to false.'); |
|
31 is('symbols.getSymbol("Article.counter").name', "counter", 'A static property set in the initializer has the name set correctly.'); |
|
32 is('symbols.getSymbol("Article.counter").memberOf', "Article", 'A static property set in the initializer has the memberOf set correctly.'); |
|
33 is('symbols.getSymbol("Article.counter").isStatic', true, 'A static property set in the initializer has isStatic set to true.'); |
|
34 } |
|
35 , |
|
36 function() { |
|
37 symbolize({a:true, _: [SYS.pwd+"test/prototype_oblit.js"]}); |
|
38 |
|
39 is('symbols.getSymbol("Article").name', "Article", 'Oblit set to constructor prototype name is found.'); |
|
40 is('typeof symbols.getSymbol("Article.prototype")', "undefined", 'The prototype oblit is not a symbol.'); |
|
41 is('symbols.getSymbol("Article#getTitle").name', "getTitle", 'The nonstatic method name of prototype oblit is correct.'); |
|
42 is('symbols.getSymbol("Article#getTitle").alias', "Article#getTitle", 'The alias of non-static method of prototype oblit is correct.'); |
|
43 is('symbols.getSymbol("Article#getTitle").isStatic', false, 'The isStatic of a nonstatic method of prototype oblit is correct.'); |
|
44 is('symbols.getSymbol("Article.getTitle").name', "getTitle", 'The static method name of prototype oblit is correct.'); |
|
45 is('symbols.getSymbol("Article.getTitle").isStatic', true, 'The isStatic of a static method of prototype oblit is correct.'); |
|
46 is('symbols.getSymbol("Article#getTitle").isa', "FUNCTION", 'The isa of non-static method of prototype oblit is correct.'); |
|
47 is('symbols.getSymbol("Article.getTitle").alias', "Article.getTitle", 'The alias of a static method of prototype oblit is correct.'); |
|
48 is('symbols.getSymbol("Article.getTitle").isa', "FUNCTION", 'The isa of static method of prototype oblit is correct.'); |
|
49 } |
|
50 , |
|
51 function() { |
|
52 symbolize({a:true, p:true, _: [SYS.pwd+"test/prototype_oblit_constructor.js"]}); |
|
53 |
|
54 is('symbols.getSymbol("Article").name', "Article", 'Oblit set to constructor prototype with inner constructor name is found.'); |
|
55 is('symbols.getSymbol("Article#init").name', "init", 'The initializer method name of prototype oblit is correct.'); |
|
56 is('symbols.getSymbol("Article").hasMember("pages")', true, 'Property set by initializer method "this" is on the outer constructor.'); |
|
57 is('symbols.getSymbol("Article#Title").name', "Title", 'Name of the inner constructor name is found.'); |
|
58 is('symbols.getSymbol("Article#Title").memberOf', "Article", 'The memberOf of the inner constructor name is found.'); |
|
59 is('symbols.getSymbol("Article#Title").isa', "CONSTRUCTOR", 'The isa of the inner constructor name is constructor.'); |
|
60 is('symbols.getSymbol("Article#Title").hasMember("title")', true, 'A property set on the inner constructor "this" is on the inner constructor.'); |
|
61 } |
|
62 , |
|
63 function() { |
|
64 symbolize({a:true, p:true, _: [SYS.pwd+"test/inner.js"]}); |
|
65 |
|
66 is('symbols.getSymbol("Outer").name', "Outer", 'Outer constructor prototype name is found.'); |
|
67 is('symbols.getSymbol("Outer").methods.length', 1, 'Inner function doesnt appear as a method of the outer.'); |
|
68 is('symbols.getSymbol("Outer").hasMethod("open")', true, 'Outer constructors methods arent affected by inner function.'); |
|
69 is('symbols.getSymbol("Outer-Inner").alias', "Outer-Inner", 'Alias of inner function is found.'); |
|
70 is('symbols.getSymbol("Outer-Inner").isa', "CONSTRUCTOR", 'isa of inner function constructor is found.'); |
|
71 is('symbols.getSymbol("Outer-Inner").memberOf', "Outer", 'The memberOf of inner function is found.'); |
|
72 is('symbols.getSymbol("Outer-Inner").name', "Inner", 'The name of inner function is found.'); |
|
73 is('symbols.getSymbol("Outer-Inner#name").name', "name", 'A member of the inner function constructor, attached to "this" is found on inner.'); |
|
74 is('symbols.getSymbol("Outer-Inner#name").memberOf', "Outer-Inner", 'The memberOf of an inner function member is found.'); |
|
75 } |
|
76 , |
|
77 function() { |
|
78 symbolize({a:true, _: [SYS.pwd+"test/prototype_nested.js"]}); |
|
79 |
|
80 is('symbols.getSymbol("Word").name', "Word", 'Base constructor name is found.'); |
|
81 is('symbols.getSymbol("Word").hasMethod("reverse")', true, 'Base constructor method is found.'); |
|
82 is('symbols.getSymbol("Word").methods.length', 1, 'Base constructor has only one method.'); |
|
83 is('symbols.getSymbol("Word").memberOf', "", 'Base constructor memberOf is empty.'); |
|
84 is('symbols.getSymbol("Word#reverse").name', "reverse", 'Member of constructor prototype name is found.'); |
|
85 is('symbols.getSymbol("Word#reverse").memberOf', "Word", 'Member of constructor prototype memberOf is found.'); |
|
86 is('symbols.getSymbol("Word#reverse.utf8").name', "utf8", 'Member of constructor prototype method name is found.'); |
|
87 is('symbols.getSymbol("Word#reverse.utf8").memberOf', "Word#reverse", 'Static nested member memberOf is found.'); |
|
88 } |
|
89 , |
|
90 function() { |
|
91 symbolize({a:true, _: [SYS.pwd+"test/namespace_nested.js"]}); |
|
92 |
|
93 is('symbols.getSymbol("ns1").name', "ns1", 'Base namespace name is found.'); |
|
94 is('symbols.getSymbol("ns1").memberOf', "", 'Base namespace memberOf is empty (its a constructor).'); |
|
95 is('symbols.getSymbol("ns1.ns2").name', "ns2", 'Nested namespace name is found.'); |
|
96 is('symbols.getSymbol("ns1.ns2").alias', "ns1.ns2", 'Nested namespace alias is found.'); |
|
97 is('symbols.getSymbol("ns1.ns2").memberOf', "ns1", 'Nested namespace memberOf is found.'); |
|
98 is('symbols.getSymbol("ns1.ns2.Function1").name', "Function1", 'Method of nested namespace name is found.'); |
|
99 is('symbols.getSymbol("ns1.ns2.Function1").memberOf', "ns1.ns2", 'Constructor of nested namespace memberOf is found.'); |
|
100 } |
|
101 , |
|
102 function() { |
|
103 symbolize({a:true, p:true, _: [SYS.pwd+"test/functions_nested.js"]}); |
|
104 |
|
105 is('symbols.getSymbol("Zop").name', "Zop", 'Any constructor name is found.'); |
|
106 is('symbols.getSymbol("Zop").isa', "CONSTRUCTOR", 'It isa constructor.'); |
|
107 is('symbols.getSymbol("Zop").hasMethod("zap")', true, 'Its method name, set later, is in methods array.'); |
|
108 is('symbols.getSymbol("Foo").name', "Foo", 'The containing constructor name is found.'); |
|
109 is('symbols.getSymbol("Foo").hasMethod("methodOne")', true, 'Its method name is found.'); |
|
110 is('symbols.getSymbol("Foo").hasMethod("methodTwo")', true, 'Its second method name is found.'); |
|
111 is('symbols.getSymbol("Foo#methodOne").alias', "Foo#methodOne", 'A methods alias is found.'); |
|
112 is('symbols.getSymbol("Foo#methodOne").isStatic', false, 'A methods is not static.'); |
|
113 is('symbols.getSymbol("Bar").name', "Bar", 'A global function declared inside another function is found.'); |
|
114 is('symbols.getSymbol("Bar").isa', "FUNCTION", 'It isa function.'); |
|
115 is('symbols.getSymbol("Bar").memberOf', "_global_", 'It is global.'); |
|
116 is('symbols.getSymbol("Foo-inner").name', "inner", 'An inner functions name is found.'); |
|
117 is('symbols.getSymbol("Foo-inner").memberOf', "Foo", 'It is member of the outer function.'); |
|
118 is('symbols.getSymbol("Foo-inner").isInner', true, 'It is an inner function.'); |
|
119 } |
|
120 , |
|
121 function() { |
|
122 symbolize({a:true, _: [SYS.pwd+"test/memberof_constructor.js"]}); |
|
123 |
|
124 is('symbols.getSymbol("Circle#Tangent").name', "Tangent", 'Constructor set on prototype using @member has correct name.'); |
|
125 is('symbols.getSymbol("Circle#Tangent").memberOf', "Circle", 'Constructor set on prototype using @member has correct memberOf.'); |
|
126 is('symbols.getSymbol("Circle#Tangent").alias', "Circle#Tangent", 'Constructor set on prototype using @member has correct alias.'); |
|
127 is('symbols.getSymbol("Circle#Tangent").isa', "CONSTRUCTOR", 'Constructor set on prototype using @member has correct isa.'); |
|
128 is('symbols.getSymbol("Circle#Tangent").isStatic', false, 'Constructor set on prototype using @member is not static.'); |
|
129 is('symbols.getSymbol("Circle#Tangent#getDiameter").name', "getDiameter", 'Method set on prototype using @member has correct name.'); |
|
130 is('symbols.getSymbol("Circle#Tangent#getDiameter").memberOf', "Circle#Tangent", 'Method set on prototype using @member has correct memberOf.'); |
|
131 is('symbols.getSymbol("Circle#Tangent#getDiameter").alias', "Circle#Tangent#getDiameter", 'Method set on prototype using @member has correct alias.'); |
|
132 is('symbols.getSymbol("Circle#Tangent#getDiameter").isa', "FUNCTION", 'Method set on prototype using @member has correct isa.'); |
|
133 is('symbols.getSymbol("Circle#Tangent#getDiameter").isStatic', false, 'Method set on prototype using @member is not static.'); |
|
134 } |
|
135 , |
|
136 function() { |
|
137 symbolize({a:true, p: true, _: [SYS.pwd+"test/memberof.js"]}); |
|
138 |
|
139 is('symbols.getSymbol("pack.install").alias', "pack.install", 'Using @memberOf sets alias, when parent name is in memberOf tag.'); |
|
140 is('symbols.getSymbol("pack.install.overwrite").name', "install.overwrite", 'Using @memberOf sets name, even if the name is dotted.'); |
|
141 is('symbols.getSymbol("pack.install.overwrite").memberOf', "pack", 'Using @memberOf sets memberOf.'); |
|
142 is('symbols.getSymbol("pack.install.overwrite").isStatic', true, 'Using @memberOf with value not ending in octothorp sets isStatic to true.'); |
|
143 } |
|
144 , |
|
145 function() { |
|
146 symbolize({a:true, p:true, _: [SYS.pwd+"test/borrows.js"]}); |
|
147 |
|
148 is('symbols.getSymbol("Layout").name', "Layout", 'Constructor can be found.'); |
|
149 is('symbols.getSymbol("Layout").hasMethod("init")', true, 'Constructor method name can be found.'); |
|
150 is('symbols.getSymbol("Layout").hasMember("orientation")', true, 'Constructor property name can be found.'); |
|
151 |
|
152 is('symbols.getSymbol("Page").hasMethod("reset")', true, 'Second constructor method name can be found.'); |
|
153 is('symbols.getSymbol("Page").hasMember("orientation")', true, 'Second constructor borrowed property name can be found in properties.'); |
|
154 is('symbols.getSymbol("Page#orientation").memberOf', "Page", 'Second constructor borrowed property memberOf can be found.'); |
|
155 is('symbols.getSymbol("Page-getInnerElements").alias', "Page-getInnerElements", 'Can borrow an inner function and it is still inner.'); |
|
156 is('symbols.getSymbol("Page.units").alias', "Page.units", 'Can borrow a static function and it is still static.'); |
|
157 |
|
158 is('symbols.getSymbol("ThreeColumnPage#init").alias', "ThreeColumnPage#init", 'Third constructor method can be found even though method with same name is borrowed.'); |
|
159 is('symbols.getSymbol("ThreeColumnPage#reset").alias', "ThreeColumnPage#reset", 'Borrowed method can be found.'); |
|
160 is('symbols.getSymbol("ThreeColumnPage#orientation").alias', "ThreeColumnPage#orientation", 'Twice borrowed method can be found.'); |
|
161 |
|
162 } |
|
163 , |
|
164 function() { |
|
165 symbolize({a:true, p:true, _: [SYS.pwd+"test/borrows2.js"]}); |
|
166 |
|
167 is('symbols.getSymbol("Foo").hasMethod("my_zop")', true, 'Borrowed method can be found.'); |
|
168 is('symbols.getSymbol("Bar").hasMethod("my_zip")', true, 'Second borrowed method can be found.'); |
|
169 } |
|
170 , |
|
171 function() { |
|
172 symbolize({a:true, p:true, _: [SYS.pwd+"test/constructs.js"]}); |
|
173 |
|
174 is('symbols.getSymbol("Person").hasMethod("say")', true, 'The constructs tag creates a class that lends can add a method to.'); |
|
175 } |
|
176 , |
|
177 function() { |
|
178 symbolize({a: true, _: [SYS.pwd+"test/augments.js", SYS.pwd+"test/augments2.js"]}); |
|
179 |
|
180 is('symbols.getSymbol("Page").augments[0]', "Layout", 'An augmented class can be found.'); |
|
181 is('symbols.getSymbol("Page#reset").alias', "Page#reset", 'Method of augmenter can be found.'); |
|
182 is('symbols.getSymbol("Page").hasMethod("Layout#init")', true, 'Method from augmented can be found.'); |
|
183 is('symbols.getSymbol("Page").hasMember("Layout#orientation")', true, 'Property from augmented can be found.'); |
|
184 is('symbols.getSymbol("Page").methods.length', 3, 'Methods of augmented class are included in methods array.'); |
|
185 |
|
186 is('symbols.getSymbol("ThreeColumnPage").augments[0]', "Page", 'The extends tag is a synonym for augments.'); |
|
187 is('symbols.getSymbol("ThreeColumnPage").hasMethod("ThreeColumnPage#init")', true, 'Local method overrides augmented method of same name.'); |
|
188 is('symbols.getSymbol("ThreeColumnPage").methods.length', 3, 'Local method count is right.'); |
|
189 |
|
190 is('symbols.getSymbol("NewsletterPage").augments[0]', "ThreeColumnPage", 'Can augment across file boundaries.'); |
|
191 is('symbols.getSymbol("NewsletterPage").augments.length', 2, 'Multiple augments are supported.'); |
|
192 is('symbols.getSymbol("NewsletterPage").inherits[0].alias', "Junkmail#annoy", 'Inherited method with augments.'); |
|
193 is('symbols.getSymbol("NewsletterPage").methods.length', 6, 'Methods of augmented class are included in methods array across files.'); |
|
194 is('symbols.getSymbol("NewsletterPage").properties.length', 1, 'Properties of augmented class are included in properties array across files.'); |
|
195 } |
|
196 , |
|
197 function() { |
|
198 symbolize({a:true, _: [SYS.pwd+"test/static_this.js"]}); |
|
199 |
|
200 is('symbols.getSymbol("box.holder").name', "holder", 'Static namespace name can be found.'); |
|
201 is('symbols.getSymbol("box.holder.foo").name', "foo", 'Static namespace method name can be found.'); |
|
202 is('symbols.getSymbol("box.holder").isStatic', true, 'Static namespace method is static.'); |
|
203 |
|
204 is('symbols.getSymbol("box.holder.counter").name', "counter", 'Instance namespace property name set on "this" can be found.'); |
|
205 is('symbols.getSymbol("box.holder.counter").alias', "box.holder.counter", 'Instance namespace property alias set on "this" can be found.'); |
|
206 is('symbols.getSymbol("box.holder.counter").memberOf', "box.holder", 'Static namespace property memberOf set on "this" can be found.'); |
|
207 } |
|
208 , |
|
209 function() { |
|
210 symbolize({a:true, p: true, _: [SYS.pwd+"test/lend.js"]}); |
|
211 |
|
212 is('symbols.getSymbol("Person").name', "Person", 'Class defined in lend comment is found.'); |
|
213 is('symbols.getSymbol("Person").hasMethod("initialize")', true, 'Lent instance method name can be found.'); |
|
214 is('symbols.getSymbol("Person").hasMethod("say")', true, 'Second instance method can be found.'); |
|
215 is('symbols.getSymbol("Person#sing").isStatic', false, 'Instance method is known to be not static.'); |
|
216 |
|
217 is('symbols.getSymbol("Person.getCount").name', "getCount", 'Static method name from second lend comment can be found.'); |
|
218 is('symbols.getSymbol("Person.getCount").isStatic', true, 'Static method from second lend comment is known to be static.'); |
|
219 |
|
220 is('LOG.warnings.filter(function($){if($.indexOf("notok") > -1) return $}).length', 1, 'A warning is emitted when lending to an undocumented parent.'); |
|
221 } |
|
222 , |
|
223 function() { |
|
224 symbolize({a:true, _: [SYS.pwd+"test/param_inline.js"]}); |
|
225 |
|
226 is('symbols.getSymbol("Layout").params[0].type', "int", 'Inline param name is set.'); |
|
227 is('symbols.getSymbol("Layout").params[0].desc', "The number of columns.", 'Inline param desc is set from comment.'); |
|
228 is('symbols.getSymbol("Layout#getElement").params[0].name', "id", 'User defined param documentation takes precedence over parser defined.'); |
|
229 is('symbols.getSymbol("Layout#getElement").params[0].isOptional', true, 'Default for param is to not be optional.'); |
|
230 is('symbols.getSymbol("Layout#getElement").params[1].isOptional', false, 'Can mark a param as being optional.'); |
|
231 is('symbols.getSymbol("Layout#getElement").params[1].type', "number|string", 'Type of inline param doc can have multiple values.'); |
|
232 is('symbols.getSymbol("Layout#Canvas").params[0].type', "", 'Type can be not defined for some params.'); |
|
233 is('symbols.getSymbol("Layout#Canvas").params[2].type', "int", 'Type can be defined inline for only some params.'); |
|
234 is('symbols.getSymbol("Layout#rotate").params.length', 0, 'Docomments inside function sig is ignored without a param.'); |
|
235 is('symbols.getSymbol("Layout#init").params[2].type', "zoppler", 'Doc comment type overrides inline type for param with same name.'); |
|
236 } |
|
237 , |
|
238 function() { |
|
239 symbolize({a: true, _: [SYS.pwd+"test/shared.js", SYS.pwd+"test/shared2.js"]}); |
|
240 |
|
241 is('symbols.getSymbol("Array#some").name', 'some', 'The name of a symbol in a shared section is found.'); |
|
242 is('symbols.getSymbol("Array#some").alias', 'Array#some', 'The alias of a symbol in a shared section is found.'); |
|
243 is('symbols.getSymbol("Array#some").desc', "Extension to builtin array.", 'A description can be shared.'); |
|
244 is('symbols.getSymbol("Array#filter").desc', "Extension to builtin array.\nChange every element of an array.", 'A shared description is appended.'); |
|
245 is('symbols.getSymbol("Queue").desc', "A first in, first out data structure.", 'A description is not shared when outside a shared section.'); |
|
246 is('symbols.getSymbol("Queue.rewind").alias', "Queue.rewind", 'Second shared tag can be started.'); |
|
247 is('symbols.getSymbol("startOver").alias', "startOver", 'Shared tag doesnt cross over files.'); |
|
248 } |
|
249 , |
|
250 function() { |
|
251 symbolize({a: true, _: [SYS.pwd+"test/config.js"]}); |
|
252 is('symbols.getSymbol("Contact").params[0].name', 'person', 'The name of a param is found.'); |
|
253 is('symbols.getSymbol("Contact").params[1].name', 'person.name', 'The name of a param set with a dot name is found.'); |
|
254 is('symbols.getSymbol("Contact").params[2].name', 'person.age', 'The name of a second param set with a dot name is found.'); |
|
255 is('symbols.getSymbol("Contact").params[4].name', 'connection', 'The name of a param after config is found.'); |
|
256 |
|
257 is('symbols.getSymbol("Family").params[0].name', 'persons', 'Another name of a param is found.'); |
|
258 is('symbols.getSymbol("Family").params[1].name', 'persons.Father', 'The name of a param+config is found.'); |
|
259 is('symbols.getSymbol("Family").params[2].name', 'persons.Mother', 'The name of a second param+config is found.'); |
|
260 is('symbols.getSymbol("Family").params[3].name', 'persons.Children', 'The name of a third param+config is found.'); |
|
261 } |
|
262 , |
|
263 function() { |
|
264 symbolize({a:true, p:true, _: [SYS.pwd+"test/ignore.js"]}); |
|
265 is('LOG.warnings.filter(function($){if($.indexOf("undocumented symbol Ignored") > -1) return $}).length', 1, 'A warning is emitted when documenting members of an ignored parent.'); |
|
266 } |
|
267 , |
|
268 function() { |
|
269 symbolize({a:true, p:true, _: [SYS.pwd+"test/functions_anon.js"]}); |
|
270 is('symbols.getSymbol("a.b").alias', 'a.b', 'In anonymous constructor this is found to be the container object.'); |
|
271 is('symbols.getSymbol("a.f").alias', 'a.f', 'In anonymous constructor this can have a method.'); |
|
272 is('symbols.getSymbol("a.c").alias', 'a.c', 'In anonymous constructor method this is found to be the container object.'); |
|
273 is('symbols.getSymbol("g").alias', 'g', 'In anonymous function executed inline this is the global.'); |
|
274 is('symbols.getSymbol("bar2.p").alias', 'bar2.p', 'In named constructor executed inline this is the container object.'); |
|
275 is('symbols.getSymbol("module.pub").alias', 'module.pub', 'In parenthesized anonymous function executed inline function scoped variables arent documented.'); |
|
276 } |
|
277 , |
|
278 function() { |
|
279 symbolize({a:true, p:true, _: [SYS.pwd+"test/oblit_anon.js"]}); |
|
280 is('symbols.getSymbol("opt").name', 'opt', 'Anonymous object properties are created.'); |
|
281 is('symbols.getSymbol("opt.conf.keep").alias', 'opt.conf.keep', 'Anonymous object first property is assigned to $anonymous.'); |
|
282 is('symbols.getSymbol("opt.conf.base").alias', 'opt.conf.base', 'Anonymous object second property is assigned to $anonymous.'); |
|
283 } |
|
284 , |
|
285 function() { |
|
286 symbolize({a:true, p:true, _: [SYS.pwd+"test/params_optional.js"]}); |
|
287 is('symbols.getSymbol("Document").params.length', 3, 'Correct number of params are found when optional param syntax is used.'); |
|
288 is('symbols.getSymbol("Document").params[1].name', "id", 'Name of optional param is found.'); |
|
289 is('symbols.getSymbol("Document").params[1].isOptional', true, 'Optional param is marked isOptional.'); |
|
290 is('symbols.getSymbol("Document").params[2].name', "title", 'Name of optional param with default value is found.'); |
|
291 is('symbols.getSymbol("Document").params[2].isOptional', true, 'Optional param with default value is marked isOptional.'); |
|
292 is('symbols.getSymbol("Document").params[2].defaultValue', " This is untitled.", 'Optional param default value is found.'); |
|
293 } |
|
294 , |
|
295 function() { |
|
296 symbolize({a:true, p:true, _: [SYS.pwd+"test/synonyms.js"]}); |
|
297 is('symbols.getSymbol("myObject.myFunc").type', 'function', 'Type can be set to function.'); |
|
298 } |
|
299 , |
|
300 function() { |
|
301 symbolize({a:true, p:true, _: [SYS.pwd+"test/event.js"]}); |
|
302 is('symbols.getSymbol("Kitchen#event:cakeEaten").isEvent', true, 'Function with event prefix is an event.'); |
|
303 is('symbols.getSymbol("Kitchen#cakeEaten").isa', "FUNCTION", 'Function with same name as event isa function.'); |
|
304 } |
|
305 , |
|
306 function() { |
|
307 symbolize({x:"js", a:true, _: [SYS.pwd+"test/scripts/"]}); |
|
308 is('JSDOC.JsDoc.srcFiles.length', 1, 'Only js files are scanned when -x=js.'); |
|
309 } |
|
310 , |
|
311 function() { |
|
312 symbolize({x:"js", a:true, _: [SYS.pwd+"test/exports.js"]}); |
|
313 is('symbols.getSymbol("mxn.Map#doThings").name', 'doThings', 'Exports creates a documentation alias that can have methods.'); |
|
314 } |
|
315 , |
|
316 function() { |
|
317 symbolize({p:true, a:true, _: [SYS.pwd+"test/module.js"]}); |
|
318 is('symbols.getSymbol("myProject.myModule.myPublicMethod").name', 'myPublicMethod', 'A function wrapped in parens can be recognized.'); |
|
319 is('symbols.getSymbol("myProject.myModule-myPrivateMethod").name', 'myPrivateMethod', 'A private method in the scope of a function wrapped in parens can be recognized.'); |
|
320 is('symbols.getSymbol("myProject.myModule-myPrivateVar").name', 'myPrivateVar', 'A private member in the scope of a function wrapped in parens can be recognized.'); |
|
321 } |
|
322 ]; |
|
323 |
|
324 //// run and print results |
|
325 print(testrun(testCases)); |