<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[173103] trunk</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/173103">173103</a></dd>
<dt>Author</dt> <dd>commit-queue@webkit.org</dd>
<dt>Date</dt> <dd>2014-08-28 18:42:21 -0700 (Thu, 28 Aug 2014)</dd>
</dl>

<h3>Log Message</h3>
<pre>Web Inspector: Write tests for ScriptSyntaxTree and fix bugs in the data structure
https://bugs.webkit.org/show_bug.cgi?id=136272

Patch by Saam Barati &lt;sbarati@apple.com&gt; on 2014-08-28
Reviewed by Joseph Pecoraro.

Source/WebInspectorUI:

Include the necessary files in Test.html to test ScriptSyntaxTree.
Also, ScriptSyntaxTree had a couple of errors for two of its nodes
where they simply ignored one of the properties on the node.
These errors were found while writing the tests and are fixed
in this patch.

* UserInterface/Models/ScriptSyntaxTree.js:
(WebInspector.ScriptSyntaxTree.prototype._createInternalSyntaxTree):
* UserInterface/Test.html:

LayoutTests:

This patch tests all nodes in the WebInspecor's Abstract Syntax Tree.
These tests don't test every aspect of the data structure, but focus
on having it parse all JavaScript expressions successfully and to also
make sure nodes in the tree are of the correct type.

* inspector/model: Added.
* inspector/model/parse-script-syntax-tree-expected.txt: Added.
* inspector/model/parse-script-syntax-tree.html: Added.</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsChangeLog">trunk/LayoutTests/ChangeLog</a></li>
<li><a href="#trunkSourceWebInspectorUIChangeLog">trunk/Source/WebInspectorUI/ChangeLog</a></li>
<li><a href="#trunkSourceWebInspectorUIUserInterfaceModelsScriptSyntaxTreejs">trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js</a></li>
<li><a href="#trunkSourceWebInspectorUIUserInterfaceTesthtml">trunk/Source/WebInspectorUI/UserInterface/Test.html</a></li>
</ul>

<h3>Added Paths</h3>
<ul>
<li>trunk/LayoutTests/inspector/model/</li>
<li><a href="#trunkLayoutTestsinspectormodelparsescriptsyntaxtreeexpectedtxt">trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt</a></li>
<li><a href="#trunkLayoutTestsinspectormodelparsescriptsyntaxtreehtml">trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkLayoutTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/ChangeLog (173102 => 173103)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/ChangeLog        2014-08-29 01:32:21 UTC (rev 173102)
+++ trunk/LayoutTests/ChangeLog        2014-08-29 01:42:21 UTC (rev 173103)
</span><span class="lines">@@ -1,3 +1,19 @@
</span><ins>+2014-08-28  Saam Barati  &lt;sbarati@apple.com&gt;
+
+        Web Inspector: Write tests for ScriptSyntaxTree and fix bugs in the data structure
+        https://bugs.webkit.org/show_bug.cgi?id=136272
+
+        Reviewed by Joseph Pecoraro.
+
+        This patch tests all nodes in the WebInspecor's Abstract Syntax Tree.
+        These tests don't test every aspect of the data structure, but focus
+        on having it parse all JavaScript expressions successfully and to also
+        make sure nodes in the tree are of the correct type.
+
+        * inspector/model: Added.
+        * inspector/model/parse-script-syntax-tree-expected.txt: Added.
+        * inspector/model/parse-script-syntax-tree.html: Added.
+
</ins><span class="cx"> 2014-08-28  Enrica Casucci  &lt;enrica@apple.com&gt;
</span><span class="cx"> 
</span><span class="cx">         Can't hit tab key more than 3 times continuously.
</span></span></pre></div>
<a id="trunkLayoutTestsinspectormodelparsescriptsyntaxtreeexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt (0 => 173103)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt                                (rev 0)
+++ trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt        2014-08-29 01:42:21 UTC (rev 173103)
</span><span class="lines">@@ -0,0 +1,41 @@
</span><ins>+passed AssignmentExpression
+passed ArrayExpression
+passed BlockStatement
+passed BinaryExpression
+passed BreakStatement
+passed CallExpression
+passed TryStatement
+passed CatchClause
+passed ConditionalExpression
+passed ContinueStatement
+passed DoWhileStatement
+passed DebuggerStatement
+passed EmptyStatement
+passed ExpressionStatement
+passed ForStatement
+passed ForInStatement
+passed FunctionDeclaration
+passed FunctionExpression
+passed Identifier
+passed IfStatement
+passed Literal
+passed LabeledStatement
+passed LogicalExpression
+passed MemberExpression
+passed NewExpression
+passed ObjectExpression
+passed Property
+passed ReturnStatement
+passed SequenceExpression
+passed SwitchStatement
+passed SwitchCase
+passed ThisExpression
+passed ThrowStatement
+passed UnaryExpression
+passed UpdateExpression
+passed VariableDeclaration
+passed VariableDeclarator
+passed WhileStatement
+passed WithStatement
+passed ALL TESTS
+
</ins></span></pre></div>
<a id="trunkLayoutTestsinspectormodelparsescriptsyntaxtreehtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html (0 => 173103)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html                                (rev 0)
+++ trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html        2014-08-29 01:42:21 UTC (rev 173103)
</span><span class="lines">@@ -0,0 +1,407 @@
</span><ins>+&lt;!doctype html&gt;
+&lt;html&gt;
+&lt;head&gt;
+&lt;script type=&quot;text/javascript&quot; src=&quot;../../http/tests/inspector/inspector-test.js&quot;&gt;&lt;/script&gt;
+&lt;script&gt;
+function test()
+{
+    function makeNode(text, isExpression)
+    {
+        var script = new WebInspector.Script(1, WebInspector.TextRange(0, text.length));
+        var scriptSyntaxTree = new WebInspector.ScriptSyntaxTree(text, script);
+        var syntaxTree = scriptSyntaxTree._syntaxTree;
+
+        InspectorTest.assert(scriptSyntaxTree.parsedSuccessfully, &quot;ScriptSyntaxTree should be able to parse: \&quot;&quot; + text + &quot;\&quot;&quot;);
+        InspectorTest.assert(syntaxTree.type === WebInspector.ScriptSyntaxTree.NodeType.Program, &quot;Should be program.&quot;);
+        InspectorTest.assert(syntaxTree.body.length === 1, &quot;Calling makeNode should return one node in the program.&quot;);
+        if (isExpression) {
+            InspectorTest.assert(syntaxTree.body[0].type === WebInspector.ScriptSyntaxTree.NodeType.ExpressionStatement);
+            return syntaxTree.body[0].expression;
+        } else
+            return syntaxTree.body[0];
+    }
+
+    var node = null;
+
+    node = makeNode(&quot;x = 20;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.AssignmentExpression);
+    InspectorTest.assert(node.left);
+    InspectorTest.assert(node.left.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.right);
+    InspectorTest.assert(node.right.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.assert(node.operator === &quot;=&quot;);
+    node = makeNode(&quot;x += 20;&quot;, true);
+    InspectorTest.assert(node.operator === &quot;+=&quot;);
+    node = makeNode(&quot;x -= 20;&quot;, true);
+    InspectorTest.assert(node.operator === &quot;-=&quot;);
+    InspectorTest.log(&quot;passed AssignmentExpression&quot;);
+
+    node = makeNode(&quot;[1, 2]&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.ArrayExpression);
+    InspectorTest.assert(Array.isArray(node.elements));
+    InspectorTest.assert(node.elements.length === 2);
+    InspectorTest.assert(node.elements[0].type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.assert(node.elements[1].type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.log(&quot;passed ArrayExpression&quot;);
+    
+    node = makeNode(&quot;{foo();}&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.BlockStatement);
+    InspectorTest.assert(node.body);
+    InspectorTest.assert(node.body.length === 1);
+    InspectorTest.assert(node.body[0].expression.type === WebInspector.ScriptSyntaxTree.NodeType.CallExpression);
+    InspectorTest.log(&quot;passed BlockStatement&quot;);
+
+    node = makeNode(&quot;2 + 2&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.BinaryExpression);
+    InspectorTest.assert(node.left);
+    InspectorTest.assert(node.right);
+    InspectorTest.assert(node.operator === &quot;+&quot;);
+    node = makeNode(&quot;2 - 2&quot;, true);
+    InspectorTest.assert(node.operator === &quot;-&quot;);
+    node = makeNode(&quot;2 * 2&quot;, true);
+    InspectorTest.assert(node.operator === &quot;*&quot;);
+    node = makeNode(&quot;2 / 2&quot;, true);
+    InspectorTest.assert(node.operator === &quot;/&quot;);
+    node = makeNode(&quot;2 % 2&quot;, true);
+    InspectorTest.assert(node.operator === &quot;%&quot;);
+    node = makeNode(&quot;2 | 2&quot;, true);
+    InspectorTest.assert(node.operator === &quot;|&quot;);
+    node = makeNode(&quot;2 ^ 2&quot;, true);
+    InspectorTest.assert(node.operator === &quot;^&quot;);
+    node = makeNode(&quot;2 == 2&quot;, true);
+    InspectorTest.assert(node.operator === &quot;==&quot;);
+    node = makeNode(&quot;2 === 2&quot;, true);
+    InspectorTest.assert(node.operator === &quot;===&quot;);
+    InspectorTest.log(&quot;passed BinaryExpression&quot;);
+
+    node = makeNode(&quot;label:while(true) {break label;}&quot;, false);
+    InspectorTest.assert(node.body.body.body[0].type === WebInspector.ScriptSyntaxTree.NodeType.BreakStatement);
+    InspectorTest.assert(node.body.body.body[0].label.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.body.body.body[0].label.name === &quot;label&quot;);
+    InspectorTest.log(&quot;passed BreakStatement&quot;);
+
+    node = makeNode(&quot;foo(20, 25)&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.CallExpression);
+    InspectorTest.assert(node.arguments);
+    InspectorTest.assert(node.arguments.length === 2);
+    InspectorTest.assert(node.arguments[0].type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.assert(node.arguments[1].type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.log(&quot;passed CallExpression&quot;);
+
+    node = makeNode(&quot;try {} catch(e) {} &quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.TryStatement);
+    InspectorTest.log(&quot;passed TryStatement&quot;);
+    InspectorTest.assert(node.handlers.length === 1);
+    InspectorTest.assert(node.handlers[0].type === WebInspector.ScriptSyntaxTree.NodeType.CatchClause);
+    InspectorTest.log(&quot;passed CatchClause&quot;);
+
+    node = makeNode(&quot;foo ? bar : baz;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.ConditionalExpression);
+    InspectorTest.assert(node.test);
+    InspectorTest.assert(node.consequent);
+    InspectorTest.assert(node.alternate);
+    InspectorTest.assert(node.test.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.consequent.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.alternate.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.log(&quot;passed ConditionalExpression&quot;);
+    
+    node = makeNode(&quot;label:while(true) {continue label;}&quot;, false);
+    InspectorTest.assert(node.body.body.body[0].type === WebInspector.ScriptSyntaxTree.NodeType.ContinueStatement);
+    InspectorTest.assert(node.body.body.body[0].label.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.body.body.body[0].label.name === &quot;label&quot;);
+    InspectorTest.log(&quot;passed ContinueStatement&quot;);
+
+    node = makeNode(&quot;do{}while(true);&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.DoWhileStatement);
+    InspectorTest.assert(node.body.type === WebInspector.ScriptSyntaxTree.NodeType.BlockStatement);
+    InspectorTest.assert(node.body.body.length === 0);
+    InspectorTest.assert(node.test);
+    InspectorTest.assert(node.test.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.log(&quot;passed DoWhileStatement&quot;);
+
+    node = makeNode(&quot;debugger;&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.DebuggerStatement);
+    InspectorTest.log(&quot;passed DebuggerStatement&quot;);
+
+    node = makeNode(&quot;;&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.EmptyStatement);
+    InspectorTest.log(&quot;passed EmptyStatement&quot;);
+
+    node = makeNode(&quot;2 + 2&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.ExpressionStatement);
+    InspectorTest.assert(node.expression);
+    InspectorTest.assert(node.expression.type === WebInspector.ScriptSyntaxTree.NodeType.BinaryExpression);
+    InspectorTest.log(&quot;passed ExpressionStatement&quot;);
+
+    node = makeNode(&quot;for(x = 0;x &lt; 20;x++){}&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.ForStatement);
+    InspectorTest.assert(node.init);
+    InspectorTest.assert(node.init.type === WebInspector.ScriptSyntaxTree.NodeType.AssignmentExpression);
+    InspectorTest.assert(node.test);
+    InspectorTest.assert(node.test.type === WebInspector.ScriptSyntaxTree.NodeType.BinaryExpression);
+    InspectorTest.assert(node.update);
+    InspectorTest.assert(node.update.type === WebInspector.ScriptSyntaxTree.NodeType.UpdateExpression);
+    InspectorTest.assert(node.body);
+    InspectorTest.assert(node.body.type === WebInspector.ScriptSyntaxTree.NodeType.BlockStatement);
+    node = makeNode(&quot;for(x = 0;x &lt; 20;x++);&quot;, false);
+    InspectorTest.assert(node.body);
+    InspectorTest.assert(node.body.type === WebInspector.ScriptSyntaxTree.NodeType.EmptyStatement);
+    InspectorTest.log(&quot;passed ForStatement&quot;);
+
+    node = makeNode(&quot;for(var x in {}){}&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.ForInStatement);
+    InspectorTest.assert(node.left);
+    InspectorTest.assert(node.left.type === WebInspector.ScriptSyntaxTree.NodeType.VariableDeclaration);
+    InspectorTest.assert(node.right);
+    InspectorTest.assert(node.right.type === WebInspector.ScriptSyntaxTree.NodeType.ObjectExpression);
+    InspectorTest.assert(node.body);
+    InspectorTest.assert(node.body.type === WebInspector.ScriptSyntaxTree.NodeType.BlockStatement);
+    node = makeNode(&quot;for(var x in {});&quot;, false);
+    InspectorTest.assert(node.body);
+    InspectorTest.assert(node.body.type === WebInspector.ScriptSyntaxTree.NodeType.EmptyStatement);
+    InspectorTest.log(&quot;passed ForInStatement&quot;);
+
+    node = makeNode(&quot;function foo(x,y){}&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.FunctionDeclaration);
+    InspectorTest.assert(node.params);
+    InspectorTest.assert(node.params.length === 2);
+    InspectorTest.assert(node.params[0].type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.params[1].type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.body);
+    InspectorTest.assert(node.body.type === WebInspector.ScriptSyntaxTree.NodeType.BlockStatement);
+    InspectorTest.assert(!node.isGetterOrSetter);
+    node = makeNode(&quot;x = {get foo(){return 20}}&quot;, true);
+    InspectorTest.assert(node.right.properties[0].value.type === WebInspector.ScriptSyntaxTree.NodeType.FunctionExpression);
+    InspectorTest.assert(node.right.properties[0].value.isGetterOrSetter);
+    node = makeNode(&quot;x = {set foo(x){return 20}}&quot;, true);
+    InspectorTest.assert(node.right.properties[0].value.type === WebInspector.ScriptSyntaxTree.NodeType.FunctionExpression);
+    InspectorTest.assert(node.right.properties[0].value.isGetterOrSetter);
+    InspectorTest.log(&quot;passed FunctionDeclaration&quot;);
+
+    node = makeNode(&quot;foo(function(x,y){})&quot;, true);
+    InspectorTest.assert(node.arguments[0].type === WebInspector.ScriptSyntaxTree.NodeType.FunctionExpression);
+    InspectorTest.assert(node.arguments[0].params);
+    InspectorTest.assert(node.arguments[0].params.length === 2);
+    InspectorTest.assert(node.arguments[0].params[0].type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.arguments[0].params[1].type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.arguments[0].body);
+    InspectorTest.assert(node.arguments[0].body.type === WebInspector.ScriptSyntaxTree.NodeType.BlockStatement);
+    InspectorTest.log(&quot;passed FunctionExpression&quot;);
+
+    node = makeNode(&quot;foo;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.name);
+    InspectorTest.assert(node.name === &quot;foo&quot;);
+    InspectorTest.log(&quot;passed Identifier&quot;);
+
+    node = makeNode(&quot;if (true) baz; else bar;&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.IfStatement);
+    InspectorTest.assert(node.test);
+    InspectorTest.assert(node.test.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.assert(node.consequent);
+    InspectorTest.assert(node.consequent.type === WebInspector.ScriptSyntaxTree.NodeType.ExpressionStatement);
+    InspectorTest.assert(node.alternate);
+    InspectorTest.assert(node.alternate.type === WebInspector.ScriptSyntaxTree.NodeType.ExpressionStatement);
+    InspectorTest.log(&quot;passed IfStatement&quot;);
+
+    node = makeNode(&quot;true;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.assert(node.value === true);
+    InspectorTest.assert(node.raw === &quot;true&quot;);
+    node = makeNode(&quot;false;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.assert(node.value === false);
+    InspectorTest.assert(node.raw === &quot;false&quot;);
+    node = makeNode(&quot;20;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.assert(node.value === 20);
+    InspectorTest.assert(node.raw === &quot;20&quot;);
+    node = makeNode(&quot;'20';&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.assert(node.value === '20');
+    InspectorTest.assert(node.raw === &quot;'20'&quot;);
+    node = makeNode(&quot;null;&quot;, true);
+    InspectorTest.assert(node.value === null);
+    InspectorTest.assert(node.raw === &quot;null&quot;);
+    node = makeNode(&quot;/regex/gi;&quot;, true);
+    InspectorTest.assert(node.value instanceof RegExp);
+    InspectorTest.assert(node.value.toString() === &quot;/regex/gi&quot;);
+    InspectorTest.assert(node.raw === &quot;/regex/gi&quot;);
+    node = makeNode(&quot;0x10&quot;, true);
+    InspectorTest.assert(node.value === 0x10);
+    InspectorTest.assert(node.raw === &quot;0x10&quot;);
+    node = makeNode(&quot;0777&quot;, true);
+    InspectorTest.assert(node.value === 0777);
+    InspectorTest.assert(node.raw === &quot;0777&quot;);
+    node = makeNode(&quot;\&quot;a\&quot;&quot;, true);
+    InspectorTest.assert(node.value === &quot;a&quot;);
+    InspectorTest.assert(node.raw === &quot;\&quot;a\&quot;&quot;);
+    InspectorTest.log(&quot;passed Literal&quot;);
+
+    node = makeNode(&quot;label:while(true)20;&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.LabeledStatement);
+    InspectorTest.assert(node.label);
+    InspectorTest.assert(node.label.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.label.name === &quot;label&quot;);
+    InspectorTest.log(&quot;passed LabeledStatement&quot;);
+
+    node = makeNode(&quot;x &amp;&amp; 20&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.LogicalExpression);
+    InspectorTest.assert(node.left);
+    InspectorTest.assert(node.left.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.right);
+    InspectorTest.assert(node.right.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    //InspectorTest.assert(node.operator === &quot;&amp;&amp;&quot;);
+    node = makeNode(&quot;x || 20&quot;, true);
+    InspectorTest.assert(node.operator === &quot;||&quot;);
+    InspectorTest.log(&quot;passed LogicalExpression&quot;);
+
+    node = makeNode(&quot;foo[20]&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.MemberExpression);
+    InspectorTest.assert(node.computed);
+    InspectorTest.assert(node.object);
+    InspectorTest.assert(node.object.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.property);
+    InspectorTest.assert(node.property.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    node = makeNode(&quot;foo.bar&quot;, true);
+    InspectorTest.assert(!node.computed);
+    InspectorTest.assert(node.property.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.log(&quot;passed MemberExpression&quot;);
+
+    node = makeNode(&quot;new Foo(20)&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.NewExpression);
+    InspectorTest.assert(node.callee);
+    InspectorTest.assert(node.callee.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.arguments);
+    InspectorTest.assert(node.arguments.length === 1);
+    node = makeNode(&quot;new Foo&quot;, true);
+    InspectorTest.assert(node.arguments);
+    InspectorTest.assert(node.arguments.length === 0);
+    InspectorTest.log(&quot;passed NewExpression&quot;);
+
+    node = makeNode(&quot;x = {foo:bar};&quot;, true);
+    InspectorTest.assert(node.right.type === WebInspector.ScriptSyntaxTree.NodeType.ObjectExpression);
+    InspectorTest.assert(node.right.properties);
+    InspectorTest.assert(node.right.properties.length === 1);
+    InspectorTest.log(&quot;passed ObjectExpression&quot;);
+
+    // Program is tested in makeNode
+
+    node = makeNode(&quot;x = {foo:20};&quot;, true);
+    InspectorTest.assert(node.right.properties[0].type === WebInspector.ScriptSyntaxTree.NodeType.Property);
+    InspectorTest.assert(node.right.properties[0].key);
+    InspectorTest.assert(node.right.properties[0].key.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.right.properties[0].value);
+    InspectorTest.assert(node.right.properties[0].value.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    node = makeNode(&quot;x = {'foo':20};&quot;, true);
+    InspectorTest.assert(node.right.properties[0].key);
+    InspectorTest.assert(node.right.properties[0].key.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.log(&quot;passed Property&quot;);
+
+    node = makeNode(&quot;function foo() { return 20; }&quot;, false);
+    InspectorTest.assert(node.body.body[0].type === WebInspector.ScriptSyntaxTree.NodeType.ReturnStatement);
+    InspectorTest.assert(node.body.body[0].argument.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    node = makeNode(&quot;function foo() { return; }&quot;, false);
+    InspectorTest.assert(node.body.body[0].argument === null);
+    InspectorTest.log(&quot;passed ReturnStatement&quot;);
+
+    node = makeNode(&quot;(x, y)&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.SequenceExpression);
+    InspectorTest.assert(node.expressions);
+    InspectorTest.assert(node.expressions.length === 2);
+    InspectorTest.assert(node.expressions[0].type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.expressions[1].type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.log(&quot;passed SequenceExpression&quot;);
+
+    node = makeNode(&quot;switch(x){case y:break;}&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.SwitchStatement);
+    InspectorTest.assert(node.discriminant.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.log(&quot;passed SwitchStatement&quot;);
+    InspectorTest.assert(node.cases[0].type === WebInspector.ScriptSyntaxTree.NodeType.SwitchCase);
+    InspectorTest.assert(node.cases[0].test.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.cases[0].consequent);
+    InspectorTest.assert(Array.isArray(node.cases[0].consequent));
+    InspectorTest.assert(node.cases[0].consequent.length === 1);
+    InspectorTest.log(&quot;passed SwitchCase&quot;);
+
+    node = makeNode(&quot;this;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.ThisExpression);
+    InspectorTest.log(&quot;passed ThisExpression&quot;);
+
+    node = makeNode(&quot;throw new Error;&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.ThrowStatement);
+    InspectorTest.assert(node.argument);
+    InspectorTest.assert(node.argument.type === WebInspector.ScriptSyntaxTree.NodeType.NewExpression);
+    InspectorTest.log(&quot;passed ThrowStatement&quot;);
+
+    node = makeNode(&quot;!foo;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.UnaryExpression);
+    InspectorTest.assert(node.argument);
+    InspectorTest.assert(node.argument.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.operator === &quot;!&quot;);
+    node = makeNode(&quot;~foo;&quot;, true);
+    InspectorTest.assert(node.operator === &quot;~&quot;);
+    node = makeNode(&quot;-foo;&quot;, true);
+    InspectorTest.assert(node.operator === &quot;-&quot;);
+    InspectorTest.log(&quot;passed UnaryExpression&quot;);
+
+    node = makeNode(&quot;foo++;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.UpdateExpression);
+    InspectorTest.assert(node.argument);
+    InspectorTest.assert(node.argument.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.operator === &quot;++&quot;);
+    InspectorTest.assert(node.prefix === false);
+    node = makeNode(&quot;++foo;&quot;, true);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.UpdateExpression);
+    InspectorTest.assert(node.argument);
+    InspectorTest.assert(node.argument.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.prefix === true);
+    InspectorTest.assert(node.operator === &quot;++&quot;);
+    node = makeNode(&quot;--foo;&quot;, true);
+    InspectorTest.assert(node.operator === &quot;--&quot;);
+    node = makeNode(&quot;foo--;&quot;, true);
+    InspectorTest.assert(node.operator === &quot;--&quot;);
+    InspectorTest.log(&quot;passed UpdateExpression&quot;);
+
+    node = makeNode(&quot;var foo = 20;&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.VariableDeclaration);
+    InspectorTest.assert(node.declarations);
+    InspectorTest.assert(node.declarations.length === 1);
+    InspectorTest.log(&quot;passed VariableDeclaration&quot;);
+    InspectorTest.assert(node.declarations[0].type === WebInspector.ScriptSyntaxTree.NodeType.VariableDeclarator);
+    InspectorTest.assert(node.declarations[0].id);
+    InspectorTest.assert(node.declarations[0].id.type);
+    InspectorTest.assert(node.declarations[0].id.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.declarations[0].init);
+    InspectorTest.assert(node.declarations[0].init.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    node = makeNode(&quot;var foo;&quot;, false);
+    InspectorTest.assert(node.declarations[0].init === null);
+    InspectorTest.log(&quot;passed VariableDeclarator&quot;);
+
+    node = makeNode(&quot;while(true)boo;&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.WhileStatement);
+    InspectorTest.assert(node.test);
+    InspectorTest.assert(node.test.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
+    InspectorTest.assert(node.body);
+    InspectorTest.assert(node.body.type === WebInspector.ScriptSyntaxTree.NodeType.ExpressionStatement);
+    node = makeNode(&quot;while(true){}&quot;, false);
+    InspectorTest.assert(node.body);
+    InspectorTest.assert(node.body.type === WebInspector.ScriptSyntaxTree.NodeType.BlockStatement);
+    InspectorTest.log(&quot;passed WhileStatement&quot;);
+
+    node = makeNode(&quot;with(o) {}&quot;, false);
+    InspectorTest.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.WithStatement);
+    InspectorTest.assert(node.object);
+    InspectorTest.assert(node.object.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.body);
+    InspectorTest.assert(node.body.type === WebInspector.ScriptSyntaxTree.NodeType.BlockStatement);
+    InspectorTest.log(&quot;passed WithStatement&quot;);
+
+    InspectorTest.log(&quot;passed ALL TESTS&quot;);
+    InspectorTest.completeTest();
+}
+&lt;/script&gt;
+&lt;/head&gt;
+&lt;body onload=&quot;runTest()&quot;&gt;
+&lt;/body&gt;
+&lt;/html&gt;
</ins></span></pre></div>
<a id="trunkSourceWebInspectorUIChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebInspectorUI/ChangeLog (173102 => 173103)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebInspectorUI/ChangeLog        2014-08-29 01:32:21 UTC (rev 173102)
+++ trunk/Source/WebInspectorUI/ChangeLog        2014-08-29 01:42:21 UTC (rev 173103)
</span><span class="lines">@@ -1,3 +1,20 @@
</span><ins>+2014-08-28  Saam Barati  &lt;sbarati@apple.com&gt;
+
+        Web Inspector: Write tests for ScriptSyntaxTree and fix bugs in the data structure
+        https://bugs.webkit.org/show_bug.cgi?id=136272
+
+        Reviewed by Joseph Pecoraro.
+
+        Include the necessary files in Test.html to test ScriptSyntaxTree.
+        Also, ScriptSyntaxTree had a couple of errors for two of its nodes
+        where they simply ignored one of the properties on the node.
+        These errors were found while writing the tests and are fixed
+        in this patch.
+
+        * UserInterface/Models/ScriptSyntaxTree.js:
+        (WebInspector.ScriptSyntaxTree.prototype._createInternalSyntaxTree):
+        * UserInterface/Test.html:
+
</ins><span class="cx"> 2014-08-27  Saam Barati  &lt;sbarati@apple.com&gt;
</span><span class="cx"> 
</span><span class="cx">         Web Inspector: Layout issues for popover on not legacy OS
</span></span></pre></div>
<a id="trunkSourceWebInspectorUIUserInterfaceModelsScriptSyntaxTreejs"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js (173102 => 173103)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js        2014-08-29 01:32:21 UTC (rev 173102)
+++ trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js        2014-08-29 01:42:21 UTC (rev 173103)
</span><span class="lines">@@ -639,14 +639,16 @@
</span><span class="cx">             result = {
</span><span class="cx">                 type: WebInspector.ScriptSyntaxTree.NodeType.LogicalExpression,
</span><span class="cx">                 left: this._createInternalSyntaxTree(node.left),
</span><del>-                right: this._createInternalSyntaxTree(node.right)
</del><ins>+                right: this._createInternalSyntaxTree(node.right),
+                operator: node.operator
</ins><span class="cx">             };
</span><span class="cx">             break;
</span><span class="cx">         case &quot;MemberExpression&quot;:
</span><span class="cx">             result = {
</span><span class="cx">                 type: WebInspector.ScriptSyntaxTree.NodeType.MemberExpression,
</span><span class="cx">                 object: this._createInternalSyntaxTree(node.object),
</span><del>-                property: this._createInternalSyntaxTree(node.property)
</del><ins>+                property: this._createInternalSyntaxTree(node.property),
+                computed: node.computed
</ins><span class="cx">             };
</span><span class="cx">             break;
</span><span class="cx">         case &quot;NewExpression&quot;:
</span></span></pre></div>
<a id="trunkSourceWebInspectorUIUserInterfaceTesthtml"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebInspectorUI/UserInterface/Test.html (173102 => 173103)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebInspectorUI/UserInterface/Test.html        2014-08-29 01:32:21 UTC (rev 173102)
+++ trunk/Source/WebInspectorUI/UserInterface/Test.html        2014-08-29 01:42:21 UTC (rev 173103)
</span><span class="lines">@@ -40,6 +40,8 @@
</span><span class="cx">     &lt;script src=&quot;Base/URLUtilities.js&quot;&gt;&lt;/script&gt;
</span><span class="cx">     &lt;script src=&quot;Base/Utilities.js&quot;&gt;&lt;/script&gt;
</span><span class="cx"> 
</span><ins>+    &lt;script src=&quot;External/Esprima/esprima.js&quot;&gt;&lt;/script&gt;
+
</ins><span class="cx">     &lt;script src=&quot;Protocol/InspectorBackend.js&quot;&gt;&lt;/script&gt;
</span><span class="cx">     &lt;script src=&quot;Protocol/InspectorFrontendAPI.js&quot;&gt;&lt;/script&gt;
</span><span class="cx">     &lt;script src=&quot;Protocol/InspectorFrontendHostStub.js&quot;&gt;&lt;/script&gt;
</span><span class="lines">@@ -93,6 +95,7 @@
</span><span class="cx">     &lt;script src=&quot;Models/ResourceTimelineRecord.js&quot;&gt;&lt;/script&gt;
</span><span class="cx">     &lt;script src=&quot;Models/Revision.js&quot;&gt;&lt;/script&gt;
</span><span class="cx">     &lt;script src=&quot;Models/Script.js&quot;&gt;&lt;/script&gt;
</span><ins>+    &lt;script src=&quot;Models/ScriptSyntaxTree.js&quot;&gt;&lt;/script&gt;
</ins><span class="cx">     &lt;script src=&quot;Models/ScriptTimelineRecord.js&quot;&gt;&lt;/script&gt;
</span><span class="cx">     &lt;script src=&quot;Models/Setting.js&quot;&gt;&lt;/script&gt;
</span><span class="cx">     &lt;script src=&quot;Models/SourceCodeLocation.js&quot;&gt;&lt;/script&gt;
</span></span></pre>
</div>
</div>

</body>
</html>