Context Navigation

parser.html

Last change on this file was 483, checked in by hendrikvanantwerpen, 11 years ago
Added Dojo 1.9.3 release.
File size: 41.7 KB

Rev	Line
[483]	1	<!DOCTYPE html>
	2	<html>
	3	<head>
	4	<title>Parser Unit Test</title>
	5	<style type="text/css">
	6	@import "../../resources/dojo.css";
	7	</style>
	8	<script type="text/javascript" src="../../dojo.js" data-dojo-config="isDebug:true, async:true"></script>
	9	<script type="text/javascript">
	10	var MyNonDojoClass = function() {};
	11	MyNonDojoClass.extend = function(){
	12	var args = arguments;
	13	return function() {
	14	this.expectedClass = true;
	15	this.params = args;
	16	};
	17	};
	18
	19	require([
	20	"require", "dojo/_base/array", "dojo/aspect", "dojo/_base/declare",
	21	"dojo/dom", "dojo/dom-attr", "dojo/dom-construct", "dojo/_base/lang", "dojo/on", "dojo/parser",
	22	"dojo/_base/window", "dojo/date/stamp", "dojo/Stateful", "dojo/Evented",
	23	"doh", "dojo/tests/resources/AMDWidget", "dojo/tests/resources/AMDMixin", "dojo/domReady!"
	24	], function(require, array, aspect, declare, dom, domAttr, domConstruct, lang, on, parser, win, dstamp,
	25	Stateful, Evented, doh, AMDWidget, AMDMixin){
	26
	27	declare("tests.parser.Widget", null, {
	28	constructor: function(args, node){
	29	this.params = args;
	30	}
	31	});
	32
	33	declare("tests.parser.Class1", null, {
	34	constructor: function(args, node){
	35	this.params = args;
	36	lang.mixin(this, args);
	37	},
	38	preambleTestProp: 1,
	39	preamble: function(){
	40	this.preambleTestProp++;
	41	},
	42	intProp: 1,
	43	callCount: 0, // for connect testing
	44	callInc: function(){ this.callCount++; },
	45	callCount2: 0, // for assignment testing
	46	strProp1: "original1",
	47	strProp2: "original2",
	48	arrProp: [],
	49	arrProp2: ["foo"],
	50	boolProp1: false,
	51	boolProp2: true,
	52	boolProp3: false,
	53	boolProp4: true,
	54	dateProp1: dstamp.fromISOString('2007-01-01'),
	55	dateProp2: dstamp.fromISOString('2007-01-01'),
	56	dateProp3: dstamp.fromISOString('2007-01-01'),
	57	funcProp: function(){},
	58	funcProp2: function(){},
	59	funcProp3: function(){},
	60	onclick: function(){ this.prototypeOnclick=true; }
	61	// FIXME: have to test dates!!
	62	// FIXME: need to test the args property!!
	63	});
	64
	65	declare("tests.parser.Class2", null, {
	66	constructor: function(){
	67	this.fromMarkup = false;
	68	},
	69	fromMarkup: false,
	70	markupFactory: function(args, node, classCtor){
	71	var i = new tests.parser.Class2();
	72	i.fromMarkup = true;
	73	return i;
	74	}
	75	});
	76
	77	declare("tests.parser.Class3", tests.parser.Class2, {
	78	fromMarkup: false,
	79	markupFactory: function(args, node, classCtor){
	80	var i = new classCtor();
	81	i.classCtor = classCtor;
	82	i.params = args;
	83	return i;
	84	}
	85	});
	86
	87	declare("tests.parser.InputClass", null, {
	88	constructor: function(args, node){
	89	this.params = args;
	90	lang.mixin(this, args);
	91	},
	92
	93	// these attributes are special in HTML, they don't have a value specified
	94	disabled: false,
	95	readonly: false,
	96	checked: false,
	97
	98	// other attributes native to HTML
	99	value: "default value",
	100	title: "default title",
	101	tabIndex: "0", // special because mixed case
	102
	103	// custom widget attributes that don't match a native HTML attributes
	104	custom1: 123,
	105	custom2: 456
	106	});
	107
	108	// Test that dir, lang, etc. attributes can be inherited from ancestor node
	109	declare("tests.parser.BidiClass", tests.parser.Widget, {
	110	constructor: function(args, node){ lang.mixin(this, args); },
	111	dir: "",
	112	lang: "",
	113	textdir: "",
	114	name: ""
	115	});
	116
	117	// For testing that parser recurses correctly, except when the prototype has a
	118	// stopParser flag
	119	declare("tests.parser.NormalContainer", null, {
	120	constructor: function(args, node){ lang.mixin(this, args); }
	121	});
	122	declare("tests.parser.ShieldedContainer", null, {
	123	constructor: function(args, node){ lang.mixin(this, args); },
	124
	125	// flag to tell parser not to instantiate nodes inside of me
	126	stopParser: true
	127	});
	128
	129	declare("tests.parser.HTML5Props", null, {
	130	constructor: function(args, node){ lang.mixin(this, args); },
	131	simple:false,
	132	a:2,
	133	b:null, c:null, d: null, e:null, f:null,
	134	afn: function(){
	135	return this.a * 2;
	136	}
	137	});
	138
	139	// not on .prototype:
	140	tests.parser.HTML5Props._aDefaultObj = {
	141	a:1, b:2, simple:true
	142	};
	143
	144	declare("tests.parser.HTML5withMethod", null, {
	145	constructor: function(args, node){ lang.mixin(this, args); },
	146	baseValue: 10,
	147	someMethod: function(a, b){
	148	return this.baseValue;
	149	},
	150	diffMethod: function(a){
	151	this._ran = true;
	152	}
	153	});
	154
	155	declare("tests.parser.StatefulClass", [Evented, Stateful], {
	156	strProp1: "",
	157	objProp1: {},
	158	boolProp1: false,
	159	prototypeOnclick: false,
	160	onclick: function() {this.prototypeOnclick=true;}
	161	});
	162
	163	declare("tests.parser.MethodClass", null, {
	164	method1ran: false,
	165	method1after: false,
	166	method2ran: false,
	167	method2before: false,
	168	method2after: false,
	169	method3result: "",
	170	method4ran: false,
	171	method4after: false,
	172	method1: function() { this.method1ran = true },
	173	method2: function() { this.method2ran = true },
	174	method3: function(result) { this.method3result = result; },
	175	method4: function() { this.method4ran = true }
	176	});
	177
	178	declare("tests.parser.ClassForMixins", null, {
	179	classDone: true
	180	});
	181
	182	declare("tests.parser.Mixin1", null, {
	183	mixin1Done: true
	184	});
	185
	186	declare("tests.parser.Mixin2", null, {
	187	mixin2Done: true
	188	});
	189
	190	deepTestProp = {
	191	blah: {
	192	thinger: 1
	193	}
	194	};
	195
	196	tests.parser.FormClass = declare(tests.parser.Widget, {
	197	encType: ""
	198	});
	199
	200	doh.register("basic tests", [
	201	function parse(){
	202	// Running the parser here so that failures appear in test log
	203	parser.parse(dom.byId("main"));
	204	},
	205	function testDataDojoId(t){
	206	t.is("object", typeof obj);
	207	},
	208	function testJsId(t){
	209	// Back-compat test, remove for 2.0
	210	t.is("object", typeof obj3);
	211	},
	212	// Attribute parsing tests
	213	function testStrProp(t){
	214	// normal string parameter
	215	t.t(typeof obj.strProp1 == "string", "obj.strProp1 is string");
	216	t.is("text", obj.strProp1);
	217
	218	// make sure that you override a string value like "foo" to a blank value
	219	t.t(typeof obj.strProp2 == "string", "obj.strProp2 is string");
	220	t.is("", obj.strProp2);
	221	},
	222	function testIntProp(t){
	223	t.is("number", (typeof obj.intProp));
	224	t.is(5, obj.intProp);
	225	},
	226	function testArrProp(t){
	227	t.is(3, obj.arrProp.length);
	228	t.is(3, obj.arrProp[1].length);
	229	t.is(["foo", "bar", "baz"], obj.arrProp);
	230
	231	// make sure empty arrays are possible
	232	t.is([], obj.arrProp2);
	233	},
	234	function testBoolProp(t){
	235	// make sure that both true and false get read correctly,
	236	// and that unspecified attributes' values don't change
	237
	238	// boolProp1 specified at true
	239	t.is("boolean", (typeof obj.boolProp1));
	240	t.t(obj.boolProp1);
	241
	242	// boolProp2 specified as false
	243	t.is("boolean", (typeof obj.boolProp2));
	244	t.f(obj.boolProp2);
	245
	246	// boolProp3 not specified (prototype says false)
	247	t.is("boolean", (typeof obj.boolProp3));
	248	t.f(obj.boolProp3);
	249
	250	// boolProp4 not specified (prototype says true)
	251	t.is("boolean", (typeof obj.boolProp4));
	252	t.t(obj.boolProp4);
	253	},
	254	function testDateProp(t){
	255	// dateProp1 specified as 2006-1-1
	256	t.is("2006-01-01", dstamp.toISOString(obj.dateProp1, {selector: 'date'}));
	257
	258	// dateProp2="", should map to NaN (a blank value on DateTextBox)
	259	t.t(isNaN(obj.dateProp2));
	260
	261	// dateProp3="now", should map to current date
	262	t.is(dstamp.toISOString(new Date(), {selector: 'date'}),
	263	dstamp.toISOString(obj.dateProp3, {selector: 'date'}));
	264	},
	265	function testUnwantedParams(t){
	266	// Make sure that parser doesn't pass any unwanted parameters to
	267	// widget constructor, especially "toString" or "constructor".
	268	// Make exception for dir/lang which parser gleans from document itself.
	269	for(var param in obj.params){
	270	doh.t(array.indexOf(
	271	["strProp1", "strProp2",
	272	"intProp",
	273	"arrProp", "arrProp2",
	274	"boolProp1", "boolProp2",
	275	"dateProp1", "dateProp2", "dateProp3",
	276	"funcProp2", "funcProp3",
	277	"preamble",
	278	"callInc1", "callInc2", "dir", "lang", "textDir"],
	279	param) >= 0, param);
	280	}
	281	},
	282	function testDisabledFlag(t){
	283	t.is("boolean", typeof disabledObj.disabled, "typeof disabled");
	284	t.t(disabledObj.disabled, "disabled");
	285	t.f(disabledObj.checked, "checked");
	286	},
	287	function testCheckedFlag(t){
	288	t.is("boolean", typeof checkedObj.checked, "typeof checked");
	289	t.f(checkedObj.disabled, "disabled");
	290	t.t(checkedObj.checked, "checked");
	291	},
	292	function testFunctionProp(t){
	293	// make sure that unspecified functions (even with common names)
	294	// don't get overridden (bug #3074)
	295	obj.onclick();
	296	t.t(obj.prototypeOnclick, "prototypeOnClick");
	297
	298	// funcProp2="foo"
	299	obj.funcProp2();
	300	t.t(obj.fooCalled, "fooCalled");
	301
	302	// funcProp3="this.func3Called=true;"
	303	obj.funcProp3();
	304	t.t(obj.func3Called, "func3Called");
	305	},
	306
	307	// test script tags inside innerHTML of source node
	308	"t.is(4, obj.preambleTestProp);",
	309	"t.is(deepTestProp, obj.deepProp);",
	310	function testConnect(t){
	311	obj.callInc();
	312	t.is(2, obj.callCount);
	313	},
	314	function testFunctionAssignment(t){
	315	obj.callInc2();
	316	t.is(1, obj.callCount2);
	317	},
	318	function testSubNodeParse(t){
	319	t.f(lang.exists("obj2"), "exists before parse");
	320	var toParse = dom.byId("toParse");
	321	parser.parse(toParse.parentNode);
	322	t.t(lang.exists("obj2"), "exists after parse");
	323	t.is("tests.parser.Class1", obj2.declaredClass);
	324	},
	325	function testMarkupFactory(t){
	326	t.t(lang.exists("obj3"), "obj3 exists");
	327	t.t(obj3.fromMarkup);
	328	},
	329	function testMarkupFactoryClass(t){
	330	t.t(lang.exists("obj4"), "obj4 exists");
	331	t.is(obj4.classCtor, tests.parser.Class3);
	332	t.t(obj4 instanceof tests.parser.Class3);
	333	t.t(obj4 instanceof tests.parser.Class2);
	334	},
	335	function testnostart(t){
	336
	337	var started = false;
	338	declare("SampleThinger", null, {
	339	startup: function(){
	340	started = true;
	341	}
	342	});
	343
	344	domConstruct.create("div", { dojoType:"SampleThinger" }, "parsertest");
	345	parser.parse("parsertest", { noStart:true });
	346
	347	t.f(started, "first started check");
	348
	349	domConstruct.empty("parsertest");
	350
	351	started = false;
	352
	353	domConstruct.create("div", { dojoType:"SampleThinger" }, "parsertest");
	354	parser.parse({ noStart:true, rootNode:"parsertest" });
	355
	356	t.f(started, "second started check");
	357	},
	358
	359	// test the various iterations of parser test
	360	function rootTest(t){
	361
	362	var tmp = aspect.after(dojo, "query", function(sel, root){
	363	t.is("parsertest2", root);
	364	});
	365
	366	parser.parse("parsertest2");
	367	parser.parse({ rootNode: "parsertest2" });
	368	parser.parse("parsertest2", { noStart:true });
	369
	370	tmp.remove();
	371	},
	372
	373	// Test that when BorderContainer etc. extends _Widget,
	374	// parser is aware of the new parameters added (to _Widget
	375	// and all of it's subclasses)
	376	function cacheRefresh(t){
	377	// Add new node to be parsed, referencing a widget that the parser has already
	378	// dealt with (and thus cached)
	379	var wrapper = domConstruct.place("<div><div dojoType='tests.parser.Class3' newParam=12345>hi</div></div>", win.body(), "last");
	380
	381	// Modify Class3's superclass widget to have new parameter (thus Class3 inherits it)
	382	lang.extend(tests.parser.Class2, {
	383	newParam: 0
	384	});
	385
	386	// Run the parser and see if it reads in newParam
	387	var widgets = parser.parse({rootNode: wrapper});
	388	doh.is(1, widgets.length, "parsed newly inserted parserTest widget");
	389	doh.is(12345, widgets[0].params.newParam, "new parameter parsed");
	390	},
	391
	392	// Test that parser recurses correctly, except when there's a stopParser flag not to
	393	function recurse(){
	394	doh.t(container1, "normal container created");
	395	doh.t(container1.incr, "script tag works too");
	396	doh.t(window.contained1, "child widget also created");
	397	doh.t(window.contained2, "child widget 2 also created");
	398
	399	doh.t(container2, "shielded container created");
	400	doh.t(container2.incr, "script tag works too");
	401	doh.f(window.contained3, "child widget not created");
	402	doh.f(window.contained4, "child widget 2 not created");
	403	},
	404
	405	function simpleHTML5(){
	406	doh.is("object", typeof html5simple, "data-dojo-id export");
	407	doh.is("object", typeof html5simple2, "data-dojo-id export");
	408
	409	doh.t(html5simple.simple, "default respecified in props=''");
	410	doh.f(html5simple2.simple, "default overridden by props=''");
	411
	412	// test data-dojo-props="simple:false, a:1, b:'two', c:[1,2,3], d:function(){ return this; }, e:{ f:'g' }"
	413	var it = html5simple2;
	414	doh.is(1, it.a, "number in param");
	415	doh.is("two", it.b, "string in param");
	416	doh.t(it.c instanceof Array, "array in param");
	417	doh.is(3, it.c.length, "array sanity");
	418	doh.is("g", it.e.f, "nested object with string");
	419
	420	// test the function
	421	doh.is(it, it.d(), "simple 'return this' function");
	422
	423	},
	424
	425	function html5inherited(){
	426	doh.is("object", typeof html5simple3);
	427	var val = html5simple3.afn();
	428	doh.is(html5simple3.a * 2, val, "afn() overrides default but calls inherited")
	429	},
	430
	431	function html5withMethod(){
	432	// testing data-dojo-event and data-dojo-args support for dojo/method and dojo/connect
	433	doh.is("object", typeof htmldojomethod);
	434	doh.t(htmldojomethod._methodRan, "plain dojo/method ran");
	435
	436	var x = htmldojomethod.someMethod(2, 2);
	437	doh.is(14, x, "overridden dojo/method");
	438
	439	htmldojomethod.diffMethod(2);
	440	doh.t(htmldojomethod._ran, "ensures original was called first");
	441	doh.is(2, htmldojomethod._fromvalue, "ensures connected was executed in scope");
	442	},
	443
	444	function testOnWatch(){
	445	// testing script-type dojo/watch and dojo/on
	446	doh.is("object", typeof objOnWatch);
	447	objOnWatch.set("strProp1","newValue1");
	448	doh.is("newValue1", objOnWatch.arrProp.newValue, "ensures watch executed");
	449
	450	objOnWatch.onclick();
	451	doh.t(objOnWatch.prototypeOnclick, "ensures original was called");
	452	doh.t(objOnWatch.boolProp1, "ensure on executed in scope");
	453	},
	454
	455	function testOn2(){
	456	// testing script-type dojo/on, when script comes after another element
	457	parser.parse("on");
	458	doh.t("on_form" in window, "widget created");
	459	on_form.emit("click");
	460	doh.t(on_form.clicked, "on callback fired");
	461	},
	462
	463	function testAspect(){
	464	// testing script-type dojo/aspect
	465	doh.is("object", typeof objAspect);
	466	doh.f(objAspect.method1ran, "ensures method unfired");
	467	doh.f(objAspect.method2ran, "ensures method unfired");
	468	doh.is(objAspect.method3result, "", "ensures method unfired");
	469	doh.f(objAspect.method4ran, "ensures method unfired");
	470
	471	objAspect.method1();
	472	objAspect.method2();
	473	objAspect.method3("something");
	474	objAspect.method4();
	475
	476	doh.t(objAspect.method1ran, "method fired");
	477	doh.t(objAspect.method1after, "after advice fired");
	478	doh.t(objAspect.method2ran, "method fired");
	479	doh.t(objAspect.method2before, "around before advice fired");
	480	doh.t(objAspect.method2after, "around after advice fired");
	481	doh.is(objAspect.method3result, "before", "before argument passed");
	482	doh.t(objAspect.method4ran, "method fired");
	483	doh.t(objAspect.method4after, "after advice fired");
	484	},
	485
	486	function testMID(){
	487	// testing specifying data-dojo-type as mid
	488	doh.is("object", typeof objAMDWidget);
	489	doh.is("Value1", objAMDWidget.params.value, "ensure object was properly parsed using MID");
	490	}
	491	]);
	492
	493	doh.register("BIDI", [
	494	// Test that dir=rtl or dir=ltr setting trickles down from root node
	495	function dirAttr(){
	496	parser.parse("dirSection1");
	497	parser.parse("dirSection2");
	498	doh.is("rtl", setRtl.dir, "direct setting of dir=rtl works");
	499	doh.is("rtl", inheritRtl.dir, "inherited rtl works");
	500	doh.is("ltr", inheritLtr.dir, "inherited ltr works (closest ancestor wins)");
	501	doh.is("rtl", inheritRtl2.dir, "inherited rtl works, from grandparent");
	502	doh.is("ltr", setLtr.dir, "direct setting of dir=ltr overrides inherited RTL");
	503	},
	504	function langAttr(){
	505	parser.parse("langSection");
	506	doh.f(lang in noLang.params, "no lang");
	507	doh.is("it_it", inheritedLang.lang, "inherited lang works");
	508	doh.is("en_us", specifiedLang.lang,"direct setting of lang overrides inherited");
	509	},
	510	function textdirAttr(){
	511	parser.parse("textDirSection");
	512	doh.f("textDir" in noTextdir.params, "no textdir");
	513	doh.is("rtl", inheritedTextdir.textDir, "inherited textdir works");
	514	doh.is("ltr", specifiedTextdir.textDir,"direct setting of textdir overrides inherited");
	515	},
	516	{
	517	// Test that calling parser.parse(nodeX) will inherit dir/lang/etc. settings
	518	// even from <html>
	519	name: "inheritance from HTML",
	520	setUp: function(){
	521	domAttr.set(win.doc.documentElement, {dir: "rtl", lang: "ja-jp", "data-dojo-textdir": "auto"});
	522	parser.parse("bidiInheritanceFromHtml");
	523	},
	524	runTest: function(){
	525	doh.is("rtl", inheritedFromHtml.params.dir, "dir");
	526	doh.is("ja-jp", inheritedFromHtml.params.lang, "lang");
	527	doh.is("auto", inheritedFromHtml.params.textDir, "textDir");
	528	},
	529	tearDown: function(){
	530	array.forEach(["dir", "lang", "data-dojo-textdir"], function(attr){
	531	win.doc.documentElement.removeAttribute(attr);
	532	});
	533	}
	534	}
	535	]);
	536
	537	doh.register("IE attribute detection", [
	538	function input1(){
	539	var widgets = parser.instantiate([dom.byId("ieInput1")]);
	540	var params = widgets[0].params;
	541
	542	doh.is("checkbox", params.type, "type");
	543	doh.t(params.disabled, "disabled");
	544	doh.t(params.checked, "checked");
	545	doh.t(params.readonly, "readonly");
	546	doh.is("bar", params.foo, "foo");
	547	doh.is("zaz", params.bar, "bar");
	548	doh.is("escaped\"dq", params.bob, "bob");
	549	doh.is("escaped\'sq", params.frank, "frank");
	550	//doh.f("value" in params, "value not specified"); // fails in IE8, thinks value=="on"
	551	},
	552	function input2(){
	553	var widgets = parser.instantiate([dom.byId("ieInput2")]);
	554	var params = widgets[0].params;
	555
	556	doh.f("type" in params, "type");
	557	doh.f("name" in params, "name");
	558	doh.f("value" in params, "value");
	559	doh.f("data-dojo-type" in params, "data-dojo-type");
	560	doh.f("data-dojo-props" in params, "data-dojo-props");
	561	doh.is("hi", params.foo, "foo");
	562	doh.f("value" in params, "value not specified");
	563	},
	564	function input3(){
	565	var widgets = parser.instantiate([dom.byId("ieInput3")]);
	566	var params = widgets[0].params;
	567
	568	doh.is("password", params.type, "type");
	569	doh.is("test", params.name, "name");
	570	doh.is("123", params.value, "value");
	571	doh.is("myClass", params["class"], "class");
	572	doh.is("display:block", params["style"].replace(/[ ;]/g, "").toLowerCase(), "style");
	573	doh.is("3", params.tabIndex, "tabIndex");
	574	},
	575	function textarea(){
	576	var widgets = parser.instantiate([dom.byId("ieTextarea")]);
	577	var params = widgets[0].params;
	578
	579	doh.is("attrVal", params.value, "value");
	580	},
	581	function button1(){
	582	var widgets = parser.instantiate([dom.byId("ieButton1")]);
	583	var params = widgets[0].params;
	584	doh.t(params.checked, "checked");
	585	doh.is("button1val", params.value, "value");
	586	},
	587	function button2(){
	588	var widgets = parser.instantiate([dom.byId("ieButton2")]);
	589	var params = widgets[0].params;
	590	doh.f("checked" in params, "checked");
	591	doh.f("value" in params, "value");
	592	},
	593	function button3(){
	594	var widgets = parser.instantiate([dom.byId("ieButton3")]);
	595	var params = widgets[0].params;
	596	doh.t(params.checked, "checked");
	597	},
	598	function button4(){
	599	var widgets = parser.instantiate([dom.byId("ieButton4")]);
	600	var params = widgets[0].params;
	601	doh.f("checked" in params);
	602	},
	603	function form1(){
	604	var widgets = parser.instantiate([dom.byId("ieForm1")]);
	605	var params = widgets[0].params;
	606
	607	doh.is("foo", params.encType, "encType is specified");
	608	},
	609	function form2(){
	610	var widgets = parser.instantiate([dom.byId("ieForm2")]);
	611	var params = widgets[0].params;
	612
	613	doh.f("encType" in params, "encType not specified")
	614	},
	615	function li(){
	616	var widgets = parser.instantiate([dom.byId("li")]);
	617	var params = widgets[0].params;
	618	doh.is("home", params.value);
	619
	620	}
	621	]);
	622
	623	doh.register("mixed attribute specification", function mixed(){
	624	parser.parse(dom.byId("mixedContainer"));
	625	doh.is("object", typeof mixedObj, "widget created");
	626	doh.is("mixedValue", mixedObj.value, "native attribute");
	627	doh.is(999, mixedObj.custom1, "data-dojo-props attribute");
	628	doh.is("custom title", mixedObj.title, "data-dojo-props overrides native");
	629	});
	630
	631	doh.register("functions", function onclick(){
	632	// Create objects referenced from markup inside of "functions" div
	633	declare("tests.parser.Button", null, {
	634	onClick: function(){
	635	console.log("prototype click");
	636	},
	637	constructor: function(args, node){
	638	lang.mixin(this, args);
	639	this.domNode = node;
	640	aspect.after(this.domNode, "onclick", lang.hitch(this, "onClick"));
	641	}
	642	});
	643	buttonClicked = function(){
	644	console.log("markup click");
	645	}; // markup says onClick="buttonClicked"
	646
	647	// Parse markup inside "functions" div
	648	parser.parse("functions");
	649
	650	// Should have created an instance called "button" where button.onClick == buttonClicked
	651	doh.is("object", typeof button, "widget created");
	652	doh.is("function", typeof button.onClick, "created as function");
	653	doh.t(buttonClicked == button.onClick, "points to specified function");
	654	});
	655
	656	doh.register("parser.instantiate()", function instantiate1() {
	657	var nodes = [dom.byId("objId1"),dom.byId("objId2"),dom.byId("contId1"),dom.byId("objId3")];
	658	parser.instantiate(nodes);
	659	doh.is("object", typeof objI1, "widget 1 created");
	660	doh.is("object", typeof objI2, "widget 2 created");
	661	doh.t(contI1, "container created");
	662	doh.is("object", typeof objI3, "child widget 3 created");
	663	doh.f(window.objI4, "child widget 4 not created");
	664	});
	665
	666	doh.register("parser.construct()", function construct1() {
	667	var nodes = [dom.byId("objC1"),dom.byId("objC2")];
	668
	669	parser.construct(tests.parser.Class1, dom.byId("objC1"));
	670	doh.is("object", typeof objC1, "widget 1 created");
	671	doh.is(5, objC1.intProp, "objC1.intProp");
	672
	673	parser.construct(tests.parser.Class1, dom.byId("objC2"));
	674	doh.is("object", typeof objC2, "widget 2 created");
	675	doh.is(5, objC2.intProp, "objC2.intProp");
	676	});
	677
	678	doh.register("data-dojo-mixins support", function mixins() {
	679	parser.parse("mixins");
	680	doh.t(resultMixins1, "object using data-dojo-mixins created from an already parsed type");
	681	doh.t(resultMixins1.mixin1Done, "mixin1 correctly mixed in");
	682	doh.t(resultMixins1.mixin2Done, "mixin2 correctly mixed in");
	683	doh.t(resultMixins1.amdMixinDone, "amd mixin correctly mixed in");
	684	doh.t(resultMixins2, "object using data-dojo-mixins created from a non parsed type");
	685	doh.t(resultMixins2.classDone, "class correctly created");
	686	doh.t(resultMixins2.mixin1Done, "mixin1 correctly mixed in");
	687	doh.t(resultMixins2.mixin2Done, "mixin2 correctly mixed in");
	688	doh.t(resultMixins2.amdMixinDone, "amd mixin correctly mixed in");
	689	doh.t(resultNonDojoMixin.expectedClass, "correct class is returned for composeJS mixin");
	690	doh.is(resultNonDojoMixin.params.length, 2, "correct # of params were passed to compose JS");
	691	doh.is(resultNonDojoMixin.params[0], tests.parser.Mixin1, "correct param 1");
	692	doh.is(resultNonDojoMixin.params[1], tests.parser.Mixin2, "correct param 2");
	693	});
	694
	695	// For any special issues with behavioral widgets (as opposed to Templated)
	696	doh.register("behavioral", [
	697	function doubleConnect(){
	698	// Class used in "behavioral" <div>
	699	Behavioral1 = declare(null, {
	700	constructor: function(params, node){
	701	on(node, "click", lang.hitch(this, "onClick"));
	702	if(typeof params.onClick != "function"){
	703	throw new Error("onClick not passed to constructor");
	704	}
	705	lang.mixin(this, params);
	706	},
	707	onClick: function(){
	708	console.log("original onnClick handler")
	709	},
	710	foo: ""
	711	});
	712
	713	parser.parse("behavioral");
	714
	715	// Setup global accessed by Behavioral1.onclick handler
	716	behavioralClickCounter = 0;
	717
	718	// Trigger click event, and make sure that handler was only called once.
	719	on.emit(dom.byId("bh1"), "click", {bubbles: true, cancelable: true});
	720
	721	doh.is(1, behavioralClickCounter, "one click event processed");
	722
	723	doh.is("bar", dom.byId("bh1").getAttribute("foo"), "foo attribute not removed from widget DOMNode");
	724	}
	725	]);
	726
	727	doh.register("script type=dojo/require support", function declarativeRequire(){
	728	var td = new doh.Deferred();
	729
	730	parser.parse("declarativeRequire").then(td.getTestCallback(function(){
	731	doh.is(typeof dr1, "object", "object using MID mapped to return var");
	732	doh.is(dr1.params.foo, "bar", "parameters set on instantiation");
	733	doh.is(typeof dr2, "object", "object using MID mapped to return var");
	734	doh.is(dr2.params.foo, "bar", "parameters set on instantiation");
	735	doh.is(typeof dr3, "object", "object using fully required");
	736	doh.is(dr3.params.foo, "bar", "parameters set on instantiation");
	737	doh.is(dr4.params.foo, 2, "module loaded and executed");
	738	doh.is(dr5.method1(1), 3, "declarative script has access to parser scope");
	739	}));
	740
	741	return td;
	742	});
	743
	744	doh.register("context require support", function contextRequire(){
	745	var td = new doh.Deferred();
	746
	747	parser.parse("contextRequire", {
	748	contextRequire: require
	749	}).then(td.getTestCallback(function(){
	750	doh.is(typeof cr1, "object", "object using relative MID mapped to return var");
	751	doh.is(cr1.params.foo, "bar", "parameters set on instantiation");
	752	doh.is(typeof cr2, "object", "object using relative MID mapped to return var");
	753	doh.is(cr2.params.foo, "bar", "parameters set on instantiation");
	754	doh.is(typeof cr3, "object", "object using relative MID mapped to return var");
	755	doh.is(cr3.params.foo, "bar", "parameters set on instantiation");
	756	doh.is(typeof cr4, "object", "object using relative MID mapped to return var");
	757	doh.is(cr4.params.foo, "bar", "parameters set on instantiation");
	758	}));
	759
	760	return td;
	761	});
	762
	763	doh.register("promise error handling support", [
	764	function asyncError(){
	765	var td = new doh.Deferred();
	766
	767	parser.parse("errorHandling").then(td.getTestErrback(function(){
	768	throw new Error("shouldn't get here");
	769	}), td.getTestCallback(function(e){
	770	doh.is(typeof e, "object", "error object returned");
	771	}));
	772
	773	return td;
	774	},
	775	function missingCtor(){
	776	var td = new doh.Deferred();
	777
	778	parser.parse("missingCtor").then(td.getTestErrback(function(){
	779	throw new Error("shouldn't get here");
	780	}), td.getTestCallback(function(e){
	781	doh.is(typeof e, "object", "error object returned");
	782	doh.is(e.toString(), "Error: Unable to resolve constructor for: 'some.type'", "proper error value returned");
	783	}));
	784
	785	return td;
	786	}
	787	]);
	788
	789	doh.run();
	790	});
	791	</script>
	792	</head>
	793	<body>
	794	<h1>Parser Unit Test</h1>
	795
	796	<div id=main>
	797	<script>
	798	function foo(){ this.fooCalled=true; }
	799	</script>
	800	<div dojoType="tests.parser.Class1" data-dojo-id="obj"
	801	strProp1="text" strProp2=""
	802	intProp="5"
	803	arrProp="foo, bar, baz"
	804	arrProp2=""
	805	boolProp1="true" boolProp2="false"
	806	dateProp1="2006-01-01" dateProp2="" dateProp3="now"
	807	funcProp2="foo" funcProp3="this.func3Called=true;"
	808	>
	809	<script type="dojo/method" data-dojo-event="preamble">
	810	this.preambleTestProp = 3;
	811	</script>
	812	<script type="dojo/method">
	813	// this should be run immediately
	814	this.deepProp = deepTestProp;
	815	</script>
	816	<script type="dojo/connect" data-dojo-event="callInc">
	817	this.callCount++;
	818	</script>
	819	<script type="dojo/method" data-dojo-event="callInc2">
	820	this.callCount2++;
	821	</script>
	822	</div>
	823	<div dojoType="tests.parser.Class2" jsId="obj3">
	824	</div>
	825	<div dojoType="tests.parser.Class3" data-dojo-id="obj4">
	826	</div>
	827	<input dojoType="tests.parser.InputClass" data-dojo-id="checkedObj" checked type="checkbox">
	828	<button dojoType="tests.parser.InputClass" data-dojo-id="disabledObj" disabled>hi</button>
	829
	830	<div id="parsertest"></div>
	831	<div id="parsertest2"></div>
	832
	833	<!-- section for testing parser recursion -->
	834	<div>
	835	<div dojoType="tests.parser.NormalContainer" data-dojo-id="container1">
	836	<!-- this script tag should get passed as param to NormalContainer constructor -->
	837	<script type="dojo/method" data-dojo-event="incr" data-dojo-args="x">
	838	return x+1;
	839	</script>
	840
	841	<!-- and these contained widgets should get instantiated -->
	842	<div dojoType="tests.parser.Class1" data-dojo-id="contained1"></div>
	843	<div>
	844	<div dojoType="tests.parser.Class1" data-dojo-id="contained2"></div>
	845	</div>
	846	</div>
	847	</div>
	848
	849	<div>
	850	<div dojoType="tests.parser.ShieldedContainer" data-dojo-id="container2">
	851	<!-- this script tag should get passed as param to ShieldedContainer constructor -->
	852	<script type="dojo/method" data-dojo-event="incr" data-dojo-args="x">
	853	return x+1;
	854	</script>
	855
	856	<!-- but these contained widgets should not get instantiated -->
	857	<div dojoType="tests.parser.Class1" data-dojo-id="contained3"></div>
	858	<div>
	859	<div dojoType="tests.parser.Class1" data-dojo-id="contained4"></div>
	860	</div>
	861	</div>
	862	</div>
	863
	864	<!-- tests for new data-dojo-type / data-dojo-props syntax -->
	865	<div>
	866	<div data-dojo-id="html5simple" data-dojo-type="tests.parser.HTML5Props" data-dojo-props="simple:true"></div>
	867	<div data-dojo-id="html5simple2" data-dojo-type="tests.parser.HTML5Props"
	868	data-dojo-props="simple:false, a:1, b:'two', c:[1,2,3], d:function(){ return this; }, e:{ f:'g' }"
	869	></div>
	870	<!-- note needing to use a named inherited lookup because we're just mixing in -->
	871	<div data-dojo-id="html5simple3" data-dojo-type="tests.parser.HTML5Props"
	872	data-dojo-props="afn: function(){ return this.inherited('afn', arguments); }"
	873	></div>
	874
	875	<!-- not used for tests, but thinking out loud: what about a named-resource prop, via getObject -->
	876	<div data-dojo-id="html5fromobjectns" data-dojo-type="tests.parser.HTML5Props"
	877	data-dojo-obj="tests.parser.HTML5Props._aDefaultObj"
	878	></div>
	879	<div data-dojo-id="html5fromobjectns2" data-dojo-type="tests.parser.HTML5Props"
	880	data-dojo-obj="tests.parser.HTML5Props._aDefaultObj" data-dojo-props="simple:false"
	881	></div>
	882
	883	</div>
	884
	885	<div>
	886	<div data-dojo-id="htmldojomethod" data-dojo-type="tests.parser.HTML5withMethod">
	887	<p>Some random markup</p>
	888	<script type="dojo/method" data-dojo-event="someMethod" data-dojo-args="a, b">
	889	return this.baseValue + a + b;
	890	</script>
	891	<script type="dojo/connect" data-dojo-event="diffMethod" data-dojo-args="a">
	892	console.log("diffMethod connect, this is ", this);
	893	this._fromvalue = a;
	894	</script>
	895	<script type="dojo/method">
	896	this._methodRan = true;
	897	</script>
	898	<div data-dojo-id="objAspect" data-dojo-type="tests.parser.MethodClass">
	899	<script type="dojo/aspect" data-dojo-method="method1" data-dojo-advice="after">
	900	if(this.method1ran){
	901	this.method1after = true;
	902	}
	903	</script>
	904	<script type="dojo/aspect" data-dojo-method="method2" data-dojo-advice="around" data-dojo-args="origFn">
	905	return function(){
	906	if(!this.method2ran){
	907	this.method2before = true;
	908	}
	909	origFn.call(this);
	910	if(this.method2ran){
	911	this.method2after = true;
	912	}
	913	};
	914	</script>
	915	<script type="dojo/aspect" data-dojo-method="method3" data-dojo-advice="before" data-dojo-args="result">
	916	if(result == "something"){
	917	return ["before"];
	918	}
	919	</script>
	920	<script type="dojo/aspect" data-dojo-method="method4">
	921	if(this.method4ran){
	922	this.method4after = true;
	923	}
	924	</script>
	925	</div>
	926	</div>
	927	</div>
	928
	929	<!-- section for testing dojo/on and dojo/watch scripts -->
	930	<div>
	931	<div data-dojo-id="objOnWatch" data-dojo-type="tests.parser.StatefulClass">
	932	<script type="dojo/watch" data-dojo-prop="strProp1" data-dojo-args="prop,oldValue,newValue">
	933	this.set("arrProp",{prop: prop, oldValue: oldValue, newValue: newValue});
	934	</script>
	935	<script type="dojo/on" data-dojo-event="click" data-dojo-args="e">
	936	console.log("diffMethod on, this is ",this);
	937	this.set("boolProp1",true);
	938	</script>
	939	</div>
	940	</div>
	941
	942	<!-- section for testing mid syntax for data-dojo-type -->
	943	<div>
	944	<div data-dojo-id="objAMDWidget" data-dojo-type="dojo/tests/resources/AMDWidget" data-dojo-props="value: 'Value1'"></div>
	945	</div>
	946	</div> <!-- end of <div id=main> -->
	947
	948	<!-- more dojo/on tests -->
	949	<div id="on">
	950	<form action="/SomeUrl" data-dojo-type="tests.parser.StatefulClass" data-dojo-id="on_form">
	951	<input data-dojo-type="tests.parser.InputClass" name="ACheckBox" />
	952	<script type="dojo/on" data-dojo-event="click">
	953	this.clicked = true;
	954	</script>
	955	</form>
	956	</div>
	957
	958	<!-- section for testing parse on a subnode -->
	959	<div>
	960	<div data-dojo-type="tests.parser.Class1" data-dojo-id="obj2" id="toParse">
	961	</div>
	962	</div>
	963
	964	<!-- section for testing that dir, lang attribute trickles down from ancestor -->
	965	<div id="dirSection1">
	966	<div dojoType="tests.parser.BidiClass" data-dojo-id="setRtl" dir="rtl" name="RTL setting"></div>
	967	<div dojoType="tests.parser.BidiClass" data-dojo-id="noDir" name="dir not inherited or set"></div>
	968	</div>
	969	<div id="dirSection2" dir="rtl">
	970	<div dojoType="tests.parser.BidiClass" data-dojo-id="inheritRtl" name="inherited RTL from parent"></div>
	971	<div dir="ltr">
	972	<div dojoType="tests.parser.BidiClass" data-dojo-id="inheritLtr" name="inherited LTR from parent"></div>
	973	</div>
	974	<div>
	975	<div dojoType="tests.parser.BidiClass" data-dojo-id="inheritRtl2" name="inherited RTL from grandparent"></div>
	976	</div>
	977	<div dojoType="tests.parser.BidiClass" data-dojo-id="setLtr" dir="ltr" name="LTR setting overrides inherited RTL"></div>
	978	</div>
	979	<div id="langSection">
	980	<div dojoType="tests.parser.BidiClass" data-dojo-id="noLang" name="shouldn't get lang"></div>
	981	<div lang="it_it">
	982	<div dojoType="tests.parser.BidiClass" data-dojo-id="inheritedLang" name="inherited lang from parent"></div>
	983	<div dojoType="tests.parser.BidiClass" data-dojo-id="specifiedLang" lang="en_us" name="specified lang overrides parent"></div>
	984	</div>
	985	</div>
	986	<div id="textDirSection">
	987	<div dojoType="tests.parser.BidiClass" data-dojo-id="noTextdir" name="shouldn't get textdir"></div>
	988	<div data-dojo-textdir="rtl">
	989	<div dojoType="tests.parser.BidiClass" data-dojo-id="inheritedTextdir" name="inherited textdir from parent"></div>
	990	<div dojoType="tests.parser.BidiClass" data-dojo-id="specifiedTextdir" data-dojo-textdir="ltr" name="specified textdir overrides parent"></div>
	991	</div>
	992	</div>
	993	<div id="bidiInheritanceFromHtml">
	994	<div dojoType="tests.parser.BidiClass" data-dojo-id="inheritedFromHtml" name="should get dir/lang/textDir from HTML tag"></div>
	995	</div>
	996
	997	<!-- tests that we can parse parameters correctly on IE6/7, not getting tripped up by escaped quotes etc. -->
	998	<div id=ie>
	999	<input id="ieInput1" data-dojo-type="tests.parser.InputClass"
	1000	type=checkbox disabled foo = 'bar' readonly bar=zaz bob='escaped"dq' frank="escaped'sq" checked />
	1001	<input id="ieInput2" data-dojo-type="tests.parser.InputClass"
	1002	fakeout1="type=submit" fakeout2="name='test'" fakeout3="value='123'" data-dojo-props="foo: 'hi'"/>
	1003	<input id="ieInput3" data-dojo-type="tests.parser.InputClass"
	1004	type=password name="test" value="123" class="myClass" style="display:block" tabindex="3"/>
	1005	<textarea id="ieTextarea" data-dojo-type="tests.parser.InputClass" value="attrVal">contentVal</textarea>
	1006	<button id="ieButton1" data-dojo-type="tests.parser.InputClass" checked value="button1val">
	1007	checked ToggleButton as button
	1008	</button>
	1009	<button id="ieButton2" data-dojo-type="tests.parser.InputClass">
	1010	unchecked ToggleButton as button
	1011	</button>
	1012	<div id="ieButton3" data-dojo-type="tests.parser.InputClass" checked>
	1013	checked ToggleButton as div
	1014	</div>
	1015	<div id="ieButton4" data-dojo-type="tests.parser.InputClass">
	1016	unchecked ToggleButton as div
	1017	</div>
	1018	<form id="ieForm1" data-dojo-type="tests.parser.FormClass" encType="foo"></form>
	1019	<form id="ieForm2" data-dojo-type="tests.parser.FormClass"></form>
	1020	<ul dojoType="tests.parser.Widget" class="nav">
	1021	<li id="li" dojoType="tests.parser.Widget" value="home">Home</li>
	1022	<li dojoType="tests.parser.Widget" value="contact">Contact</li>
	1023	<li dojoType="tests.parser.Widget" value="group">Group</li>
	1024	<li dojoType="tests.parser.Widget" value="campaign">Campaign</li>
	1025	</ul>
	1026	</div>
	1027
	1028	<!-- tests for when parameters are specified both natively and in data-dojo-props. -->
	1029	<div id="mixedContainer">
	1030	<input data-dojo-type="tests.parser.InputClass" data-dojo-id="mixedObj"
	1031	value="mixedValue" title="native title" data-dojo-props="custom1: 999, title: 'custom title'">
	1032	</div>
	1033
	1034	<!-- tests for function names native to HTML, specifically an issue on IE<8 -->
	1035	<div id="functions">
	1036	<button dojoType="tests.parser.Button" onClick="buttonClicked" data-dojo-id="button">Click me</button>
	1037	</div>
	1038
	1039	<!-- section for testing parser.instantiate() -->
	1040	<div id="instantiate1">
	1041	<div dojoType="tests.parser.Class1" data-dojo-id="objI1" id="objId1"
	1042	strProp1="text" strProp2=""
	1043	intProp="5"
	1044	arrProp="foo, bar, baz"
	1045	arrProp2=""
	1046	boolProp1="true" boolProp2="false"
	1047	dateProp1="2006-01-01" dateProp2="" dateProp3="now"
	1048	funcProp2="foo" funcProp3="this.func3Called=true;"
	1049	>
	1050	</div>
	1051	<div data-dojo-type="tests.parser.Class1" data-dojo-id="objI2" id="objId2"
	1052	data-dojo-props="
	1053	strProp1:'text',
	1054	strProp2:'',
	1055	intProp:5,
	1056	arrProp:['foo', 'bar', 'baz'],
	1057	arrProp2:[],
	1058	boolProp1:true,
	1059	boolProp2:'false',
	1060	dateProp1:'2006-01-01',
	1061	dateProp2:'',
	1062	dateProp3:'now',
	1063	funcProp2:foo,
	1064	funcProp3:'this.func3Called=true;'"
	1065	>
	1066	</div>
	1067	<div dojoType="tests.parser.NormalContainer" data-dojo-id="contI1" id ="contId1">
	1068	<div dojoType="tests.parser.Class1" data-dojo-id="objI3" id="objId3"></div>
	1069	<div dojoType="tests.parser.Class1" data-dojo-id="objI4" id="objId4"></div>
	1070	</div>
	1071	</div>
	1072
	1073	<!-- section for testing parser.construct() -->
	1074	<div id="construct1">
	1075	<div data-dojo-id="objC1" id="objC1"
	1076	strProp1="text" strProp2=""
	1077	intProp="5"
	1078	arrProp="foo, bar, baz"
	1079	arrProp2=""
	1080	boolProp1="true" boolProp2="false"
	1081	dateProp1="2006-01-01" dateProp2="" dateProp3="now"
	1082	funcProp2="foo" funcProp3="this.func3Called=true;"
	1083	>
	1084	</div>
	1085	<div data-dojo-id="objC2" id="objC2"
	1086	data-dojo-props="
	1087	strProp1:'text',
	1088	strProp2:'',
	1089	intProp:5,
	1090	arrProp:['foo', 'bar', 'baz'],
	1091	arrProp2:[],
	1092	boolProp1:true,
	1093	boolProp2:'false',
	1094	dateProp1:'2006-01-01',
	1095	dateProp2:'',
	1096	dateProp3:'now',
	1097	funcProp2:foo,
	1098	funcProp3:'this.func3Called=true;'"
	1099	>
	1100	</div>
	1101	</div>
	1102
	1103	<!-- tests for data-dojo-mixins -->
	1104	<div id="mixins">
	1105	<div data-dojo-type="tests.parser.Class1" data-dojo-mixins="tests.parser.Mixin1,tests.parser.Mixin2,dojo/tests/resources/AMDMixin"
	1106	data-dojo-id="resultMixins1"></div>
	1107	<div data-dojo-type="tests.parser.ClassForMixins" data-dojo-mixins="tests.parser.Mixin1, tests.parser.Mixin2, dojo/tests/resources/AMDMixin"
	1108	data-dojo-id="resultMixins2"></div>
	1109	<div data-dojo-type="MyNonDojoClass" data-dojo-mixins="tests.parser.Mixin1, tests.parser.Mixin2"
	1110	data-dojo-id="resultNonDojoMixin"></div>
	1111	</div>
	1112
	1113	<!-- tests for behavioral widgets -->
	1114	<div id="behavioral">
	1115	<div data-dojo-type="Behavioral1" onClick="behavioralClickCounter++;" id="bh1" foo="bar">click me</div>
	1116	</div>
	1117
	1118	<!-- tests for declarative require -->
	1119	<div id="declarativeRequire">
	1120	<script type="dojo/require">
	1121	AMDWidget: "dojo/tests/resources/AMDWidget",
	1122	AMDWidget2: "dojo/tests/resources/AMDWidget2"
	1123	</script>
	1124	<div data-dojo-id="dr1" data-dojo-type="AMDWidget" data-dojo-props="foo: 'bar'"></div>
	1125	<div data-dojo-id="dr2" data-dojo-type="AMDWidget2" data-dojo-props="foo: 'bar'"></div>
	1126	<script type="dojo/require">
	1127	AMDWidget3: "dojo/tests/resources/AMDWidget3"
	1128	</script>
	1129	<div data-dojo-id="dr3" data-dojo-type="dojo/tests/resources/AMDWidget3" data-dojo-props="foo: 'bar'"></div>
	1130	<script type="dojo/require">
	1131	amdmodule: "dojo/tests/resources/amdmodule"
	1132	</script>
	1133	<div data-dojo-id="dr4" data-dojo-type="AMDWidget" data-dojo-props="foo: amdmodule(1)"></div>
	1134	<div data-dojo-id="dr5" data-dojo-type="AMDWidget2">
	1135	<script type="dojo/aspect" data-dojo-advice="before" data-dojo-method="method1" data-dojo-args="value">
	1136	return [amdmodule(value)];
	1137	</script>
	1138	</div>
	1139	</div>
	1140
	1141	<!-- tests for context require -->
	1142	<!-- The relative MIDs, because they are "up", the loader thinks they are not necessarily modules, in the
	1143	real world, they would most likely be in sibling paths and the need for the .js would not be
	1144	necessary -->
	1145	<div id="contextRequire">
	1146	<script type="dojo/require">
	1147	"context.AMDWidget": "../resources/AMDWidget.js",
	1148	"context.AMDWidget2": "../resources/AMDWidget2.js"
	1149	</script>
	1150	<div data-dojo-id="cr1" data-dojo-type="context.AMDWidget" data-dojo-props="foo: 'bar'"></div>
	1151	<div data-dojo-id="cr2" data-dojo-type="context.AMDWidget2" data-dojo-props="foo: 'bar'"></div>
	1152	<div data-dojo-id="cr3" data-dojo-type="../resources/AMDWidget.js" data-dojo-props="foo: 'bar'"></div>
	1153	<div data-dojo-id="cr4" data-dojo-type="../resources/AMDWidget3.js" data-dojo-props="foo: 'bar'"></div>
	1154	</div>
	1155
	1156	<!-- tests for promise error handling -->
	1157	<div id="errorHandling">
	1158	<div data-dojo-type="dojo/tests/resources/AMDWidget" data-dojo-props="foo: bar"></div>
	1159	</div>
	1160	<div id="missingCtor">
	1161	<div data-dojo-type="some.type"></div>
	1162	</div>
	1163	</body>
	1164	</html>

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: Dev/trunk/src/client/dojo/tests/parser/parser.html

Download in other formats: