Function generateHardhatTestForFunction

src/code-gen/test/hardhat.ts:118–206

(
  struct: ProcessedStruct,
  fn: CodeGenFunction,
  libraryName: string
)

]);

export function generateHardhatTestForFunction(
  struct: ProcessedStruct,
  fn: CodeGenFunction,
  libraryName: string
) {
  const contractName = `external${libraryName}`;
  const testCode: ArrayJoinInput<string>[] = [];
  const generateCall = (args: string[]) => _generateCall(contractName, fn, args)
  const getOverflowTest = (args: string[], field: ProcessedField) => _getOverflowTest(contractName, fn, args, field)
  const getUnderflowTest = (args: string[], field: ProcessedField) => _getUnderflowTest(contractName, fn, args, field)
  
  const fields = fn.internalType === 'getter' ? fn.outputFields : fn.inputFields;
  const {minValues, maxValues} = getMinMaxValues(fields)

  const minMax = minValues.map((f, i) => i % 2 ? minValues[i] : maxValues[i]);
  const maxMin = minValues.map((f, i) => i % 2 ? maxValues[i] : minValues[i]);
  if (fn.internalType === 'setter') {
    for (let i = 0; i < fields.length; i++) {
      const inputs = [...minValues];
      const field = fields[i];
      if (shouldCheckForOverflow(field)) {
        inputs[i] = getFieldValue(field, 'overflow');
        testCode.push(getOverflowTest(inputs, field), '')
        if (field.type.meta === 'elementary' && field.type.type === 'int') {
          inputs[i] = getFieldValue(field, 'underflow');
          testCode.push(getUnderflowTest(inputs, field), '')
        }
      }
    }
    const getGetter = _env.findGetterOrSetterForFields(struct, fields, fn, contractName, 'getter');
    if (!getGetter) {
      console.log(`Could not find way to get all fields updated by ${fn.name}`)
      return undefined;
    }
    const getterCode = getGetter();
    const testSetMinMax = getSetterTest(
      `Should be able to set ${fields.length === 1 ? 'min value' : 'min/max values'}`,
      fields,
      [generateCall(minMax)],
      getterCode,
      minMax
    )
    testCode.push(testSetMinMax, '')
    const testSetMaxMin = getSetterTest(
      `Should be able to set ${fields.length === 1 ? 'max value' : 'max/min values'}`,
      fields,
      [generateCall(maxMin)],
      getterCode,
      maxMin
    )
    testCode.push(testSetMaxMin, '')
  } else {
    const destructuredDecodeParams = fn.outputFields.length > 1
      ? `{ ${fn.outputFields.map(f => f.name).join(", ")} }`
      : `${fn.outputFields[0].name}`
    const getterCode = [`const ${destructuredDecodeParams} = await ${contractName}.${fn.name}()`]

    const getSetter = _env.findGetterOrSetterForFields(struct, fields, fn, contractName, 'setter');