From 6f9e79f450580686ed063d92534461e18a738a25 Mon Sep 17 00:00:00 2001 From: Riachel Date: Thu, 17 Nov 2022 10:51:40 +0800 Subject: [PATCH] Descriptor: add params ut tests details: add params ut tests issue:https://gitee.com/openharmony/arkcompiler_toolchain/issues/I61MA0 Signed-off-by: Riachel --- tooling/base/pt_params.cpp | 1991 +++++++++++++------------ tooling/test/debugger_params_test.cpp | 1382 +++++++++++------ 2 files changed, 1908 insertions(+), 1465 deletions(-) diff --git a/tooling/base/pt_params.cpp b/tooling/base/pt_params.cpp index 26983d94..7b719471 100644 --- a/tooling/base/pt_params.cpp +++ b/tooling/base/pt_params.cpp @@ -1,988 +1,1003 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "base/pt_params.h" - -namespace panda::ecmascript::tooling { -std::unique_ptr EnableParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - double maxScriptsCacheSize; - ret = params.GetDouble("maxScriptsCacheSize", &maxScriptsCacheSize); - if (ret == Result::SUCCESS) { - paramsObject->maxScriptsCacheSize_ = maxScriptsCacheSize; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'maxScriptsCacheSize';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "EnableParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr EvaluateOnCallFrameParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::string callFrameId; - ret = params.GetString("callFrameId", &callFrameId); - if (ret == Result::SUCCESS) { - paramsObject->callFrameId_ = std::stoi(callFrameId); - } else { - error += "Unknown 'callFrameId';"; - } - std::string expression; - ret = params.GetString("expression", &expression); - if (ret == Result::SUCCESS) { - paramsObject->expression_ = std::move(expression); - } else { - error += "Unknown 'expression';"; - } - std::string objectGroup; - ret = params.GetString("objectGroup", &objectGroup); - if (ret == Result::SUCCESS) { - paramsObject->objectGroup_ = std::move(objectGroup); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'objectGroup';"; - } - bool includeCommandLineAPI = false; - ret = params.GetBool("includeCommandLineAPI", &includeCommandLineAPI); - if (ret == Result::SUCCESS) { - paramsObject->includeCommandLineAPI_ = includeCommandLineAPI; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'includeCommandLineAPI';"; - } - bool silent = false; - ret = params.GetBool("silent", &silent); - if (ret == Result::SUCCESS) { - paramsObject->silent_ = silent; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'silent';"; - } - bool returnByValue = false; - ret = params.GetBool("returnByValue", &returnByValue); - if (ret == Result::SUCCESS) { - paramsObject->returnByValue_ = returnByValue; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'returnByValue';"; - } - bool generatePreview = false; - ret = params.GetBool("generatePreview", &generatePreview); - if (ret == Result::SUCCESS) { - paramsObject->generatePreview_ = generatePreview; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'generatePreview';"; - } - bool throwOnSideEffect = false; - ret = params.GetBool("throwOnSideEffect", &throwOnSideEffect); - if (ret == Result::SUCCESS) { - paramsObject->throwOnSideEffect_ = throwOnSideEffect; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'throwOnSideEffect';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "EvaluateOnCallFrameParams::Create " << error; - return nullptr; - } - return paramsObject; -} - -std::unique_ptr GetPossibleBreakpointsParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::unique_ptr start; - ret = params.GetObject("start", &start); - if (ret == Result::SUCCESS) { - std::unique_ptr location = Location::Create(*start); - if (location == nullptr) { - error += "Unknown 'start';"; - } else { - paramsObject->start_ = std::move(location); - } - } else { - error += "Unknown 'start';"; - } - std::unique_ptr end; - ret = params.GetObject("start", &end); - if (ret == Result::SUCCESS) { - std::unique_ptr location = Location::Create(*end); - if (location == nullptr) { - error += "Unknown 'end';"; - } else { - paramsObject->end_ = std::move(location); - } - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'end';"; - } - bool restrictToFunction = false; - ret = params.GetBool("restrictToFunction", &restrictToFunction); - if (ret == Result::SUCCESS) { - paramsObject->restrictToFunction_ = restrictToFunction; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'restrictToFunction';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "GetPossibleBreakpointsParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr GetScriptSourceParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::string scriptId; - ret = params.GetString("scriptId", &scriptId); - if (ret == Result::SUCCESS) { - paramsObject->scriptId_ = std::stoi(scriptId); - } else { - error += "Unknown 'scriptId';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "GetScriptSourceParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr RemoveBreakpointParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::string breakpointId; - ret = params.GetString("breakpointId", &breakpointId); - if (ret == Result::SUCCESS) { - paramsObject->breakpointId_ = std::move(breakpointId); - } else { - error += "Unknown 'breakpointId';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "RemoveBreakpointParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr ResumeParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - bool terminateOnResume = false; - ret = params.GetBool("terminateOnResume", &terminateOnResume); - if (ret == Result::SUCCESS) { - paramsObject->terminateOnResume_ = terminateOnResume; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'terminateOnResume';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "ResumeParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr SetAsyncCallStackDepthParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - int32_t maxDepth; - ret = params.GetInt("maxDepth", &maxDepth); - if (ret == Result::SUCCESS) { - paramsObject->maxDepth_ = maxDepth; - } else { - error += "Unknown 'maxDepth';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "SetAsyncCallStackDepthParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr SetBlackboxPatternsParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::unique_ptr patterns; - ret = params.GetArray("patterns", &patterns); - if (ret == Result::SUCCESS) { - int32_t len = patterns->GetSize(); - for (int32_t i = 0; i < len; ++i) { - std::unique_ptr item = patterns->Get(i); - if (item->IsString()) { - paramsObject->patterns_.emplace_back(item->GetString()); - } else { - error += "'patterns' items should be a String;"; - } - } - } else { - error += "Unknown 'patterns';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "SetBlackboxPatternsParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr SetBreakpointByUrlParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - int32_t lineNumber; - ret = params.GetInt("lineNumber", &lineNumber); - if (ret == Result::SUCCESS) { - paramsObject->lineNumber_ = lineNumber; - } else { - error += "Unknown 'lineNumber';"; - } - std::string url; - ret = params.GetString("url", &url); - if (ret == Result::SUCCESS) { - paramsObject->url_ = std::move(url); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'url';"; - } - std::string urlRegex; - ret = params.GetString("urlRegex", &urlRegex); - if (ret == Result::SUCCESS) { - paramsObject->urlRegex_ = std::move(urlRegex); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'urlRegex';"; - } - std::string scriptHash; - ret = params.GetString("scriptHash", &scriptHash); - if (ret == Result::SUCCESS) { - paramsObject->scriptHash_ = std::move(scriptHash); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'scriptHash';"; - } - int32_t columnNumber; - ret = params.GetInt("columnNumber", &columnNumber); - if (ret == Result::SUCCESS) { - paramsObject->columnNumber_ = columnNumber; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'columnNumber';"; - } - std::string condition; - ret = params.GetString("condition", &condition); - if (ret == Result::SUCCESS) { - paramsObject->condition_ = std::move(condition); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'condition';"; - } - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "SetBreakpointByUrlParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr SetPauseOnExceptionsParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::string state; - ret = params.GetString("state", &state); - if (ret == Result::SUCCESS) { - paramsObject->StoreState(state); - } else { - error += "Unknown 'state';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "SetPauseOnExceptionsParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr StepIntoParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - bool breakOnAsyncCall = false; - ret = params.GetBool("breakOnAsyncCall", &breakOnAsyncCall); - if (ret == Result::SUCCESS) { - paramsObject->breakOnAsyncCall_ = breakOnAsyncCall; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'breakOnAsyncCall';"; - } - std::unique_ptr skipList; - ret = params.GetArray("skipList", &skipList); - if (ret == Result::SUCCESS) { - int32_t len = skipList->GetSize(); - for (int32_t i = 0; i < len; ++i) { - std::unique_ptr obj = LocationRange::Create(*skipList->Get(i)); - if (obj == nullptr) { - error += "'skipList' items LocationRange is invalid;"; - } else { - paramsObject->skipList_->emplace_back(std::move(obj)); - } - } - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'skipList';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "StepIntoParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr StepOverParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::unique_ptr skipList; - ret = params.GetArray("skipList", &skipList); - if (ret == Result::SUCCESS) { - int32_t len = skipList->GetSize(); - for (int32_t i = 0; i < len; ++i) { - std::unique_ptr obj = LocationRange::Create(*skipList->Get(i)); - if (obj == nullptr) { - error += "'skipList' items LocationRange is invalid;"; - } else { - paramsObject->skipList_->emplace_back(std::move(obj)); - } - } - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'skipList';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "StepOverParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr SetMixedDebugParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - bool enabled = false; - ret = params.GetBool("enabled", &enabled); - if (ret == Result::SUCCESS) { - paramsObject->enabled_ = enabled; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'enabled';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "SetMixedDebugParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr ReplyNativeCallingParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - bool userCode = false; - ret = params.GetBool("userCode", &userCode); - if (ret == Result::SUCCESS) { - paramsObject->userCode_ = userCode; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'userCode';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "ReplyNativeCallingParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr GetPropertiesParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::string objectId; - ret = params.GetString("objectId", &objectId); - if (ret == Result::SUCCESS) { - paramsObject->objectId_ = std::stoi(objectId); - } else { - error += "Unknown 'objectId';"; - } - bool ownProperties = false; - ret = params.GetBool("ownProperties", &ownProperties); - if (ret == Result::SUCCESS) { - paramsObject->ownProperties_ = ownProperties; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'ownProperties';"; - } - bool accessorPropertiesOnly = false; - ret = params.GetBool("accessorPropertiesOnly", &accessorPropertiesOnly); - if (ret == Result::SUCCESS) { - paramsObject->accessorPropertiesOnly_ = accessorPropertiesOnly; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'accessorPropertiesOnly';"; - } - bool generatePreview = false; - ret = params.GetBool("generatePreview", &generatePreview); - if (ret == Result::SUCCESS) { - paramsObject->generatePreview_ = generatePreview; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'generatePreview';"; - } - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "GetPropertiesParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr CallFunctionOnParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - // paramsObject->functionDeclaration_ - std::string functionDeclaration; - ret = params.GetString("functionDeclaration", &functionDeclaration); - if (ret == Result::SUCCESS) { - paramsObject->functionDeclaration_ = std::move(functionDeclaration); - } else { - error += "Unknown 'functionDeclaration';"; - } - // paramsObject->objectId_ - std::string objectId; - ret = params.GetString("objectId", &objectId); - if (ret == Result::SUCCESS) { - paramsObject->objectId_ = std::stoi(objectId); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'objectId';"; - } - // paramsObject->arguments_ - std::unique_ptr arguments; - ret = params.GetArray("arguments", &arguments); - if (ret == Result::SUCCESS) { - int32_t len = arguments->GetSize(); - for (int32_t i = 0; i < len; ++i) { - std::unique_ptr obj = CallArgument::Create(*arguments->Get(i)); - if (obj == nullptr) { - error += "'arguments' items CallArgument is invaild;"; - } else { - paramsObject->arguments_->emplace_back(std::move(obj)); - } - } - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'arguments';"; - } - // paramsObject->silent_ - bool silent = false; - ret = params.GetBool("silent", &silent); - if (ret == Result::SUCCESS) { - paramsObject->silent_ = silent; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'silent';"; - } - // paramsObject->returnByValue_ - bool returnByValue = false; - ret = params.GetBool("returnByValue", &returnByValue); - if (ret == Result::SUCCESS) { - paramsObject->returnByValue_ = returnByValue; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'returnByValue';"; - } - // paramsObject->generatePreview_ - bool generatePreview = false; - ret = params.GetBool("generatePreview", &generatePreview); - if (ret == Result::SUCCESS) { - paramsObject->generatePreview_ = generatePreview; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'generatePreview';"; - } - // paramsObject->userGesture_ - bool userGesture = false; - ret = params.GetBool("userGesture", &userGesture); - if (ret == Result::SUCCESS) { - paramsObject->userGesture_ = userGesture; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'userGesture';"; - } - // paramsObject->awaitPromise_ - bool awaitPromise = false; - ret = params.GetBool("awaitPromise", &awaitPromise); - if (ret == Result::SUCCESS) { - paramsObject->awaitPromise_ = awaitPromise; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'awaitPromise';"; - } - // paramsObject->executionContextId_ - int32_t executionContextId; - ret = params.GetInt("executionContextId", &executionContextId); - if (ret == Result::SUCCESS) { - paramsObject->executionContextId_ = executionContextId; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'executionContextId';"; - } - // paramsObject->objectGroup_ - std::string objectGroup; - ret = params.GetString("objectGroup", &objectGroup); - if (ret == Result::SUCCESS) { - paramsObject->objectGroup_ = std::move(objectGroup); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'objectGroup';"; - } - // paramsObject->throwOnSideEffect_ - bool throwOnSideEffect = false; - ret = params.GetBool("throwOnSideEffect", &throwOnSideEffect); - if (ret == Result::SUCCESS) { - paramsObject->throwOnSideEffect_ = throwOnSideEffect; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'throwOnSideEffect';"; - } - - // Check whether the error is empty. - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "CallFunctionOnParams::Create " << error; - return nullptr; - } - - return paramsObject; -} - -std::unique_ptr StartSamplingParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - int32_t samplingInterval; - ret = params.GetInt("samplingInterval", &samplingInterval); - if (ret == Result::SUCCESS) { - paramsObject->samplingInterval_ = samplingInterval; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'samplingInterval';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "StartSamplingParams::Create " << error; - return nullptr; - } - return paramsObject; -} - -std::unique_ptr StartTrackingHeapObjectsParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - bool trackAllocations = false; - ret = params.GetBool("trackAllocations", &trackAllocations); - if (ret == Result::SUCCESS) { - paramsObject->trackAllocations_ = trackAllocations; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'trackAllocations';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "StartTrackingHeapObjectsParams::Create " << error; - return nullptr; - } - return paramsObject; -} - -std::unique_ptr StopTrackingHeapObjectsParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - bool reportProgress = false; - ret = params.GetBool("reportProgress", &reportProgress); - if (ret == Result::SUCCESS) { - paramsObject->reportProgress_ = reportProgress; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'reportProgress';"; - } - - bool treatGlobalObjectsAsRoots = false; - ret = params.GetBool("treatGlobalObjectsAsRoots", &treatGlobalObjectsAsRoots); - if (ret == Result::SUCCESS) { - paramsObject->treatGlobalObjectsAsRoots_ = treatGlobalObjectsAsRoots; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'treatGlobalObjectsAsRoots';"; - } - - bool captureNumericValue = false; - ret = params.GetBool("captureNumericValue", &captureNumericValue); - if (ret == Result::SUCCESS) { - paramsObject->captureNumericValue_ = captureNumericValue; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'captureNumericValue';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "StopTrackingHeapObjectsParams::Create " << error; - return nullptr; - } - return paramsObject; -} - -std::unique_ptr AddInspectedHeapObjectParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::string heapObjectId; - ret = params.GetString("heapObjectId", &heapObjectId); - if (ret == Result::SUCCESS) { - paramsObject->heapObjectId_ = std::stoi(heapObjectId); - } else { - error += "Unknown 'heapObjectId';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "AddInspectedHeapObjectParams::Create " << error; - return nullptr; - } - return paramsObject; -} - -std::unique_ptr GetHeapObjectIdParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::string objectId; - ret = params.GetString("objectId", &objectId); - if (ret == Result::SUCCESS) { - paramsObject->objectId_ = std::stoi(objectId); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'objectId';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "GetHeapObjectIdParams::Create " << error; - return nullptr; - } - return paramsObject; -} - -std::unique_ptr GetObjectByHeapObjectIdParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - std::string objectId; - ret = params.GetString("objectId", &objectId); - if (ret == Result::SUCCESS) { - paramsObject->objectId_ = std::stoi(objectId); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'objectId';"; - } - - std::string objectGroup; - ret = params.GetString("objectGroup", &objectGroup); - if (ret == Result::SUCCESS) { - paramsObject->objectGroup_ = std::move(objectGroup); - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'objectGroup';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "GetObjectByHeapObjectIdParams::Create " << error; - return nullptr; - } - return paramsObject; -} - -std::unique_ptr StartPreciseCoverageParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - bool callCount = false; - ret = params.GetBool("callCount", &callCount); - if (ret == Result::SUCCESS) { - paramsObject->callCount_ = callCount; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'callCount';"; - } - - bool detailed = false; - ret = params.GetBool("detailed", &detailed); - if (ret == Result::SUCCESS) { - paramsObject->detailed_ = detailed; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'detailed';"; - } - - bool allowTriggeredUpdates = false; - ret = params.GetBool("allowTriggeredUpdates", &allowTriggeredUpdates); - if (ret == Result::SUCCESS) { - paramsObject->allowTriggeredUpdates_ = allowTriggeredUpdates; - } else if (ret == Result::TYPE_ERROR) { // optional value - error += "Unknown 'allowTriggeredUpdates';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "StartPreciseCoverageParams::Create " << error; - return nullptr; - } - return paramsObject; -} - -std::unique_ptr SetSamplingIntervalParams::Create(const PtJson ¶ms) -{ - auto paramsObject = std::make_unique(); - std::string error; - Result ret; - - int32_t interval = 0; - ret = params.GetInt("interval", &interval); - if (ret == Result::SUCCESS) { - paramsObject->interval_ = interval; - } else { - error += "Unknown 'interval';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "SetSamplingIntervalParams::Create " << error; - return nullptr; - } - return paramsObject; -} - -std::unique_ptr RecordClockSyncMarkerParams::Create(const PtJson ¶ms) -{ - std::string error; - auto recordClockSyncMarkerParams = std::make_unique(); - Result ret; - - std::string syncId; - ret = params.GetString("syncId", &syncId); - if (ret == Result::SUCCESS) { - recordClockSyncMarkerParams->syncId_ = syncId; - } else { - error += "Unknown 'syncId';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "RecordClockSyncMarkerParams::Create " << error; - return nullptr; - } - - return recordClockSyncMarkerParams; -} - -std::unique_ptr RequestMemoryDumpParams::Create(const PtJson ¶ms) -{ - std::string error; - auto requestMemoryDumpParams = std::make_unique(); - Result ret; - - bool deterministic = false; - ret = params.GetBool("deterministic", &deterministic); - if (ret == Result::SUCCESS) { - requestMemoryDumpParams->deterministic_ = deterministic; - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'deterministic';"; - } - - std::string levelOfDetail; - ret = params.GetString("levelOfDetail", &levelOfDetail); - if (ret == Result::SUCCESS) { - if (MemoryDumpLevelOfDetailValues::Valid(levelOfDetail)) { - requestMemoryDumpParams->levelOfDetail_ = std::move(levelOfDetail); - } else { - error += "'levelOfDetail' is invalid;"; - } - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'levelOfDetail';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "RequestMemoryDumpParams::Create " << error; - return nullptr; - } - - return requestMemoryDumpParams; -} - -std::unique_ptr StartParams::Create(const PtJson ¶ms) -{ - std::string error; - auto startParams = std::make_unique(); - Result ret; - - std::string categories; - ret = params.GetString("categories", &categories); - if (ret == Result::SUCCESS) { - startParams->categories_ = std::move(categories); - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'categories';"; - } - - std::string options; - ret = params.GetString("options", &options); - if (ret == Result::SUCCESS) { - startParams->options_ = std::move(options); - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'options';"; - } - - int32_t bufferUsageReportingInterval = 0; - ret = params.GetInt("bufferUsageReportingInterval", &bufferUsageReportingInterval); - if (ret == Result::SUCCESS) { - startParams->bufferUsageReportingInterval_ = bufferUsageReportingInterval; - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'bufferUsageReportingInterval';"; - } - - std::string transferMode; - ret = params.GetString("transferMode", &transferMode); - if (ret == Result::SUCCESS) { - if (StartParams::TransferModeValues::Valid(transferMode)) { - startParams->transferMode_ = std::move(transferMode); - } else { - error += "'transferMode' is invalid;"; - } - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'transferMode';"; - } - - std::string streamFormat; - ret = params.GetString("streamFormat", &streamFormat); - if (ret == Result::SUCCESS) { - if (StreamFormatValues::Valid(streamFormat)) { - startParams->streamFormat_ = std::move(streamFormat); - } else { - error += "'streamFormat' is invalid;"; - } - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'streamFormat';"; - } - - std::string streamCompression; - ret = params.GetString("streamCompression", &streamCompression); - if (ret == Result::SUCCESS) { - if (StreamCompressionValues::Valid(streamCompression)) { - startParams->streamCompression_ = std::move(streamCompression); - } else { - error += "'streamCompression' is invalid;"; - } - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'streamCompression';"; - } - - std::unique_ptr traceConfig; - ret = params.GetObject("traceConfig", &traceConfig); - if (ret == Result::SUCCESS) { - std::unique_ptr pTraceConfig = TraceConfig::Create(*traceConfig); - if (pTraceConfig == nullptr) { - error += "'traceConfig' format invalid;"; - } else { - startParams->traceConfig_ = std::move(pTraceConfig); - } - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'traceConfig';"; - } - - std::string perfettoConfig; - ret = params.GetString("perfettoConfig", &perfettoConfig); - if (ret == Result::SUCCESS) { - startParams->perfettoConfig_ = std::move(perfettoConfig); - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'perfettoConfig';"; - } - - std::string tracingBackend; - ret = params.GetString("tracingBackend", &tracingBackend); - if (ret == Result::SUCCESS) { - if (TracingBackendValues::Valid(tracingBackend)) { - startParams->tracingBackend_ = std::move(tracingBackend); - } else { - error += "'tracingBackend' is invalid;"; - } - } else if (ret == Result::TYPE_ERROR) { - error += "Unknown 'tracingBackend';"; - } - - if (!error.empty()) { - LOG_DEBUGGER(ERROR) << "StartParams::Create " << error; - return nullptr; - } - - return startParams; -} -} // namespace panda::ecmascript::tooling +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "base/pt_params.h" + +namespace panda::ecmascript::tooling { +std::unique_ptr EnableParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + double maxScriptsCacheSize; + ret = params.GetDouble("maxScriptsCacheSize", &maxScriptsCacheSize); + if (ret == Result::SUCCESS) { + paramsObject->maxScriptsCacheSize_ = maxScriptsCacheSize; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'maxScriptsCacheSize';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "EnableParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr EvaluateOnCallFrameParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::string callFrameId; + ret = params.GetString("callFrameId", &callFrameId); + if (ret == Result::SUCCESS) { + paramsObject->callFrameId_ = std::stoi(callFrameId); + } else { + error += "Unknown 'callFrameId';"; + } + std::string expression; + ret = params.GetString("expression", &expression); + if (ret == Result::SUCCESS) { + paramsObject->expression_ = std::move(expression); + } else { + error += "Unknown 'expression';"; + } + std::string objectGroup; + ret = params.GetString("objectGroup", &objectGroup); + if (ret == Result::SUCCESS) { + paramsObject->objectGroup_ = std::move(objectGroup); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'objectGroup';"; + } + bool includeCommandLineAPI = false; + ret = params.GetBool("includeCommandLineAPI", &includeCommandLineAPI); + if (ret == Result::SUCCESS) { + paramsObject->includeCommandLineAPI_ = includeCommandLineAPI; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'includeCommandLineAPI';"; + } + bool silent = false; + ret = params.GetBool("silent", &silent); + if (ret == Result::SUCCESS) { + paramsObject->silent_ = silent; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'silent';"; + } + bool returnByValue = false; + ret = params.GetBool("returnByValue", &returnByValue); + if (ret == Result::SUCCESS) { + paramsObject->returnByValue_ = returnByValue; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'returnByValue';"; + } + bool generatePreview = false; + ret = params.GetBool("generatePreview", &generatePreview); + if (ret == Result::SUCCESS) { + paramsObject->generatePreview_ = generatePreview; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'generatePreview';"; + } + bool throwOnSideEffect = false; + ret = params.GetBool("throwOnSideEffect", &throwOnSideEffect); + if (ret == Result::SUCCESS) { + paramsObject->throwOnSideEffect_ = throwOnSideEffect; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'throwOnSideEffect';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "EvaluateOnCallFrameParams::Create " << error; + return nullptr; + } + return paramsObject; +} + +std::unique_ptr GetPossibleBreakpointsParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::unique_ptr start; + ret = params.GetObject("start", &start); + if (ret == Result::SUCCESS) { + std::unique_ptr location = Location::Create(*start); + if (location == nullptr) { + error += "Unknown 'start';"; + } else { + paramsObject->start_ = std::move(location); + } + } else { + error += "Unknown 'start';"; + } + std::unique_ptr end; + ret = params.GetObject("end", &end); + if (ret == Result::SUCCESS) { + std::unique_ptr location = Location::Create(*end); + if (location == nullptr) { + error += "Unknown 'end';"; + } else { + paramsObject->end_ = std::move(location); + } + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'end';"; + } + bool restrictToFunction = false; + ret = params.GetBool("restrictToFunction", &restrictToFunction); + if (ret == Result::SUCCESS) { + paramsObject->restrictToFunction_ = restrictToFunction; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'restrictToFunction';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "GetPossibleBreakpointsParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr GetScriptSourceParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::string scriptId; + ret = params.GetString("scriptId", &scriptId); + if (ret == Result::SUCCESS) { + paramsObject->scriptId_ = std::stoi(scriptId); + } else { + error += "Unknown 'scriptId';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "GetScriptSourceParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr RemoveBreakpointParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::string breakpointId; + ret = params.GetString("breakpointId", &breakpointId); + if (ret == Result::SUCCESS) { + paramsObject->breakpointId_ = std::move(breakpointId); + } else { + error += "Unknown 'breakpointId';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "RemoveBreakpointParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr ResumeParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + bool terminateOnResume = false; + ret = params.GetBool("terminateOnResume", &terminateOnResume); + if (ret == Result::SUCCESS) { + paramsObject->terminateOnResume_ = terminateOnResume; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'terminateOnResume';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "ResumeParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr SetAsyncCallStackDepthParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + int32_t maxDepth; + ret = params.GetInt("maxDepth", &maxDepth); + if (ret == Result::SUCCESS) { + paramsObject->maxDepth_ = maxDepth; + } else { + error += "Unknown 'maxDepth';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "SetAsyncCallStackDepthParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr SetBlackboxPatternsParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::unique_ptr patterns; + ret = params.GetArray("patterns", &patterns); + if (ret == Result::SUCCESS) { + int32_t len = patterns->GetSize(); + for (int32_t i = 0; i < len; ++i) { + std::unique_ptr item = patterns->Get(i); + if (item->IsString()) { + paramsObject->patterns_.emplace_back(item->GetString()); + } else { + error += "'patterns' items should be a String;"; + } + } + } else { + error += "Unknown 'patterns';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "SetBlackboxPatternsParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr SetBreakpointByUrlParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + int32_t lineNumber; + ret = params.GetInt("lineNumber", &lineNumber); + if (ret == Result::SUCCESS) { + paramsObject->lineNumber_ = lineNumber; + } else { + error += "Unknown 'lineNumber';"; + } + std::string url; + ret = params.GetString("url", &url); + if (ret == Result::SUCCESS) { + paramsObject->url_ = std::move(url); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'url';"; + } + std::string urlRegex; + ret = params.GetString("urlRegex", &urlRegex); + if (ret == Result::SUCCESS) { + paramsObject->urlRegex_ = std::move(urlRegex); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'urlRegex';"; + } + std::string scriptHash; + ret = params.GetString("scriptHash", &scriptHash); + if (ret == Result::SUCCESS) { + paramsObject->scriptHash_ = std::move(scriptHash); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'scriptHash';"; + } + int32_t columnNumber; + ret = params.GetInt("columnNumber", &columnNumber); + if (ret == Result::SUCCESS) { + paramsObject->columnNumber_ = columnNumber; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'columnNumber';"; + } + std::string condition; + ret = params.GetString("condition", &condition); + if (ret == Result::SUCCESS) { + paramsObject->condition_ = std::move(condition); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'condition';"; + } + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "SetBreakpointByUrlParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr SetPauseOnExceptionsParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::string state; + ret = params.GetString("state", &state); + if (ret == Result::SUCCESS) { + paramsObject->StoreState(state); + } else { + error += "Unknown 'state';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "SetPauseOnExceptionsParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr StepIntoParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + bool breakOnAsyncCall = false; + ret = params.GetBool("breakOnAsyncCall", &breakOnAsyncCall); + if (ret == Result::SUCCESS) { + paramsObject->breakOnAsyncCall_ = breakOnAsyncCall; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'breakOnAsyncCall';"; + } + std::unique_ptr skipList; + ret = params.GetArray("skipList", &skipList); + if (ret == Result::SUCCESS) { + int32_t len = skipList->GetSize(); + std::list> listLocation; + for (int32_t i = 0; i < len; ++i) { + std::unique_ptr obj = LocationRange::Create(*skipList->Get(i)); + if (obj == nullptr) { + error += "'skipList' items LocationRange is invalid;"; + break; + } else { + listLocation.emplace_back(std::move(obj)); + } + } + if (listLocation.size()) { + paramsObject->skipList_ = std::move(listLocation); + } + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'skipList';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "StepIntoParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr StepOverParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::unique_ptr skipList; + ret = params.GetArray("skipList", &skipList); + if (ret == Result::SUCCESS) { + int32_t len = skipList->GetSize(); + std::list> listLocation; + for (int32_t i = 0; i < len; ++i) { + std::unique_ptr obj = LocationRange::Create(*skipList->Get(i)); + if (obj == nullptr) { + error += "'skipList' items LocationRange is invalid;"; + break; + } else { + listLocation.emplace_back(std::move(obj)); + } + } + if (listLocation.size()) { + paramsObject->skipList_ = std::move(listLocation); + } + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'skipList';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "StepOverParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr SetMixedDebugParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + bool enabled = false; + ret = params.GetBool("enabled", &enabled); + if (ret == Result::SUCCESS) { + paramsObject->enabled_ = enabled; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'enabled';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "SetMixedDebugParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr ReplyNativeCallingParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + bool userCode = false; + ret = params.GetBool("userCode", &userCode); + if (ret == Result::SUCCESS) { + paramsObject->userCode_ = userCode; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'userCode';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "ReplyNativeCallingParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr GetPropertiesParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::string objectId; + ret = params.GetString("objectId", &objectId); + if (ret == Result::SUCCESS) { + paramsObject->objectId_ = std::stoi(objectId); + } else { + error += "Unknown 'objectId';"; + } + bool ownProperties = false; + ret = params.GetBool("ownProperties", &ownProperties); + if (ret == Result::SUCCESS) { + paramsObject->ownProperties_ = ownProperties; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'ownProperties';"; + } + bool accessorPropertiesOnly = false; + ret = params.GetBool("accessorPropertiesOnly", &accessorPropertiesOnly); + if (ret == Result::SUCCESS) { + paramsObject->accessorPropertiesOnly_ = accessorPropertiesOnly; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'accessorPropertiesOnly';"; + } + bool generatePreview = false; + ret = params.GetBool("generatePreview", &generatePreview); + if (ret == Result::SUCCESS) { + paramsObject->generatePreview_ = generatePreview; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'generatePreview';"; + } + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "GetPropertiesParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr CallFunctionOnParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + // paramsObject->functionDeclaration_ + std::string functionDeclaration; + ret = params.GetString("functionDeclaration", &functionDeclaration); + if (ret == Result::SUCCESS) { + paramsObject->functionDeclaration_ = std::move(functionDeclaration); + } else { + error += "Unknown 'functionDeclaration';"; + } + // paramsObject->objectId_ + std::string objectId; + ret = params.GetString("objectId", &objectId); + if (ret == Result::SUCCESS) { + paramsObject->objectId_ = std::stoi(objectId); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'objectId';"; + } + // paramsObject->arguments_ + std::unique_ptr arguments; + ret = params.GetArray("arguments", &arguments); + if (ret == Result::SUCCESS) { + int32_t len = arguments->GetSize(); + std::vector> callArgument; + for (int32_t i = 0; i < len; ++i) { + std::unique_ptr obj = CallArgument::Create(*arguments->Get(i)); + if (obj == nullptr) { + error += "'arguments' items CallArgument is invaild;"; + break; + } else { + callArgument.emplace_back(std::move(obj)); + } + } + if (callArgument.size()) { + paramsObject->arguments_ = std::move(callArgument); + } + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'arguments';"; + } + // paramsObject->silent_ + bool silent = false; + ret = params.GetBool("silent", &silent); + if (ret == Result::SUCCESS) { + paramsObject->silent_ = silent; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'silent';"; + } + // paramsObject->returnByValue_ + bool returnByValue = false; + ret = params.GetBool("returnByValue", &returnByValue); + if (ret == Result::SUCCESS) { + paramsObject->returnByValue_ = returnByValue; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'returnByValue';"; + } + // paramsObject->generatePreview_ + bool generatePreview = false; + ret = params.GetBool("generatePreview", &generatePreview); + if (ret == Result::SUCCESS) { + paramsObject->generatePreview_ = generatePreview; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'generatePreview';"; + } + // paramsObject->userGesture_ + bool userGesture = false; + ret = params.GetBool("userGesture", &userGesture); + if (ret == Result::SUCCESS) { + paramsObject->userGesture_ = userGesture; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'userGesture';"; + } + // paramsObject->awaitPromise_ + bool awaitPromise = false; + ret = params.GetBool("awaitPromise", &awaitPromise); + if (ret == Result::SUCCESS) { + paramsObject->awaitPromise_ = awaitPromise; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'awaitPromise';"; + } + // paramsObject->executionContextId_ + int32_t executionContextId; + ret = params.GetInt("executionContextId", &executionContextId); + if (ret == Result::SUCCESS) { + paramsObject->executionContextId_ = executionContextId; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'executionContextId';"; + } + // paramsObject->objectGroup_ + std::string objectGroup; + ret = params.GetString("objectGroup", &objectGroup); + if (ret == Result::SUCCESS) { + paramsObject->objectGroup_ = std::move(objectGroup); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'objectGroup';"; + } + // paramsObject->throwOnSideEffect_ + bool throwOnSideEffect = false; + ret = params.GetBool("throwOnSideEffect", &throwOnSideEffect); + if (ret == Result::SUCCESS) { + paramsObject->throwOnSideEffect_ = throwOnSideEffect; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'throwOnSideEffect';"; + } + + // Check whether the error is empty. + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "CallFunctionOnParams::Create " << error; + return nullptr; + } + + return paramsObject; +} + +std::unique_ptr StartSamplingParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + int32_t samplingInterval; + ret = params.GetInt("samplingInterval", &samplingInterval); + if (ret == Result::SUCCESS) { + paramsObject->samplingInterval_ = samplingInterval; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'samplingInterval';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "StartSamplingParams::Create " << error; + return nullptr; + } + return paramsObject; +} + +std::unique_ptr StartTrackingHeapObjectsParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + bool trackAllocations = false; + ret = params.GetBool("trackAllocations", &trackAllocations); + if (ret == Result::SUCCESS) { + paramsObject->trackAllocations_ = trackAllocations; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'trackAllocations';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "StartTrackingHeapObjectsParams::Create " << error; + return nullptr; + } + return paramsObject; +} + +std::unique_ptr StopTrackingHeapObjectsParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + bool reportProgress = false; + ret = params.GetBool("reportProgress", &reportProgress); + if (ret == Result::SUCCESS) { + paramsObject->reportProgress_ = reportProgress; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'reportProgress';"; + } + + bool treatGlobalObjectsAsRoots = false; + ret = params.GetBool("treatGlobalObjectsAsRoots", &treatGlobalObjectsAsRoots); + if (ret == Result::SUCCESS) { + paramsObject->treatGlobalObjectsAsRoots_ = treatGlobalObjectsAsRoots; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'treatGlobalObjectsAsRoots';"; + } + + bool captureNumericValue = false; + ret = params.GetBool("captureNumericValue", &captureNumericValue); + if (ret == Result::SUCCESS) { + paramsObject->captureNumericValue_ = captureNumericValue; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'captureNumericValue';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "StopTrackingHeapObjectsParams::Create " << error; + return nullptr; + } + return paramsObject; +} + +std::unique_ptr AddInspectedHeapObjectParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::string heapObjectId; + ret = params.GetString("heapObjectId", &heapObjectId); + if (ret == Result::SUCCESS) { + paramsObject->heapObjectId_ = std::stoi(heapObjectId); + } else { + error += "Unknown 'heapObjectId';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "AddInspectedHeapObjectParams::Create " << error; + return nullptr; + } + return paramsObject; +} + +std::unique_ptr GetHeapObjectIdParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::string objectId; + ret = params.GetString("objectId", &objectId); + if (ret == Result::SUCCESS) { + paramsObject->objectId_ = std::stoi(objectId); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'objectId';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "GetHeapObjectIdParams::Create " << error; + return nullptr; + } + return paramsObject; +} + +std::unique_ptr GetObjectByHeapObjectIdParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + std::string objectId; + ret = params.GetString("objectId", &objectId); + if (ret == Result::SUCCESS) { + paramsObject->objectId_ = std::stoi(objectId); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'objectId';"; + } + + std::string objectGroup; + ret = params.GetString("objectGroup", &objectGroup); + if (ret == Result::SUCCESS) { + paramsObject->objectGroup_ = std::move(objectGroup); + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'objectGroup';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "GetObjectByHeapObjectIdParams::Create " << error; + return nullptr; + } + return paramsObject; +} + +std::unique_ptr StartPreciseCoverageParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + bool callCount = false; + ret = params.GetBool("callCount", &callCount); + if (ret == Result::SUCCESS) { + paramsObject->callCount_ = callCount; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'callCount';"; + } + + bool detailed = false; + ret = params.GetBool("detailed", &detailed); + if (ret == Result::SUCCESS) { + paramsObject->detailed_ = detailed; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'detailed';"; + } + + bool allowTriggeredUpdates = false; + ret = params.GetBool("allowTriggeredUpdates", &allowTriggeredUpdates); + if (ret == Result::SUCCESS) { + paramsObject->allowTriggeredUpdates_ = allowTriggeredUpdates; + } else if (ret == Result::TYPE_ERROR) { // optional value + error += "Unknown 'allowTriggeredUpdates';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "StartPreciseCoverageParams::Create " << error; + return nullptr; + } + return paramsObject; +} + +std::unique_ptr SetSamplingIntervalParams::Create(const PtJson ¶ms) +{ + auto paramsObject = std::make_unique(); + std::string error; + Result ret; + + int32_t interval = 0; + ret = params.GetInt("interval", &interval); + if (ret == Result::SUCCESS) { + paramsObject->interval_ = interval; + } else { + error += "Unknown 'interval';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "SetSamplingIntervalParams::Create " << error; + return nullptr; + } + return paramsObject; +} + +std::unique_ptr RecordClockSyncMarkerParams::Create(const PtJson ¶ms) +{ + std::string error; + auto recordClockSyncMarkerParams = std::make_unique(); + Result ret; + + std::string syncId; + ret = params.GetString("syncId", &syncId); + if (ret == Result::SUCCESS) { + recordClockSyncMarkerParams->syncId_ = syncId; + } else { + error += "Unknown 'syncId';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "RecordClockSyncMarkerParams::Create " << error; + return nullptr; + } + + return recordClockSyncMarkerParams; +} + +std::unique_ptr RequestMemoryDumpParams::Create(const PtJson ¶ms) +{ + std::string error; + auto requestMemoryDumpParams = std::make_unique(); + Result ret; + + bool deterministic = false; + ret = params.GetBool("deterministic", &deterministic); + if (ret == Result::SUCCESS) { + requestMemoryDumpParams->deterministic_ = deterministic; + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'deterministic';"; + } + + std::string levelOfDetail; + ret = params.GetString("levelOfDetail", &levelOfDetail); + if (ret == Result::SUCCESS) { + if (MemoryDumpLevelOfDetailValues::Valid(levelOfDetail)) { + requestMemoryDumpParams->levelOfDetail_ = std::move(levelOfDetail); + } else { + error += "'levelOfDetail' is invalid;"; + } + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'levelOfDetail';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "RequestMemoryDumpParams::Create " << error; + return nullptr; + } + + return requestMemoryDumpParams; +} + +std::unique_ptr StartParams::Create(const PtJson ¶ms) +{ + std::string error; + auto startParams = std::make_unique(); + Result ret; + + std::string categories; + ret = params.GetString("categories", &categories); + if (ret == Result::SUCCESS) { + startParams->categories_ = std::move(categories); + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'categories';"; + } + + std::string options; + ret = params.GetString("options", &options); + if (ret == Result::SUCCESS) { + startParams->options_ = std::move(options); + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'options';"; + } + + int32_t bufferUsageReportingInterval = 0; + ret = params.GetInt("bufferUsageReportingInterval", &bufferUsageReportingInterval); + if (ret == Result::SUCCESS) { + startParams->bufferUsageReportingInterval_ = bufferUsageReportingInterval; + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'bufferUsageReportingInterval';"; + } + + std::string transferMode; + ret = params.GetString("transferMode", &transferMode); + if (ret == Result::SUCCESS) { + if (StartParams::TransferModeValues::Valid(transferMode)) { + startParams->transferMode_ = std::move(transferMode); + } else { + error += "'transferMode' is invalid;"; + } + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'transferMode';"; + } + + std::string streamFormat; + ret = params.GetString("streamFormat", &streamFormat); + if (ret == Result::SUCCESS) { + if (StreamFormatValues::Valid(streamFormat)) { + startParams->streamFormat_ = std::move(streamFormat); + } else { + error += "'streamFormat' is invalid;"; + } + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'streamFormat';"; + } + + std::string streamCompression; + ret = params.GetString("streamCompression", &streamCompression); + if (ret == Result::SUCCESS) { + if (StreamCompressionValues::Valid(streamCompression)) { + startParams->streamCompression_ = std::move(streamCompression); + } else { + error += "'streamCompression' is invalid;"; + } + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'streamCompression';"; + } + + std::unique_ptr traceConfig; + ret = params.GetObject("traceConfig", &traceConfig); + if (ret == Result::SUCCESS) { + std::unique_ptr pTraceConfig = TraceConfig::Create(*traceConfig); + if (pTraceConfig == nullptr) { + error += "'traceConfig' format invalid;"; + } else { + startParams->traceConfig_ = std::move(pTraceConfig); + } + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'traceConfig';"; + } + + std::string perfettoConfig; + ret = params.GetString("perfettoConfig", &perfettoConfig); + if (ret == Result::SUCCESS) { + startParams->perfettoConfig_ = std::move(perfettoConfig); + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'perfettoConfig';"; + } + + std::string tracingBackend; + ret = params.GetString("tracingBackend", &tracingBackend); + if (ret == Result::SUCCESS) { + if (TracingBackendValues::Valid(tracingBackend)) { + startParams->tracingBackend_ = std::move(tracingBackend); + } else { + error += "'tracingBackend' is invalid;"; + } + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'tracingBackend';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "StartParams::Create " << error; + return nullptr; + } + + return startParams; +} +} // namespace panda::ecmascript::tooling diff --git a/tooling/test/debugger_params_test.cpp b/tooling/test/debugger_params_test.cpp index a9d79faa..8f35265a 100644 --- a/tooling/test/debugger_params_test.cpp +++ b/tooling/test/debugger_params_test.cpp @@ -1,477 +1,905 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "base/pt_types.h" -#include "base/pt_params.h" -#include "dispatcher.h" - -#include "ecmascript/js_array.h" -#include "ecmascript/js_object-inl.h" -#include "ecmascript/js_tagged_value-inl.h" -#include "ecmascript/object_factory.h" -#include "ecmascript/tests/test_helper.h" - -using namespace panda::ecmascript; -using namespace panda::ecmascript::tooling; - -namespace panda::test { -// Duplicate name of panda::ecmascript::PropertyDescriptor in js_object-inl.h -using panda::ecmascript::tooling::PropertyDescriptor; - -using ObjectType = RemoteObject::TypeName; -using ObjectSubType = RemoteObject::SubTypeName; -using ObjectClassName = RemoteObject::ClassName; - -class DebuggerParamsTest : public testing::Test { -public: - static void SetUpTestCase() - { - GTEST_LOG_(INFO) << "SetUpTestCase"; - Logger::InitializeStdLogging(Logger::Level::FATAL, LoggerComponentMaskAll); - } - - static void TearDownTestCase() - { - Logger::InitializeStdLogging(Logger::Level::ERROR, LoggerComponentMaskAll); - GTEST_LOG_(INFO) << "TearDownCase"; - } - - void SetUp() override - { - TestHelper::CreateEcmaVMWithScope(ecmaVm, thread, scope); - // Main logic is JSON parser, so not need trigger GC to decrease execute time - ecmaVm->SetEnableForceGC(false); - } - - void TearDown() override - { - TestHelper::DestroyEcmaVMWithScope(ecmaVm, scope); - } - -protected: - EcmaVM *ecmaVm {nullptr}; - EcmaHandleScope *scope {nullptr}; - JSThread *thread {nullptr}; -}; - -HWTEST_F_L0(DebuggerParamsTest, EnableParamsCreateTest) -{ - std::string msg; - std::unique_ptr enableParams; - - // abnormal - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - enableParams = EnableParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(enableParams, nullptr); - EXPECT_FALSE(enableParams->HasMaxScriptsCacheSize()); - - // normal - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"maxScriptsCacheSize":100}})"; - enableParams = EnableParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(enableParams, nullptr); - EXPECT_EQ(enableParams->GetMaxScriptsCacheSize(), 100); -} - -HWTEST_F_L0(DebuggerParamsTest, StartSamplingParamsCreateTest) -{ - std::string msg; - std::unique_ptr startSamplingData; - - // abnormal params of null params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(startSamplingData, nullptr); - EXPECT_EQ(startSamplingData->GetSamplingInterval(), 32768); - - // abnormal params of unknown params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; - startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(startSamplingData, nullptr); - EXPECT_EQ(startSamplingData->GetSamplingInterval(), 32768); - - // abnormal params of params.sub-key=["samplingInterval":true] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":true}})"; - startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(startSamplingData, nullptr); - - // abnormal params of params.sub-key=["samplingInterval":true] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":"Test"}})"; - startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(startSamplingData, nullptr); - - // abnormal params of params.sub-key = [ "size"=100,"nodeId"=1,"ordinal"=10] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":1000}})"; - startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(startSamplingData, nullptr); - EXPECT_EQ(startSamplingData->GetSamplingInterval(), 1000); -} - -HWTEST_F_L0(DebuggerParamsTest, StartTrackingHeapObjectsParamsCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of null params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - ASSERT_FALSE(objectData->GetTrackAllocations()); - - // abnormal params of unknown params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; - objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - ASSERT_FALSE(objectData->GetTrackAllocations()); - - // abnormal params of params.sub-key=["trackAllocations":10] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":10}})"; - objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of params.sub-key=["trackAllocations":"Test"] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":"Test"}})"; - objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of params.sub-key=["trackAllocations":true] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":true}})"; - objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - ASSERT_TRUE(objectData->GetTrackAllocations()); -} - -HWTEST_F_L0(DebuggerParamsTest, StopTrackingHeapObjectsParamsCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of null params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - ASSERT_FALSE(objectData->GetReportProgress()); - ASSERT_FALSE(objectData->GetTreatGlobalObjectsAsRoots()); - ASSERT_FALSE(objectData->GetCaptureNumericValue()); - - // abnormal params of unknown params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; - objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - ASSERT_FALSE(objectData->GetReportProgress()); - ASSERT_FALSE(objectData->GetTreatGlobalObjectsAsRoots()); - ASSERT_FALSE(objectData->GetCaptureNumericValue()); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ - "reportProgress":10, - "treatGlobalObjectsAsRoots":10, - "captureNumericValue":10}})"; - objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ - "reportProgress":"Test", - "treatGlobalObjectsAsRoots":"Test", - "captureNumericValue":"Test"}})"; - objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ - "reportProgress":true, - "treatGlobalObjectsAsRoots":true, - "captureNumericValue":true}})"; - objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - ASSERT_TRUE(objectData->GetReportProgress()); - ASSERT_TRUE(objectData->GetTreatGlobalObjectsAsRoots()); - ASSERT_TRUE(objectData->GetCaptureNumericValue()); -} - -HWTEST_F_L0(DebuggerParamsTest, AddInspectedHeapObjectParamsCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of null msg - msg = std::string() + R"({})"; - objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of unexist key params - msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; - objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of null params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of unknown params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; - objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of params.sub-key=["heapObjectId":10] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":10}})"; - objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of params.sub-key=["heapObjectId":true] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":true}})"; - objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of params.sub-key=["heapObjectId":“10”] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":"10"}})"; - objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - EXPECT_EQ(objectData->GetHeapObjectId(), 10); -} - -HWTEST_F_L0(DebuggerParamsTest, GetHeapObjectIdParamsCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of params.sub-key=["objectId":10] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10}})"; - objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of params.sub-key=["objectId":true] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":true}})"; - objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of params.sub-key=["objectId":“10”] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10"}})"; - objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - EXPECT_EQ((int)objectData->GetObjectId(), 10); -} - -HWTEST_F_L0(DebuggerParamsTest, GetObjectByHeapObjectIdParamsCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of params.sub-key=["objectId":10] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10}})"; - objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of params.sub-key=["objectId":true] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "objectGroup":10}})"; - objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of params.sub-key=["objectId":“10”] - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10"}})"; - objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - EXPECT_EQ((int)objectData->GetObjectId(), 10); - ASSERT_FALSE(objectData->HasObjectGroup()); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "objectGroup":"groupname"}})"; - objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - EXPECT_EQ((int)objectData->GetObjectId(), 10); - EXPECT_EQ(objectData->GetObjectGroup(), "groupname"); -} - -HWTEST_F_L0(DebuggerParamsTest, StartPreciseCoverageParamCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of null params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - // abnormal params of unknown params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; - objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ - "callCount":8, - "detailed":8, - "allowTriggeredUpdates":8}})"; - objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ - "callCount":"Test", - "detailed":"Test", - "allowTriggeredUpdates":"Test"}})"; - objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ - "callCount":true, - "detailed":true, - "allowTriggeredUpdates":true}})"; - objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - ASSERT_TRUE(objectData->GetCallCount()); - ASSERT_TRUE(objectData->GetDetailed()); - ASSERT_TRUE(objectData->GetAllowTriggeredUpdates()); -} - -HWTEST_F_L0(DebuggerParamsTest, SetSamplingIntervalParamsCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of null msg - msg = std::string() + R"({})"; - objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of unexist key params - msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; - objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of null params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of unknown params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; - objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ - "interval":"500"}})"; - objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"interval":500}})"; - objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - EXPECT_EQ(objectData->GetInterval(), 500); -} - -HWTEST_F_L0(DebuggerParamsTest, RecordClockSyncMarkerParamsCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of null msg - msg = std::string() + R"({})"; - objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of unexist key params - msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; - objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of null params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - // abnormal params of unknown params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; - objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); - EXPECT_EQ(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"syncId":"101"}})"; - objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - EXPECT_EQ(objectData->GetSyncId(), "101"); -} - -HWTEST_F_L0(DebuggerParamsTest, RequestMemoryDumpParamsCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of null msg - msg = std::string() + R"({})"; - objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - // abnormal params of unexist key params - msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; - objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - // abnormal params of null params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - // abnormal params of unknown params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; - objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"deterministic":true, - "levelOfDetail":"background"}})"; - objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - ASSERT_TRUE(objectData->GetDeterministic()); - EXPECT_EQ(objectData->GetLevelOfDetail(), "background"); -} - -HWTEST_F_L0(DebuggerParamsTest, StartParamsCreateTest) -{ - std::string msg; - std::unique_ptr objectData; - - // abnormal params of null msg - msg = std::string() + R"({})"; - objectData = StartParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - // abnormal params of unexist key params - msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; - objectData = StartParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - // abnormal params of null params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; - objectData = StartParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - // abnormal params of unknown params.sub-key - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; - objectData = StartParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - - msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"categories":"filter1", - "options":"1", "bufferUsageReportingInterval":11, "transferMode":"ReportEvents", "streamFormat":"json", - "streamCompression":"none", "traceConfig": {"recordMode":"recordUntilFull"}, "perfettoConfig":"categories", - "tracingBackend":"auto"}})"; - objectData = StartParams::Create(DispatchRequest(msg).GetParams()); - ASSERT_NE(objectData, nullptr); - EXPECT_EQ(objectData->GetCategories(), "filter1"); - EXPECT_EQ(objectData->GetOptions(), "1"); - EXPECT_EQ(objectData->GetBufferUsageReportingInterval(), 11); - EXPECT_EQ(objectData->GetTransferMode(), "ReportEvents"); - EXPECT_EQ(objectData->GetStreamFormat(), "json"); - EXPECT_EQ(objectData->GetStreamCompression(), "none"); - TraceConfig *traceConfig = objectData->GetTraceConfig(); - ASSERT_NE(traceConfig, nullptr); - EXPECT_EQ(traceConfig->GetRecordMode(), "recordUntilFull"); - EXPECT_EQ(objectData->GetPerfettoConfig(), "categories"); - EXPECT_EQ(objectData->GetTracingBackend(), "auto"); -} -} // namespace panda::test +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "base/pt_types.h" +#include "base/pt_params.h" +#include "dispatcher.h" + +#include "ecmascript/js_array.h" +#include "ecmascript/js_object-inl.h" +#include "ecmascript/js_tagged_value-inl.h" +#include "ecmascript/object_factory.h" +#include "ecmascript/tests/test_helper.h" + +using namespace panda::ecmascript; +using namespace panda::ecmascript::tooling; + +namespace panda::test { +// Duplicate name of panda::ecmascript::PropertyDescriptor in js_object-inl.h +using panda::ecmascript::tooling::PropertyDescriptor; + +using ObjectType = RemoteObject::TypeName; +using ObjectSubType = RemoteObject::SubTypeName; +using ObjectClassName = RemoteObject::ClassName; + +class DebuggerParamsTest : public testing::Test { +public: + static void SetUpTestCase() + { + GTEST_LOG_(INFO) << "SetUpTestCase"; + Logger::InitializeStdLogging(Logger::Level::FATAL, LoggerComponentMaskAll); + } + + static void TearDownTestCase() + { + Logger::InitializeStdLogging(Logger::Level::ERROR, LoggerComponentMaskAll); + GTEST_LOG_(INFO) << "TearDownCase"; + } + + void SetUp() override + { + TestHelper::CreateEcmaVMWithScope(ecmaVm, thread, scope); + // Main logic is JSON parser, so not need trigger GC to decrease execute time + ecmaVm->SetEnableForceGC(false); + } + + void TearDown() override + { + TestHelper::DestroyEcmaVMWithScope(ecmaVm, scope); + } + +protected: + EcmaVM *ecmaVm {nullptr}; + EcmaHandleScope *scope {nullptr}; + JSThread *thread {nullptr}; +}; + +HWTEST_F_L0(DebuggerParamsTest, EnableParamsCreateTest) +{ + std::string msg; + std::unique_ptr enableParams; + + // abnormal + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + enableParams = EnableParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(enableParams, nullptr); + EXPECT_FALSE(enableParams->HasMaxScriptsCacheSize()); + + // normal + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"maxScriptsCacheSize":100}})"; + enableParams = EnableParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(enableParams, nullptr); + EXPECT_EQ(enableParams->GetMaxScriptsCacheSize(), 100); +} + +HWTEST_F_L0(DebuggerParamsTest, StartSamplingParamsCreateTest) +{ + std::string msg; + std::unique_ptr startSamplingData; + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(startSamplingData, nullptr); + EXPECT_EQ(startSamplingData->GetSamplingInterval(), 32768); + + // abnormal params of unknown params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; + startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(startSamplingData, nullptr); + EXPECT_EQ(startSamplingData->GetSamplingInterval(), 32768); + + // abnormal params of params.sub-key=["samplingInterval":true] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":true}})"; + startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(startSamplingData, nullptr); + + // abnormal params of params.sub-key=["samplingInterval":true] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":"Test"}})"; + startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(startSamplingData, nullptr); + + // abnormal params of params.sub-key = [ "size"=100,"nodeId"=1,"ordinal"=10] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"samplingInterval":1000}})"; + startSamplingData = StartSamplingParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(startSamplingData, nullptr); + EXPECT_EQ(startSamplingData->GetSamplingInterval(), 1000); +} + +HWTEST_F_L0(DebuggerParamsTest, StartTrackingHeapObjectsParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_FALSE(objectData->GetTrackAllocations()); + + // abnormal params of unknown params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; + objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_FALSE(objectData->GetTrackAllocations()); + + // abnormal params of params.sub-key=["trackAllocations":10] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":10}})"; + objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of params.sub-key=["trackAllocations":"Test"] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":"Test"}})"; + objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of params.sub-key=["trackAllocations":true] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"trackAllocations":true}})"; + objectData = StartTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_TRUE(objectData->GetTrackAllocations()); +} + +HWTEST_F_L0(DebuggerParamsTest, StopTrackingHeapObjectsParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_FALSE(objectData->GetReportProgress()); + ASSERT_FALSE(objectData->GetTreatGlobalObjectsAsRoots()); + ASSERT_FALSE(objectData->GetCaptureNumericValue()); + + // abnormal params of unknown params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; + objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_FALSE(objectData->GetReportProgress()); + ASSERT_FALSE(objectData->GetTreatGlobalObjectsAsRoots()); + ASSERT_FALSE(objectData->GetCaptureNumericValue()); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ + "reportProgress":10, + "treatGlobalObjectsAsRoots":10, + "captureNumericValue":10}})"; + objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ + "reportProgress":"Test", + "treatGlobalObjectsAsRoots":"Test", + "captureNumericValue":"Test"}})"; + objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ + "reportProgress":true, + "treatGlobalObjectsAsRoots":true, + "captureNumericValue":true}})"; + objectData = StopTrackingHeapObjectsParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_TRUE(objectData->GetReportProgress()); + ASSERT_TRUE(objectData->GetTreatGlobalObjectsAsRoots()); + ASSERT_TRUE(objectData->GetCaptureNumericValue()); +} + +HWTEST_F_L0(DebuggerParamsTest, AddInspectedHeapObjectParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unknown params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; + objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of params.sub-key=["heapObjectId":10] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":10}})"; + objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of params.sub-key=["heapObjectId":true] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":true}})"; + objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of params.sub-key=["heapObjectId":“10”] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"heapObjectId":"10"}})"; + objectData = AddInspectedHeapObjectParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetHeapObjectId(), 10); +} + +HWTEST_F_L0(DebuggerParamsTest, GetHeapObjectIdParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of params.sub-key=["objectId":10] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10}})"; + objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of params.sub-key=["objectId":true] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":true}})"; + objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of params.sub-key=["objectId":“10”] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10"}})"; + objectData = GetHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ((int)objectData->GetObjectId(), 10); +} + +HWTEST_F_L0(DebuggerParamsTest, GetObjectByHeapObjectIdParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of params.sub-key=["objectId":10] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10}})"; + objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of params.sub-key=["objectId":true] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "objectGroup":10}})"; + objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of params.sub-key=["objectId":“10”] + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10"}})"; + objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ((int)objectData->GetObjectId(), 10); + ASSERT_FALSE(objectData->HasObjectGroup()); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "objectGroup":"groupname"}})"; + objectData = GetObjectByHeapObjectIdParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ((int)objectData->GetObjectId(), 10); + EXPECT_EQ(objectData->GetObjectGroup(), "groupname"); +} + +HWTEST_F_L0(DebuggerParamsTest, StartPreciseCoverageParamCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + // abnormal params of unknown params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; + objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ + "callCount":8, + "detailed":8, + "allowTriggeredUpdates":8}})"; + objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ + "callCount":"Test", + "detailed":"Test", + "allowTriggeredUpdates":"Test"}})"; + objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ + "callCount":true, + "detailed":true, + "allowTriggeredUpdates":true}})"; + objectData = StartPreciseCoverageParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_TRUE(objectData->GetCallCount()); + ASSERT_TRUE(objectData->GetDetailed()); + ASSERT_TRUE(objectData->GetAllowTriggeredUpdates()); +} + +HWTEST_F_L0(DebuggerParamsTest, SetSamplingIntervalParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unknown params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; + objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{ + "interval":"500"}})"; + objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"interval":500}})"; + objectData = SetSamplingIntervalParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetInterval(), 500); +} + +HWTEST_F_L0(DebuggerParamsTest, RecordClockSyncMarkerParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unknown params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; + objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"syncId":"101"}})"; + objectData = RecordClockSyncMarkerParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetSyncId(), "101"); +} + +HWTEST_F_L0(DebuggerParamsTest, RequestMemoryDumpParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + // abnormal params of unknown params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; + objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"deterministic":true, + "levelOfDetail":"background"}})"; + objectData = RequestMemoryDumpParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_TRUE(objectData->GetDeterministic()); + EXPECT_EQ(objectData->GetLevelOfDetail(), "background"); +} + +HWTEST_F_L0(DebuggerParamsTest, StartParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = StartParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = StartParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = StartParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + // abnormal params of unknown params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"unknownKey":100}})"; + objectData = StartParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"categories":"filter1", + "options":"1", "bufferUsageReportingInterval":11, "transferMode":"ReportEvents", "streamFormat":"json", + "streamCompression":"none", "traceConfig": {"recordMode":"recordUntilFull"}, "perfettoConfig":"categories", + "tracingBackend":"auto"}})"; + objectData = StartParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetCategories(), "filter1"); + EXPECT_EQ(objectData->GetOptions(), "1"); + EXPECT_EQ(objectData->GetBufferUsageReportingInterval(), 11); + EXPECT_EQ(objectData->GetTransferMode(), "ReportEvents"); + EXPECT_EQ(objectData->GetStreamFormat(), "json"); + EXPECT_EQ(objectData->GetStreamCompression(), "none"); + TraceConfig *traceConfig = objectData->GetTraceConfig(); + ASSERT_NE(traceConfig, nullptr); + EXPECT_EQ(traceConfig->GetRecordMode(), "recordUntilFull"); + EXPECT_EQ(objectData->GetPerfettoConfig(), "categories"); + EXPECT_EQ(objectData->GetTracingBackend(), "auto"); +} + +HWTEST_F_L0(DebuggerParamsTest, EvaluateOnCallFrameParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"callFrameId":1, "expression":true, + "objectGroup":1, "includeCommandLineAPI":"true", "silent":"true", "returnByValue":"true", + "generatePreview":"true", "throwOnSideEffect":"true", "timeout":"10"}})"; + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"callFrameId":"1", "expression":"test", + "objectGroup":"testGroup", "includeCommandLineAPI":true, "silent":true, "returnByValue":true, + "generatePreview":true, "throwOnSideEffect":true, "timeout":10}})"; + objectData = EvaluateOnCallFrameParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetCallFrameId(), 1); + EXPECT_EQ(objectData->GetExpression(), "test"); +} + +HWTEST_F_L0(DebuggerParamsTest, GetPossibleBreakpointsParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"start":10, "end":10, + "restrictToFunction":"true"}})"; + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"start":{"scriptId":"1", "lineNumber":1, + "columnNumber":10}, "end":{"scriptId":"1", "lineNumber":10, "columnNumber":10}, "restrictToFunction":true}})"; + objectData = GetPossibleBreakpointsParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + Location *start = objectData->GetStart(); + Location *end = objectData->GetEnd(); + EXPECT_EQ(start->GetScriptId(), 1); + EXPECT_EQ(start->GetLine(), 1); + EXPECT_EQ(start->GetColumn(), 10); + EXPECT_EQ(end->GetScriptId(), 1); + EXPECT_EQ(end->GetLine(), 10); + EXPECT_EQ(end->GetColumn(), 10); + ASSERT_TRUE(objectData->GetRestrictToFunction()); +} + +HWTEST_F_L0(DebuggerParamsTest, GetScriptSourceParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"scriptId":10}})"; + objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"scriptId":"10"}})"; + objectData = GetScriptSourceParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetScriptId(), 10); +} + +HWTEST_F_L0(DebuggerParamsTest, RemoveBreakpointParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakpointId":10}})"; + objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakpointId":"10"}})"; + objectData = RemoveBreakpointParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetBreakpointId(), "10"); +} + +HWTEST_F_L0(DebuggerParamsTest, ResumeParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"terminateOnResume":10}})"; + objectData = ResumeParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"terminateOnResume":true}})"; + objectData = ResumeParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_TRUE(objectData->GetTerminateOnResume()); +} + +HWTEST_F_L0(DebuggerParamsTest, SetAsyncCallStackDepthParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"maxDepth":true}})"; + objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"maxDepth":5}})"; + objectData = SetAsyncCallStackDepthParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetMaxDepth(), 5); +} + +HWTEST_F_L0(DebuggerParamsTest, SetBlackboxPatternsParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"patterns":"testpattern"}})"; + objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"patterns":["testpattern1", "testpattern2"]}})"; + objectData = SetBlackboxPatternsParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + std::list patterns = objectData->GetPatterns(); + EXPECT_EQ(patterns.size(), 2U); +} + +HWTEST_F_L0(DebuggerParamsTest, SetBreakpointByUrlParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"lineNumber":"10", "url":10, + "urlRegex":true, "scriptHash":true, "columnNumber":"10", "condition":10}})"; + objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"lineNumber":10, "url":"testURL", + "urlRegex":"testURLRegex", "scriptHash":"testScriptHash", "columnNumber":10, "condition":"testCondition"}})"; + objectData = SetBreakpointByUrlParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetLine(), 10); + EXPECT_EQ(objectData->GetUrl(), "testURL"); + EXPECT_EQ(objectData->GetUrlRegex(), "testURLRegex"); + EXPECT_EQ(objectData->GetScriptHash(), "testScriptHash"); + EXPECT_EQ(objectData->GetColumn(), 10); + EXPECT_EQ(objectData->GetCondition(), "testCondition"); +} + +HWTEST_F_L0(DebuggerParamsTest, SetPauseOnExceptionsParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"state":10}})"; + objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"state":"none"}})"; + objectData = SetPauseOnExceptionsParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetState(), PauseOnExceptionsState::NONE); +} + +HWTEST_F_L0(DebuggerParamsTest, StepIntoParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakOnAsyncCall":10, "skipList":true}})"; + objectData = StepIntoParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"breakOnAsyncCall":true, + "skipList":[{"scriptId":"1", "start":{"lineNumber":1, "columnNumber":10}, "end":{"lineNumber":2, + "columnNumber":20}}, {"scriptId":"2", "start":{"lineNumber":3, "columnNumber":30}, "end":{"lineNumber":4, + "columnNumber":40}}]}})"; + objectData = StepIntoParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_TRUE(objectData->GetBreakOnAsyncCall()); + const std::list> *locationRangeList = objectData->GetSkipList(); + EXPECT_EQ(locationRangeList->size(), 2U); +} + + +HWTEST_F_L0(DebuggerParamsTest, StepOverParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"skipList":true}})"; + objectData = StepOverParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"skipList":[{"scriptId":"1", + "start":{"lineNumber":1, "columnNumber":10}, "end":{"lineNumber":2, "columnNumber":20}}, {"scriptId":"2", + "start":{"lineNumber":3, "columnNumber":30}, "end":{"lineNumber":4, "columnNumber":40}}]}})"; + objectData = StepOverParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + const std::list> *locationRangeList = objectData->GetSkipList(); + EXPECT_EQ(locationRangeList->size(), 2U); +} + +HWTEST_F_L0(DebuggerParamsTest, SetMixedDebugParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"enabled":"test"}})"; + objectData = SetMixedDebugParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"enabled":true}})"; + objectData = SetMixedDebugParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_TRUE(objectData->GetEnabled()); +} + +HWTEST_F_L0(DebuggerParamsTest, ReplyNativeCallingParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"userCode":"test"}})"; + objectData = ReplyNativeCallingParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"userCode":true}})"; + objectData = ReplyNativeCallingParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + ASSERT_TRUE(objectData->GetUserCode()); +} + +HWTEST_F_L0(DebuggerParamsTest, GetPropertiesParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":10, "ownProperties":1, + "accessorPropertiesOnly":2, "generatePreview":3}})"; + objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"objectId":"10", "ownProperties":true, + "accessorPropertiesOnly":true, "generatePreview":true}})"; + objectData = GetPropertiesParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetObjectId(), 10); + ASSERT_TRUE(objectData->GetOwnProperties()); + ASSERT_TRUE(objectData->GetAccessPropertiesOnly()); + ASSERT_TRUE(objectData->GetGeneratePreview()); +} + +HWTEST_F_L0(DebuggerParamsTest, CallFunctionOnParamsCreateTest) +{ + std::string msg; + std::unique_ptr objectData; + + // abnormal params of null msg + msg = std::string() + R"({})"; + objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of unexist key params + msg = std::string() + R"({"id":0,"method":"Debugger.Test"})"; + objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + // abnormal params of null params.sub-key + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{}})"; + objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"functionDeclaration":true, "objectId":1, + "arguments":[{"unserializableValue":1, "objectId":10}, {"unserializableValue":2, "objectId":20}], + "silent":"true", "returnByValue":"true", "generatePreview":"true", "userGesture":"true", "awaitPromise":"true", + "executionContextId":"1", "objectGroup":2, "throwOnSideEffect":"true"}})"; + objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams()); + EXPECT_EQ(objectData, nullptr); + + msg = std::string() + R"({"id":0,"method":"Debugger.Test","params":{"functionDeclaration":"testFunction", + "objectId":"1", "arguments":[{"unserializableValue":"testValue1", "objectId":"10"}, + {"unserializableValue":"testValue2", "objectId":"20"}], "silent":true, "returnByValue":true, + "generatePreview":true, "userGesture":true, "awaitPromise":true, "executionContextId":1, + "objectGroup":"testGrp", "throwOnSideEffect":true}})"; + objectData = CallFunctionOnParams::Create(DispatchRequest(msg).GetParams()); + ASSERT_NE(objectData, nullptr); + EXPECT_EQ(objectData->GetFunctionDeclaration(), "testFunction"); + EXPECT_EQ(objectData->GetObjectId(), 1); + const std::vector> *callArgument = objectData->GetArguments(); + EXPECT_EQ(callArgument->size(), 2U); + ASSERT_TRUE(objectData->GetSilent()); + ASSERT_TRUE(objectData->GetReturnByValue()); + ASSERT_TRUE(objectData->GetGeneratePreview()); + ASSERT_TRUE(objectData->GetUserGesture()); + ASSERT_TRUE(objectData->GetAwaitPromise()); + EXPECT_EQ(objectData->GetExecutionContextId(), 1); + EXPECT_EQ(objectData->GetObjectGroup(), "testGrp"); + ASSERT_TRUE(objectData->GetThrowOnSideEffect()); +} +} // namespace panda::test -- Gitee