Merge pull request #6806 from remix-project-org/debugger_unittests

Debugger unittests

Author: yann300

libs/remix-debug/src/solidity-decoder/helpers/callTreeHelper.ts

@@ -40,7 +40,7 @@ export function isConstructorExit (tree, step, scopeId, initialEntrystackIndex,
     return false
   }
   // Check if stack has returned to entry depth (or below, in case of cleanup)
-  if (initialEntrystackIndex !== undefined && stepDetail.stack.length <= initialEntrystackIndex) {
+  if (initialEntrystackIndex && stepDetail.stack.length <= initialEntrystackIndex) {
     console.log('Exiting constructor scope ', scopeId, ' at step ', step)
     return true
   }

libs/remix-debug/src/solidity-decoder/internalCallTree.ts

@@ -775,7 +775,7 @@ async function buildTree (tree: InternalCallTree, step, scopeId, isCreation, fun
 
     // Update symbolic stack based on opcode execution
     const previousSymbolicStack = tree.symbolicStackManager.getStackAtStep(step)
-    if (stepDetail.stack.length !== previousSymbolicStack.length) {
+    if (tree.debug && stepDetail.stack.length !== previousSymbolicStack.length) {
       console.warn('STACK SIZE MISMATCH at step ', step, ' opcode ', stepDetail.op, ' symbolic stack size ', previousSymbolicStack.length, ' actual stack size ', stepDetail.stack.length )
     }
 
@@ -810,7 +810,7 @@ async function buildTree (tree: InternalCallTree, step, scopeId, isCreation, fun
       try {
         previousSourceLocation = null
         const newScopeId = scopeId === '' ? subScope.toString() : scopeId + '.' + subScope
-        console.log('Entering new scope at step ', step, newScopeId, isInternalTxInstrn, internalfunctionCall)
+        if (tree.debug) console.log('Entering new scope at step ', step, newScopeId, isInternalTxInstrn, internalfunctionCall)
         tree.scopeStarts[step] = newScopeId
         const startExecutionLine = lineColumnPos && lineColumnPos.start ? lineColumnPos.start.line + 1 : undefined
         tree.scopes[newScopeId] = { firstStep: step, locals: {}, isCreation, gasCost: 0, startExecutionLine, functionDefinition: null, opcodeInfo: stepDetail, stackBeforeJumping: newSymbolicStack, lowLevelScope: true }

libs/remix-debug/test/decoder/localsTests/parameterTypes.ts

@@ -0,0 +1,272 @@
+'use strict'
+import { NestedScope } from '@remix-project/remix-debug'
+import * as helper from './helper'
+const { ethers } = require('ethers')
+
+module.exports = async function (st, privateKey, contractBytecode, compilationResult, contractCode) {
+  st.plan(26)
+  const enableCtorTest = false
+  // Test scenarios with expected parameter values
+  const testCases = [
+    {
+      name: 'directCall',
+      signature: 'directCall(uint256,string)',
+      params: [123, 'DirectTest'],
+      description: 'Direct function call parameters'
+    },
+    {
+      name: 'internalCallTest',
+      signature: 'internalCallTest(uint256,string)',
+      params: [456, 'InternalTest'],
+      description: 'Internal call parameters'
+    },
+    {
+      name: 'thisCallTest',
+      signature: 'thisCallTest(uint256,string)',
+      params: [789, 'ThisTest'],
+      description: 'This.function() call parameters'
+    },
+    {
+      name: 'callTest',
+      signature: 'callTest(uint256,string)',
+      params: [111, 'CallTest'],
+      description: 'CALL operation parameters'
+    },
+    {
+      name: 'staticCallTest',
+      signature: 'staticCallTest(uint256,string)',
+      params: [222, 'StaticTest'],
+      description: 'STATICCALL operation parameters'
+    },
+    {
+      name: 'delegateCallTest',
+      signature: 'delegateCallTest(uint256,string)',
+      params: [333, 'DelegateTest'],
+      description: 'DELEGATECALL operation parameters'
+    },
+    {
+      name: 'createTest',
+      signature: 'createTest(uint256,string)',
+      params: [444, 'CreateTest'],
+      description: 'CREATE operation parameters'
+    },
+    {
+      name: 'create2Test',
+      signature: 'create2Test(uint256,string,bytes32)',
+      params: [555, 'Create2Test', '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'],
+      description: 'CREATE2 operation parameters'
+    }
+  ]
+
+  // Helper function to encode parameters
+  function encodeParams(signature: string, params: any[]): string {
+    // Use ethers interface to encode function call
+    const iface = new ethers.Interface([`function ${signature}`])
+    const functionName = signature.split('(')[0]
+    return iface.encodeFunctionData(functionName, params)
+  }
+
+  // Helper function to find scope by function name and get its firstStep
+  function findFunctionScope(nestedScopes: NestedScope[], functionName: string): { scope: NestedScope, firstStep: number } | null {
+    let foundDuplicate = false // TODO this needs to be fixed, there are always 2 nodes for a single function call
+    function traverse(scope: NestedScope, parentFirstStep?: number): { scope: NestedScope, firstStep: number } | null {
+      // Check if this scope matches our function
+      if (scope.functionDefinition?.name === functionName || scope.functionDefinition?.kind === functionName) {
+        const firstStep = scope.firstStep || parentFirstStep || 0
+        return { scope, firstStep }
+      }
+
+      // Look for nested function calls within this scope
+      if (scope.children) {
+        for (const child of scope.children) {
+          const result = traverse(child, scope.firstStep || parentFirstStep)
+          if (result && foundDuplicate) return result
+          if (result) foundDuplicate = true
+        }
+      }
+
+      return null
+    }
+
+    for (const rootScope of nestedScopes) {
+      const result = traverse(rootScope)
+      if (result) return result
+    }
+
+    return null
+  }
+
+  try {
+    if (enableCtorTest) {
+      // First deploy the contract (constructor with inheritance test)
+      console.log('Deploying contract with constructor parameters...')
+      const constructorParams = [42, 'ConstructorTest']
+      const constructorData = ethers.AbiCoder.defaultAbiCoder().encode(['uint256', 'string'], constructorParams)
+      const deployBytecode = contractBytecode + constructorData.slice(2) // Remove 0x prefix
+
+      const { traceManager: deployTraceManager, callTree: deployCallTree, waitForCallTree: waitForDeployCallTree } =
+        await helper.setupDebugger(privateKey, deployBytecode, compilationResult, contractCode)
+
+      const { scopes: deployScopes, scopeStarts: deployScopeStarts } = await waitForDeployCallTree()
+      const deployNestedScopes: NestedScope[] = deployCallTree.getScopesAsNestedJSON()
+
+      console.log(deployNestedScopes)
+
+      // Test inherited constructor parameters
+      const baseConstructorScope = findFunctionScope(deployNestedScopes, 'constructor')
+      if (baseConstructorScope) {
+        console.log(`Testing constructor parameters at step ${baseConstructorScope.firstStep}`)
+
+        const symbolicStack = deployCallTree.getSymbolicStackAtStep(baseConstructorScope.firstStep)
+        console.log('Constructor symbolic stack:', symbolicStack)
+
+        await helper.decodeLocals(st, baseConstructorScope.firstStep + 1, deployTraceManager, deployCallTree, (locals) => {
+          console.log('Constructor locals:', Object.keys(locals))
+
+          // Look for constructor parameters
+          if (locals['_constructorValue']) {
+            st.equals(locals['_constructorValue'].value, '42', 'Constructor uint parameter should be decoded correctly')
+          }
+          if (locals['_constructorMessage']) {
+            st.equals(locals['_constructorMessage'].value, 'ConstructorTest', 'Constructor string parameter should be decoded correctly')
+          }
+
+          // Also check inherited constructor parameters
+          if (locals['_baseValue']) {
+            st.equals(locals['_baseValue'].value, '52', 'Base constructor uint parameter should be decoded correctly (42 + 10)')
+          }
+          if (locals['_baseMessage']) {
+            st.equals(locals['_baseMessage'].value, 'Base: ConstructorTest', 'Base constructor string parameter should be decoded correctly')
+          }
+
+          st.ok(Object.keys(locals).length > 0, 'Constructor should have decoded local variables')
+        })
+      } else {
+        st.fail('Could not find constructor scope for parameter testing')
+      }
+    }
+
+    // Now test each function call scenario
+    for (const testCase of testCases) {
+      console.log(`\nTesting ${testCase.name}: ${testCase.description}`)
+
+      const txData = encodeParams(testCase.signature, testCase.params)
+      console.log(`Transaction data for ${testCase.name}: ${txData}`)
+
+      const constructorParams = [42, 'ConstructorTest']
+      const constructorData = ethers.AbiCoder.defaultAbiCoder().encode(['uint256', 'string'], constructorParams)
+      const deployBytecode = contractBytecode + constructorData.slice(2) // Remove 0x prefix
+      const { traceManager, callTree, waitForCallTree } = await helper.setupDebugger(
+        privateKey,
+        deployBytecode,
+        compilationResult,
+        contractCode,
+        txData
+      )
+
+      const { scopes, scopeStarts } = await waitForCallTree()
+      const nestedScopes: NestedScope[] = callTree.getScopesAsNestedJSON()
+
+      // Find the target function scope
+      const functionScope = findFunctionScope(nestedScopes, testCase.name)
+
+      if (functionScope) {
+        console.log(`Found ${testCase.name} scope with firstStep: ${functionScope.firstStep}`)
+
+        // Get symbolic stack at the first step of this function
+        const symbolicStack = callTree.getSymbolicStackAtStep(functionScope.firstStep)
+        // console.log(`Symbolic stack for ${testCase.name}:`, symbolicStack)
+
+        // Decode locals at this step
+        await helper.decodeLocals(st, functionScope.firstStep + 3, traceManager, callTree, (locals) => {
+          console.log(`${testCase.name} locals:`, locals)
+
+          // Verify parameter decoding based on function signature
+          if (testCase.signature.includes('uint256')) {
+            const uintParamNames = ['_directValue', '_testValue', '_thisValue', '_callValue', '_staticValue', '_delegateValue', '_createValue', '_create2Value']
+            const expectedUintParam = uintParamNames.find(name => locals[name])
+
+            if (expectedUintParam) {
+              st.equals(locals[expectedUintParam].value, testCase.params[0].toString(),
+                `${testCase.name}: uint parameter should be decoded correctly`)
+            } else {
+              // Try alternative parameter names
+              const allUintKeys = Object.keys(locals).filter(key =>
+                key.includes('Value') || key.includes('value') || locals[key].type?.includes('uint'))
+              if (allUintKeys.length > 0) {
+                st.ok(true, `${testCase.name}: Found potential uint parameter: ${allUintKeys[0]}`)
+              } else {
+                st.fail(`${testCase.name}: Could not find uint parameter in locals`)
+              }
+            }
+          }
+
+          if (testCase.signature.includes('string')) {
+            const stringParamNames = ['_directMessage', '_testMessage', '_thisMessage', '_callMessage', '_staticMessage', '_delegateMessage', '_createMessage', '_create2Message']
+            const expectedStringParam = stringParamNames.find(name => locals[name])
+
+            if (expectedStringParam) {
+              st.equals(locals[expectedStringParam].value, testCase.params[1],
+                `${testCase.name}: string parameter should be decoded correctly`)
+            } else {
+              // Try alternative parameter names
+              const allStringKeys = Object.keys(locals).filter(key =>
+                key.includes('Message') || key.includes('message') || locals[key].type?.includes('string'))
+              if (allStringKeys.length > 0) {
+                st.ok(true, `${testCase.name}: Found potential string parameter: ${allStringKeys[0]}`)
+              } else {
+                st.fail(`${testCase.name}: Could not find string parameter in locals`)
+              }
+            }
+          }
+
+          st.ok(Object.keys(locals).length > 0, `${testCase.name}: Should have decoded local variables`)
+        })
+
+        // Additional tests for internal function calls
+        if (testCase.name === 'internalCallTest') {
+          // Also check the internal function that gets called
+          const internalScope = findFunctionScope(nestedScopes, '_internalFunction')
+          if (internalScope) {
+            console.log(`Found _internalFunction scope with firstStep: ${internalScope.firstStep}`)
+            await helper.decodeLocals(st, internalScope.firstStep + 2, traceManager, callTree, (locals) => {
+              console.log('_internalFunction locals:', Object.keys(locals))
+
+              if (locals['_internalValue']) {
+                st.equals(locals['_internalValue'].value, '506', 'Internal function uint parameter should be decoded correctly (456 + 50)')
+              }
+              if (locals['_internalMessage']) {
+                st.ok(locals['_internalMessage'].value.includes('Internal:'), 'Internal function string parameter should be decoded correctly')
+              }
+            })
+          }
+        }
+
+        // For external calls via this.function(), check the target function too
+        if (testCase.name === 'thisCallTest') {
+          const externalScope = findFunctionScope(nestedScopes, 'externalCallViaThis')
+          if (externalScope) {
+            console.log(`Found externalCallViaThis scope with firstStep: ${externalScope.firstStep}`)
+            await helper.decodeLocals(st, externalScope.firstStep + 2, traceManager, callTree, (locals) => {
+              console.log('externalCallViaThis locals:', Object.keys(locals))
+
+              if (locals['_externalValue']) {
+                st.equals(locals['_externalValue'].value, '814', 'External function uint parameter should be decoded correctly (789 + 25)')
+              }
+              if (locals['_externalMessage']) {
+                st.ok(locals['_externalMessage'].value.includes('This:'), 'External function string parameter should be decoded correctly')
+              }
+            })
+          }
+        }
+
+      } else {
+        st.fail(`Could not find scope for function ${testCase.name}`)
+      }
+    }
+
+  } catch (error) {
+    console.error('Test error:', error)
+    st.fail(error.message || error)
+  }
+}