| // Copyright (c) 2009 The Chromium Authors. All rights reserved. |
| // This program and the accompanying materials are made available |
| // under the terms of the Eclipse Public License v2.0 which accompanies |
| // this distribution, and is available at |
| // https://www.eclipse.org/legal/epl-2.0/ |
| |
| package org.eclipse.wst.jsdt.chromium.internal.browserfixture; |
| |
| import static org.eclipse.wst.jsdt.chromium.tests.internal.JsonBuilderUtil.convertToRealJson; |
| import static org.eclipse.wst.jsdt.chromium.tests.internal.JsonBuilderUtil.jsonArray; |
| import static org.eclipse.wst.jsdt.chromium.tests.internal.JsonBuilderUtil.jsonObject; |
| import static org.eclipse.wst.jsdt.chromium.tests.internal.JsonBuilderUtil.jsonProperty; |
| |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| import org.eclipse.wst.jsdt.chromium.Breakpoint; |
| import org.eclipse.wst.jsdt.chromium.JavascriptVm.BreakpointCallback; |
| import org.eclipse.wst.jsdt.chromium.RelayOk; |
| import org.eclipse.wst.jsdt.chromium.Script; |
| import org.eclipse.wst.jsdt.chromium.SyncCallback; |
| import org.eclipse.wst.jsdt.chromium.internal.FixtureParserAccess; |
| import org.eclipse.wst.jsdt.chromium.internal.JsonUtil; |
| import org.eclipse.wst.jsdt.chromium.internal.protocolparser.JsonParseMethod; |
| import org.eclipse.wst.jsdt.chromium.internal.protocolparser.JsonParserRoot; |
| import org.eclipse.wst.jsdt.chromium.internal.protocolparser.JsonProtocolParseException; |
| import org.eclipse.wst.jsdt.chromium.internal.protocolparser.JsonSubtypeCasting; |
| import org.eclipse.wst.jsdt.chromium.internal.protocolparser.JsonType; |
| import org.eclipse.wst.jsdt.chromium.internal.transport.ChromeStub; |
| import org.eclipse.wst.jsdt.chromium.internal.transport.Connection.NetListener; |
| import org.eclipse.wst.jsdt.chromium.internal.transport.Message; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.BreakpointImpl; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.BreakpointManager; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.DebuggerCommand; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.ScriptImplTestGate; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.ScriptManager; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.V8ContextFilter; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.protocol.V8Protocol; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.protocol.input.V8ProtocolParserAccess; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.protocol.input.data.ContextHandle; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.protocol.input.data.ScriptHandle; |
| import org.eclipse.wst.jsdt.chromium.internal.v8native.protocol.input.data.SomeHandle; |
| import org.json.simple.JSONArray; |
| import org.json.simple.JSONObject; |
| import org.json.simple.parser.ParseException; |
| |
| /** |
| * A ChromeStub implementation with a certain fixture applied. |
| */ |
| @SuppressWarnings("unchecked") |
| public class FixtureChromeStub implements ChromeStub { |
| |
| private static final Map<Long, Integer> scriptIdToScriptRefMap = new HashMap<Long, Integer>(); |
| |
| private static final V8ContextFilter contextFilter = new V8ContextFilter() { |
| @Override |
| public boolean isContextOurs(ContextHandle contextHandle) { |
| return true; |
| } |
| }; |
| |
| private static final Map<Long, String> refToObjectMap; |
| private static final Map<Long, String> refToFullVersionMap; |
| static { |
| refToObjectMap = new HashMap<Long, String>(); |
| refToFullVersionMap = new HashMap<Long, String>(); |
| |
| // MouseEvent |
| refToObjectMap.put(Long.valueOf(getMouseEventRef()), |
| "{\"handle\":" + getMouseEventRef() + "," + |
| "\"type\":\"object\",\"className\":\"MouseEvent\"," + |
| "\"constructorFunction\":{\"ref\":19},\"protoObject\":{\"ref\":73}," + |
| "\"prototypeObject\":{\"ref\":2},\"properties\":[" + |
| "{\"name\":\"x\",\"propertyType\":3,\"ref\":" + getNumber3Ref() + "}," + |
| "{\"name\":\"y\",\"propertyType\":3,\"ref\":" + getNumber3Ref() + "}]," + |
| "\"text\":\"#<an Object>\"}"); |
| |
| // Fake constructor function handle. |
| refToObjectMap.put(19L, convertToRealJson("{'handle':19,'type':'null','text':'null'}")); |
| // Fake proto object handle. |
| refToObjectMap.put(73L, convertToRealJson("{'handle':73,'type':'null','text':'null'}")); |
| |
| // Script |
| refToObjectMap.put(Long.valueOf(getScriptRef()), |
| jsonObject( |
| jsonProperty("handle", getScriptRef()), |
| jsonProperty("type", "script"), |
| jsonProperty("name", "file:///C:/1.js"), |
| jsonProperty("id", getScriptId()), |
| jsonProperty("lineOffset", 0), |
| jsonProperty("columnOffset", 0), |
| jsonProperty("lineCount", 32), |
| jsonProperty("source", |
| "SomeObject = function() {\r\n this.fieldOne = \"One\";\r\n};\r\n\r\n" |
| + "SomeObject.prototype.methodTwo = function() {\r\n alert(this.fieldOne);" |
| + "\r\n}\r\n\r\n\r\nfunction clicked() {\r\n var obj = {\r\n" |
| + " objField : { internalObj : { intField : 1}, simpleString : \"foo\" },\r\n" |
| + " someNumber : 3\r\n };\r\n var a = 1;\r\n\r\n var arr;\r\n" |
| + " arr = [\"foo\", 3, new Date(), obj, arr];\r\n" |
| + " for (var i = 5; i < 240; i += 2) {\r\n arr[i] = \"bar\";\r\n }\r\n" |
| + " arr[100] = 0.99999887;\r\n// var b = a + 1\r\n// console.log('Foo');\r\n" |
| + " anotherScript();\r\n}\r\n\r\nfunction anotherScript() {\r\n var i = 0;\r\n" |
| + " i += 2;\r\n var someObj = new SomeObject();\r\n}\r\n" |
| ), |
| jsonProperty("sourceLength", 595), |
| jsonProperty("type", "script"), |
| jsonProperty("type", "script"), |
| jsonProperty("scriptType", 2), |
| jsonProperty("context", jsonObject(jsonProperty("ref", 0))), |
| jsonProperty("text", "file:///C:/1.js (lines: 32)"), |
| jsonProperty("compilationType", 17) // a random value |
| ).toJSONString() |
| ); |
| // Compiled Script |
| refToObjectMap.put(Long.valueOf(getCompiledScriptRef()), |
| jsonObject( |
| jsonProperty("handle", getCompiledScriptRef()), |
| jsonProperty("type", "script"), |
| jsonProperty("name", "file:///C:/2.js"), |
| jsonProperty("id", getCompiledScriptId()), |
| jsonProperty("lineOffset", 0), |
| jsonProperty("columnOffset", 0), |
| jsonProperty("lineCount", 32), |
| jsonProperty("source", |
| "SomeObject = function() {\r\n this.fieldOne = \"One\";\r\n};" + |
| "\r\n\r\nSomeObject.prototype.methodTwo = function() {\r\n alert(this.fieldOne);" + |
| "\r\n}\r\n\r\n\r\nfunction compiled() {\r\n var obj = {\r\n" + |
| " compiled : { internalObj : { intField : 1}, simpleString : \"foo\" },\r\n" + |
| " someNumber : 3\r\n };\r\n var a = 1;\r\n\r\n var arr;\r\n" + |
| " arr = [\"foo\", 3, new Date(), obj, arr];\r\n" + |
| " for (var i = 5; i < 240; i += 2) {\r\n arr[i] = \"bar\";\r\n }\r\n" + |
| " arr[100] = 0.99999887;\r\n// var b = a + 1\r\n// console.log('Foo');\r\n" + |
| " anotherScript();\r\n}\r\n\r\nfunction anotherScript() {\r\n var i = 0;\r\n" + |
| " i += 2;\r\n var someObj = new SomeObject();\r\n}\r\n" |
| ), |
| jsonProperty("sourceLength", 595), |
| jsonProperty("scriptType", 2), |
| jsonProperty("context", jsonObject(jsonProperty("ref", 0))), |
| jsonProperty("text", "file:///C:/2.js (lines: 32)"), |
| jsonProperty("compilationType", 17) // a random value |
| ).toJSONString() |
| ); |
| // Function |
| refToObjectMap.put(Long.valueOf(getFunctionRef()), |
| "{\"handle\":" + getFunctionRef() + ",\"type\":\"function\",\"className\":\"Function\"," + |
| "\"constructorFunction\":{\"ref\":31},\"protoObject\":{\"ref\":32}," + |
| "\"prototypeObject\":{\"ref\":33},\"name\":\"clicked\",\"inferredName\":\"\"," + |
| "\"resolved\":true,\"source\":\"function clicked() {\\r\\n var obj = {\\r\\n" + |
| " objField : { internalObj : { intField : 1}, simpleString : \\\"foo\\\" },\\r\\n" + |
| " someNumber : 3\\r\\n };\\r\\n var a = 1;\\r\\n\\r\\n var arr;\\r\\n" + |
| " arr = [\\\"foo\\\", 3, new Date(), obj, arr];\\r\\n" + |
| " for (var i = 5; i < 240; i += 2) {\\r\\n arr[i] = \\\"bar\\\";\\r\\n }\\r\\n" + |
| " arr[100] = 0.99999887;\\r\\n// var b = a + 1\\r\\n// console.log('Foo');\\r\\n" + |
| " anotherScript();\\r\\n}\",\"script\":{\"ref\":" + getScriptRef() + |
| "},\"properties\":[{\"name\":\"name\"," + |
| "\"attributes\":7,\"propertyType\":3,\"ref\":34},{\"name\":\"caller\",\"attributes\":7," + |
| "\"propertyType\":3,\"ref\":11},{\"name\":\"length\",\"attributes\":7,\"propertyType\":3," + |
| "\"ref\":35},{\"name\":\"arguments\",\"attributes\":7,\"propertyType\":3,\"ref\":327}," + |
| "{\"name\":\"prototype\",\"attributes\":4,\"propertyType\":3,\"ref\":33}]," + |
| "\"text\":\"function clicked() {\\r\\n var obj = {\\r\\n objField : { internalObj :" + |
| " { intField : 1}, simpleString : \\\"foo\\\" },\\r\\n someNumber : 3\\r\\n };\\r\\n" + |
| " var a = 1;\\r\\n\\r\\n var arr;\\r\\n arr = [\\\"foo\\\", 3, new Date(), obj, arr];" + |
| "\\r\\n for (var i = 5; i < 240; i += 2) {\\r\\n arr[i] = \\\"bar\\\";\\r\\n }\\r\\n" + |
| " arr[100] = 0.99999887;\\r\\n// var b = a + 1\\r\\n// console.log('Foo');\\r\\n" + |
| " anotherScript();\\r\\n}\"}"); |
| // Number "3" |
| refToObjectMap.put(Long.valueOf(getNumber3Ref()), |
| "{\"handle\":" + getNumber3Ref() + ",\"type\":\"number\",\"value\":3,\"text\":\"3\"}"); |
| |
| |
| refToObjectMap.put(Long.valueOf(getLongValueRef()), |
| LongValue.createHandle(true).toJSONString()); |
| refToFullVersionMap.put(Long.valueOf(getLongValueRef()), |
| LongValue.createHandle(false).toJSONString()); |
| |
| scriptIdToScriptRefMap.put(Long.valueOf(getScriptId()), getScriptRef()); |
| scriptIdToScriptRefMap.put(Long.valueOf(getCompiledScriptId()), getCompiledScriptRef()); |
| } |
| |
| private final ScriptManager scriptManager = ScriptImplTestGate.create(contextFilter); |
| |
| public FixtureChromeStub() { |
| JSONObject body = getJsonObjectByRef(getScriptRef()); |
| ScriptHandle scriptsNormalBody; |
| try { |
| scriptsNormalBody = V8ProtocolParserAccess.get().parseScriptHandle(body); |
| } catch (JsonProtocolParseException e) { |
| throw new RuntimeException(e); |
| } |
| ScriptImplTestGate.addScript(scriptManager, scriptsNormalBody, constructScriptRefsTyped()); |
| } |
| |
| public static int getNumber3Ref() { |
| return 65; |
| } |
| |
| public static int getLongValueRef() { |
| return 66; |
| } |
| |
| private static int getCompiledScriptRef() { |
| return 6; |
| } |
| |
| public static int getFunctionRef() { |
| return 0; |
| } |
| |
| public static int getScriptRef() { |
| return 5; |
| } |
| |
| public static Long getScriptId() { |
| return Long.valueOf(566); |
| } |
| |
| public static Long getCompiledScriptId() { |
| return Long.valueOf(567); |
| } |
| |
| public static int getMouseEventRef() { |
| return 1; |
| } |
| |
| private final Map<Long, BreakpointImpl> breakpoints = new HashMap<Long, BreakpointImpl>(); |
| private boolean isRunning = true; |
| private NetListener listener; |
| private static long breakpointCounter = 1; |
| private static long seqCounter = 1; |
| |
| private static final BreakpointManager NULL_BREAKPOINT_MANAGER = |
| new BreakpointManager(null) { |
| |
| @Override |
| public RelayOk changeBreakpoint(BreakpointImpl breakpointImpl, BreakpointCallback callback, |
| SyncCallback syncCallback) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| @Override |
| public RelayOk clearBreakpoint(BreakpointImpl breakpointImpl, BreakpointCallback callback, |
| SyncCallback syncCallback, long originalId) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| @Override |
| public RelayOk setBreakpoint(Breakpoint.Target target, int line, int position, |
| boolean enabled, String condition, BreakpointCallback callback, |
| SyncCallback syncCallback) { |
| throw new UnsupportedOperationException(); |
| } |
| }; |
| |
| private static long nextBreakpointId() { |
| return breakpointCounter++; |
| } |
| |
| private static long nextSeq() { |
| return seqCounter++; |
| } |
| |
| @Override |
| public Message respondTo(Message requestMessage) { |
| // needs request_seq and command at the end |
| JSONObject data; |
| try { |
| data = JsonUtil.jsonObjectFromJson(requestMessage.getContent()); |
| } catch (ParseException e) { |
| throw new RuntimeException(e); |
| } |
| String response = null; |
| boolean success = true; |
| // TODO: remove the block, that was introduced to preserve indentation. |
| { |
| JSONObject responseMessage = new JSONObject(); |
| Map<String, Object> nameToJsonValue = new HashMap<String, Object>(); |
| Long seq = JsonUtil.getAsLong(data, V8Protocol.KEY_SEQ); |
| String debuggerCommandString = JsonUtil.getAsString(data, V8Protocol.KEY_COMMAND); |
| DebuggerCommand debuggerCommand = DebuggerCommand.forString(debuggerCommandString); |
| JSONObject args = JsonUtil.getAsJSON(data, "arguments"); |
| switch (debuggerCommand) { |
| case LOOKUP: |
| { |
| JSONArray handles = JsonUtil.getAsJSONArray(args, "handles"); |
| JSONObject jsonBody = putJsonValue("body", new JSONObject(), nameToJsonValue); |
| for (int i = 0; i < handles.size(); i++) { |
| Long ref = (Long) handles.get(i); |
| String objectData = refToObjectMap.get(ref); |
| if (args.get("maxStringLength") != null ) { |
| String fullVersion = refToFullVersionMap.get(ref); |
| if (fullVersion != null) { |
| objectData = fullVersion; |
| } |
| } |
| if (objectData != null) { |
| try { |
| jsonBody.put(String.valueOf(ref), JsonUtil.jsonObjectFromJson(objectData)); |
| } catch (ParseException e) { |
| throw new RuntimeException(e); |
| } |
| } else { |
| success = false; |
| } |
| } |
| JSONArray jsonRefs = putJsonValue("refs", new JSONArray(), nameToJsonValue); |
| jsonRefs.add(getJsonObjectByRef(getNumber3Ref())); |
| } |
| break; |
| case EVALUATE: |
| success = handleEvaluate(args, nameToJsonValue); |
| break; |
| case SETBREAKPOINT: |
| case CHANGEBREAKPOINT: |
| { |
| long id = (debuggerCommand == DebuggerCommand.SETBREAKPOINT) |
| ? nextBreakpointId() |
| : JsonUtil.getAsLong(args, "breakpoint"); |
| Breakpoint.Target target = new Breakpoint.Target.ScriptName("abcde.js"); |
| breakpoints.put(id, new FakeBreakpoint(id, target, |
| JsonUtil.getAsBoolean(args, "enabled"), |
| JsonUtil.getAsString(args, "condition"))); |
| JSONObject jsonBody = putJsonValue("body", new JSONObject(), nameToJsonValue); |
| jsonBody.put("type", "script"); |
| jsonBody.put("breakpoint", id); |
| break; |
| } |
| case CLEARBREAKPOINT: { |
| long id = JsonUtil.getAsLong(args, "breakpoint"); |
| breakpoints.remove(id); |
| JSONObject jsonBody = putJsonValue("body", new JSONObject(), nameToJsonValue); |
| jsonBody.put("type", "script"); |
| jsonBody.put("breakpoint", id); |
| break; |
| } |
| case CONTINUE: |
| isRunning = true; |
| break; |
| case BACKTRACE: |
| JSONObject jsonBody = putJsonValue("body", new JSONObject(), nameToJsonValue); |
| constructBacktrace(responseMessage, jsonBody); |
| break; |
| case SCRIPTS: |
| nameToJsonValue.put("body", constructScripts(JsonUtil.getAsJSONArray(args, "ids"))); |
| nameToJsonValue.put("refs", constructScriptRefsJson()); |
| break; |
| case SOURCE: |
| //constructSource(); |
| break; |
| case SCOPE: |
| constructScopeResponse(nameToJsonValue); |
| break; |
| default: |
| success = false; |
| } |
| responseMessage.put("seq", nextSeq()); |
| responseMessage.put("request_seq", seq); |
| responseMessage.put("command", debuggerCommandString); |
| responseMessage.put("type", "response"); |
| if (success) { |
| responseMessage.put("success", true); |
| responseMessage.put("running", isRunning); |
| for (Entry<String, Object> entry : nameToJsonValue.entrySet()) { |
| responseMessage.put(entry.getKey(), entry.getValue()); |
| } |
| } else { |
| responseMessage.put("success", false); |
| responseMessage.put("message", "An error occurred"); |
| } |
| response = responseMessage.toJSONString(); |
| } |
| return new Message(Collections.<String, String>emptyMap(), response); |
| } |
| |
| @Override |
| public void sendSuspendedEvent() { |
| String response = "{\"seq\":" + nextSeq() + ",\"type\":\"event\",\"event\":\"break\"," |
| + "\"body\":{\"invocationText\":\"wasteCpu();\",\"sourceLine\":25,\"sourceColumn\":4," |
| + "\"sourceLineText\":\" debugger;\",\"script\":{\"id\":11,\"name\":\"samples/test.js\"," |
| + "\"lineOffset\":0,\"columnOffset\":0,\"lineCount\":36}}}"; |
| Message message = new Message(Collections.<String, String>emptyMap(), response); |
| listener.messageReceived(message); |
| } |
| |
| private <T> T putJsonValue(String name, T value, Map<String, Object> targetMap) { |
| targetMap.put(name, value); |
| return value; |
| } |
| |
| private JSONArray constructScriptRefsJson() { |
| return jsonArray(jsonObject( |
| jsonProperty("text", "#<a ContextMirror>"), |
| jsonProperty("handle", 0L), // must match the context ref in the script object |
| jsonProperty("type", "context"), |
| jsonProperty("data", jsonObject( |
| jsonProperty("value", 1L), |
| jsonProperty("type", "page") |
| )) |
| )); |
| } |
| |
| private List<SomeHandle> constructScriptRefsTyped() { |
| JSONArray refs = constructScriptRefsJson(); |
| try { |
| return FixtureParserAccess.get().parseRefs(refs).asHandles(); |
| } catch (JsonProtocolParseException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| private JSONArray constructScripts(JSONArray ids) { |
| JSONArray scripts = new JSONArray(); |
| for (Script script : scriptManager.allScripts()) { |
| Object id = script.getId(); |
| if (ids == null || ids.contains(id)) { |
| scripts.add(getJsonObjectByRef(scriptIdToScriptRefMap.get(script.getId()))); |
| } |
| } |
| return scripts; |
| } |
| |
| private void constructBacktrace(JSONObject response, JSONObject responseBody) { |
| response.put("refs", getRefs(getScriptRef(), getFunctionRef())); |
| responseBody.put("fromFrame", 0); |
| responseBody.put("toFrame", 1); |
| responseBody.put("totalFrames", 1); |
| JSONArray frames = new JSONArray(); |
| JSONObject frame = new JSONObject(); |
| frame.put("type", "frame"); |
| frame.put("index", 0); |
| frame.put("receiver", getReceiver()); |
| frame.put("func", getFunc()); |
| frame.put("script", getScript()); |
| frame.put("constructCall", false); |
| frame.put("debuggerFrame", false); |
| frame.put("arguments", new JSONArray()); |
| frame.put("locals", getLocalsArray()); |
| frame.put("scopes", getScopesArray()); |
| frame.put("position", 305); |
| frame.put("line", 18); |
| frame.put("column", 3); |
| frame.put("sourceLineText", " foo = bar;"); |
| frame.put("text", "#00 clicked() file:///C:/1.js line 18 column 3 (position 305)"); |
| frames.add(frame); |
| responseBody.put("frames", frames); |
| } |
| |
| private void constructScopeResponse(Map<String, Object> nameToJsonValue) { |
| nameToJsonValue.put("body", jsonObject( |
| jsonProperty("type", 1), |
| jsonProperty("index", 0), |
| jsonProperty("frameIndex", 0), |
| jsonProperty("object", |
| jsonObject( |
| jsonProperty("handle", -1), |
| jsonProperty("type", "object"), |
| jsonProperty("className", "Object"), |
| jsonProperty("constructorFunction", jsonObject( |
| "'ref':20,'type':'function','name':'Object','inferredName':''")), |
| jsonProperty("protoObject", jsonObject( |
| "'ref':21,'type':'object','className':'Object'")), |
| jsonProperty("prototypeObject", jsonObject("'ref':2,'type':'undefined'")), |
| jsonProperty("properties", |
| jsonArray( |
| jsonObject("'name':'x','value':{'ref':" + getMouseEventRef() + |
| ",'type':'object','className':'MouseEvent'}"), |
| jsonObject("'name':'y','value':{'ref':" + getNumber3Ref() + |
| ",'type':'number','value':3}") |
| ) |
| ), |
| jsonProperty("text", "#<an Object>") |
| ) |
| ), |
| jsonProperty("text", "#<a ScopeMirror>") |
| )); |
| nameToJsonValue.put("refs", getRefs(getNumber3Ref(), getMouseEventRef())); |
| } |
| |
| private boolean handleEvaluate(JSONObject args, Map<String, Object> nameToJsonValue) { |
| String expression = JsonUtil.getAsString(args, "expression"); |
| if (!"#long_value".equals(expression)) { |
| return false; |
| } |
| nameToJsonValue.put("body", LongValue.createHandle(true)); |
| return true; |
| } |
| |
| private static class LongValue { |
| static final String FULL_VALUE = "A very very very very very very very long value"; |
| static final int LENGTH_LIMIT = 10; |
| |
| static JSONObject createHandle(boolean truncated) { |
| if (truncated) { |
| String truncatedValue = LongValue.FULL_VALUE.substring(0, LongValue.LENGTH_LIMIT) + " ..."; |
| return jsonObject( |
| jsonProperty("handle", getLongValueRef()), |
| jsonProperty("type", "string"), |
| jsonProperty("value", truncatedValue), |
| jsonProperty("text", truncatedValue), |
| jsonProperty("fromIndex", 0), |
| jsonProperty("toIndex", LongValue.LENGTH_LIMIT), |
| jsonProperty("length", LongValue.FULL_VALUE.length()) |
| ); |
| } else { |
| return jsonObject( |
| jsonProperty("handle", getLongValueRef()), |
| jsonProperty("type", "string"), |
| jsonProperty("value", LongValue.FULL_VALUE), |
| jsonProperty("text", LongValue.FULL_VALUE) |
| ); |
| } |
| } |
| } |
| |
| |
| private JSONArray getRefs(int ... refParams) { |
| JSONObject [] refHandleObjects = new JSONObject [refParams.length]; |
| for (int i = 0; i < refParams.length; i++) { |
| refHandleObjects[i] = getJsonObjectByRef(refParams[i]); |
| } |
| return jsonArray(refHandleObjects); |
| } |
| |
| private JSONObject getJsonObjectByRef(int ref) { |
| String jsonText = refToObjectMap.get(Long.valueOf(ref)); |
| try { |
| return JsonUtil.jsonObjectFromJson(jsonText); |
| } catch (ParseException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| private JSONArray getLocalsArray() { |
| return jsonArray( |
| jsonObject( |
| jsonProperty("name", "a"), |
| jsonProperty("value", |
| jsonObject( |
| jsonProperty("ref", getNumber3Ref()), |
| jsonProperty("type", "number"), |
| jsonProperty("value", 1) |
| ) |
| ) |
| ) |
| ); |
| } |
| |
| private JSONArray getScopesArray() { |
| return jsonArray( |
| jsonObject( |
| jsonProperty("type", 0), |
| jsonProperty("index", 0) |
| ) |
| ); |
| } |
| |
| private JSONObject getScript() { |
| JSONObject script = new JSONObject(); |
| script.put("ref", getScriptRef()); |
| return script; |
| } |
| |
| private JSONObject getFunc() { |
| JSONObject func = new JSONObject(); |
| func.put("ref", getFunctionRef()); |
| func.put("type", "function"); |
| func.put("name", "clicked"); |
| func.put("scriptId", getScriptId()); |
| return func; |
| } |
| |
| private JSONObject getReceiver() { |
| JSONObject receiver = new JSONObject(); |
| receiver.put("ref", getMouseEventRef()); |
| receiver.put("type", "object"); |
| receiver.put("className", "global"); |
| return receiver; |
| } |
| |
| public void sendEvent(Message eventMessage) { |
| listener.messageReceived(eventMessage); |
| } |
| |
| public void hitBreakpoints(Collection<Long> breakpointIds) { |
| isRunning = false; |
| JSONObject eventObject = new JSONObject(); |
| eventObject.put("seq", nextSeq()); |
| eventObject.put("type", "event"); |
| eventObject.put("event", "break"); |
| JSONObject body = new JSONObject(); |
| JSONArray bps = new JSONArray(); |
| bps.addAll(breakpointIds); |
| body.put("breakpoints", bps); |
| // TODO: add other data if needed |
| eventObject.put("body", body); |
| sendEvent(createMessage(eventObject.toJSONString())); |
| } |
| |
| public void sendAfterCompile() { |
| JSONObject scriptsObject = getJsonObjectByRef(getCompiledScriptRef()); |
| ScriptHandle scriptsNormalBody; |
| try { |
| scriptsNormalBody = V8ProtocolParserAccess.get().parseScriptHandle(scriptsObject); |
| } catch (JsonProtocolParseException e) { |
| throw new RuntimeException(e); |
| } |
| ScriptImplTestGate.addScript(scriptManager, scriptsNormalBody, constructScriptRefsTyped()); |
| |
| JSONObject scriptObject = getJsonObjectByRef(getCompiledScriptRef()); |
| scriptObject.remove("source"); |
| |
| JSONObject afterCompileObject = jsonObject( |
| jsonProperty("seq", nextSeq()), |
| jsonProperty("type", "event"), |
| jsonProperty("event", "afterCompile"), |
| jsonProperty("success", true), |
| jsonProperty("body", jsonObject(jsonProperty("script", scriptObject))), |
| jsonProperty("refs", constructScriptRefsJson()) |
| ); |
| |
| sendEvent(createMessage(afterCompileObject.toJSONString())); |
| } |
| |
| private Message createMessage(String content) { |
| return new Message(Collections.<String, String>emptyMap(), content); |
| } |
| |
| private static class FakeBreakpoint extends BreakpointImpl { |
| public FakeBreakpoint(long id, Target target, boolean enabled, String condition) { |
| super(id, target, 15, enabled, condition, NULL_BREAKPOINT_MANAGER); |
| } |
| } |
| |
| @Override |
| public void setNetListener(NetListener listener) { |
| this.listener = listener; |
| } |
| |
| @JsonType(subtypesChosenManually=true) |
| public interface Refs { |
| @JsonSubtypeCasting |
| List<SomeHandle> asHandles() throws JsonProtocolParseException; |
| @JsonSubtypeCasting |
| List<? extends SomeHandle> asHandles2() throws JsonProtocolParseException; |
| } |
| |
| @JsonParserRoot |
| public interface FixtureParser { |
| |
| @JsonParseMethod |
| Refs parseRefs(Object refs) throws JsonProtocolParseException; |
| |
| } |
| } |
