[ { "path": ".boilerplate.txt", "content": "// TEST MOCKERY BOILERPLATE" }, { "path": ".gitattributes", "content": "* text eol=lf\n*.png -text\n*.gif -text\n" }, { "path": ".github/ISSUE_TEMPLATE/bug_report.md", "content": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n## Description\n\nA clear and concise description of what the bug is.\n\n## Reproducer\n\nSteps to reproduce the behavior.\n\n## Expected behavior\n\nA clear and concise description of what you expected to happen.\n\n## Mockery version\n\n`vX.Y.Z`\n\n## Installation Mechanism\n\n- [ ] `go get`\n- [ ] Pre-built release\n- [ ] homebrew\n- [ ] Other: [please describe]\n\n## Go version\n\nVersion of Go used to build mockery from source (if applicable).\n" }, { "path": ".github/PULL_REQUEST_TEMPLATE.md", "content": "Description\n-------------\n\nPlease include a summary of the changes and the related issue. Please also include relevant motivation and context.\n\n- Fixes # (issue)\n\n## Type of change\n\n- [ ] Bug fix (non-breaking change which fixes an issue)\n- [ ] New feature (non-breaking change which adds functionality)\n- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)\n- [ ] This change requires a documentation update\n\nVersion of Go used when building/testing:\n---------------------------------------------\n\n- [ ] 1.22\n- [ ] 1.23\n\nHow Has This Been Tested?\n---------------------------\n\nPlease describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration\n\nChecklist\n-----------\n\n- [ ] My code follows the style guidelines of this project\n- [ ] I have performed a self-review of my code\n- [ ] I have commented my code, particularly in hard-to-understand areas\n- [ ] I have made corresponding changes to the documentation\n- [ ] My changes generate no new warnings\n- [ ] I have added tests that prove my fix is effective or that my feature works\n- [ ] New and existing unit tests pass locally with my changes\n" }, { "path": ".github/workflows/documentation.yml", "content": "name: documentation\non:\n push:\n branches: [ master, v3 ]\npermissions:\n contents: write\njobs:\n deploy:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v3\n - uses: actions/setup-python@v4\n with:\n python-version: 3.x\n - uses: actions/cache@v4\n with:\n key: v3-documentation-${{ runner.os }}-${{ steps.get-date.outputs.date }}\n path: .cache\n - run: sudo apt-get update && sudo apt-get install -y libcairo2-dev libfreetype6-dev libffi-dev libjpeg-dev libpng-dev libz-dev\n - run: pip install -r docs/requirements.txt\n env:\n GH_TOKEN: ${{ secrets.GH_TOKEN }}\n - name: Setup doc deploy\n run: |\n git config --global user.name vektra-bot\n git config --global user.email vektra-bot@vektra.github.io\n git fetch origin gh-pages --depth=1\n - name: Deploy docs\n run: \"mike deploy --push --update-aliases $(grep VERSION mockery-tools.env | cut -d'=' -f 2 | cut -d'.' -f1-2) latest latest-v3\"\n env:\n GOOGLE_ANALYTICS_KEY: ${{ secrets.GOOGLE_ANALYTICS_KEY }}\n" }, { "path": ".github/workflows/release.yml", "content": "name: \"release\"\n\non:\n workflow_dispatch:\n inputs:\n tag:\n description: \"Tag to release\"\n type: string\n required: true\n\n workflow_call:\n inputs:\n tag:\n description: \"Tag to release\"\n type: string\n required: true\n secrets:\n DOCKER_USERNAME:\n required: true\n DOCKER_PASSWORD:\n required: true\n GORELEASER_GITHUB_TOKEN:\n required: true\n GORELEASER_HOMEBREW_TAP_TOKEN:\n required: true\n\npermissions:\n contents: write\n\njobs:\n release:\n runs-on: ubuntu-latest\n env:\n DOCKER_CLI_EXPERIMENTAL: \"enabled\"\n\n steps:\n - uses: actions/checkout@v4\n with:\n fetch-depth: 0\n ref: refs/tags/${{ inputs.tag }}\n\n - name: Set up Go\n uses: actions/setup-go@v4\n with:\n go-version: 'stable'\n\n - name: Set up QEMU\n uses: docker/setup-qemu-action@v2\n\n - name: Set up Docker Buildx\n uses: docker/setup-buildx-action@v2\n\n - name: Login to DockerHub\n uses: docker/login-action@v1\n with:\n username: ${{ secrets.DOCKER_USERNAME }}\n password: ${{ secrets.DOCKER_PASSWORD }}\n\n - name: GoReleaser\n uses: goreleaser/goreleaser-action@v2.7.0\n with:\n args: release --clean\n version: \"<2\"\n env:\n GITHUB_TOKEN: ${{ secrets.GORELEASER_GITHUB_TOKEN }}\n HOMEBREW_TAP_TOKEN: ${{ secrets.GORELEASER_HOMEBREW_TAP_TOKEN }}\n GORELEASER_CURRENT_TAG: ${{ inputs.tag }}\n" }, { "path": ".github/workflows/reusable-testing.yml", "content": "name: Reusable Go Test\n\non:\n workflow_call:\n inputs:\n ref:\n required: false\n type: string\n default: \"\"\n\njobs:\n test:\n runs-on: ${{ matrix.os }}\n strategy:\n matrix:\n os: [\"macos-latest\", \"ubuntu-latest\", \"windows-latest\"]\n go_vers: [\"1.25\", \"1.26\"]\n steps:\n - uses: actions/checkout@v2\n with:\n fetch-depth: 0\n ref: ${{ inputs.ref }}\n\n - name: Set up Go\n uses: actions/setup-go@v2\n with:\n go-version: ${{ matrix.go_vers }}\n\n - name: Download dependencies\n run: go mod download -x\n\n - name: Test\n run: go run github.com/go-task/task/v3/cmd/task test.ci\n" }, { "path": ".github/workflows/tag-and-release.yml", "content": "name: Test and maybe create a new release\n\non:\n push:\n branches: [master, v3]\npermissions:\n contents: write\njobs:\n test:\n uses: ./.github/workflows/reusable-testing.yml\n tag:\n runs-on: ubuntu-latest\n needs: test\n outputs:\n tag_result: ${{ steps.tag.outputs.tag_result }}\n requested_version: ${{ steps.tag.outputs.requested_version }}\n previous_version: ${{ steps.tag.outputs.previous_version }}\n steps:\n - run: sudo apt update && sudo apt install -y git && git --version\n - uses: actions/checkout@v2\n with:\n # We need entire history of tags\n fetch-depth: 0\n\n - name: Set up Go\n uses: actions/setup-go@v5\n with:\n go-version-file: ./tools/go.mod\n check-latest: true\n cache-dependency-path: \"**/*.sum\"\n\n - name: Install Task\n uses: arduino/setup-task@v2\n with:\n version: 3.x\n repo-token: ${{ secrets.GITHUB_TOKEN }}\n\n - name: Run tagging commands\n id: tag\n run: |\n set +e\n task -x tag 1>/tmp/versions.txt\n tag_result=\"$?\"\n\n printf \"versions: $(cat /tmp/versions.txt)\\n\"\n echo \"requested_version=$(cut -d',' -f 1 /tmp/versions.txt)\" >> $GITHUB_OUTPUT\n echo \"previous_version=$(cut -d',' -f 2 /tmp/versions.txt)\" >> $GITHUB_OUTPUT\n\n echo \"tag_result=$tag_result\" >> $GITHUB_OUTPUT\n # The range between 8 and 63 inclusive is reserved for custom\n # error codes that contain specific meaning.\n if [ $tag_result -lt 8 -o $tag_result -gt 63 ]; then\n exit $tag_result\n fi\n exit 0\n - name: Push tags\n run: task tag.push\n if: steps.tag.outputs.tag_result == 0\n\n release:\n needs: tag\n if: needs.tag.outputs.tag_result == 0\n uses: ./.github/workflows/release.yml\n secrets: inherit\n with:\n tag: ${{ needs.tag.outputs.requested_version }}\n" }, { "path": ".github/workflows/testing-dispatch.yml", "content": "name: Go Test (manual run)\n\non:\n workflow_dispatch:\n inputs:\n ref:\n description: \"Tag/commit to checkout.\"\n type: string\n required: true\n\njobs:\n test:\n uses: ./.github/workflows/reusable-testing.yml\n with:\n ref: ${{ inputs.ref }}" }, { "path": ".github/workflows/testing.yml", "content": "name: Go Test\n\non:\n pull_request:\n branches: [ master, v3 ]\n\njobs:\n test:\n uses: ./.github/workflows/reusable-testing.yml" }, { "path": ".gitignore", "content": "mockery.prof\ndist\n.idea\ndocs/ve\nve\n.cache\ncoverage.txt\nsite/\n.task/\ntools/tools\n*.lua\n" }, { "path": ".golangci.yml", "content": "linters:\n # Disable all linters.\n # Default: false\n disable-all: true\n # Enable specific linter\n # https://golangci-lint.run/usage/linters/#enabled-by-default\n enable:\n - errcheck\n - gofumpt\n - gosimple\n - govet\n - ineffassign\n - staticcheck\n - typecheck\n - contextcheck\n - durationcheck\n - copyloopvar\n - gocheckcompilerdirectives\n - gosec\n - loggercheck\n - nilerr\n - prealloc\n - predeclared\n - reassign\n - revive\n - testifylint\nlinters-settings:\n revive:\n enable-all-rules: false\n rules:\n - name: 'var-naming'\n staticcheck:\n checks:\n - all\n - '-SA1024'\n testifylint:\n disable-all: true\n enable:\n - compares\n - empty\n - expected-actual\n - len\n gosimple:\n checks:\n - S1000\n - S1001\n - S1003\n - S1004\n - S1005\n - S1006\n - S1007\n - S1008\n - S1009\n - S1010\n - S1011\n - S1012\n - S1016\n - S1017\n - S1018\n - S1019\n - S1020\n - S1021\n - S1023\n - S1024\n - S1025\n - S1028\n - S1029\n - S1030\n - S1031\n - S1032\n - S1033\n - S1034\n - S1035\n - S1036\n - S1037\n - S1038\n - S1039\n - S1040\nissues:\n exclude-rules:\n - linters:\n - revive\n text: \"var-naming: don't use an underscore in package name\"\n" }, { "path": ".goreleaser.yml", "content": "---\nproject_name: mockery\nbefore:\n hooks:\n - go mod download\nbuilds:\n - main: ./main.go\n binary: mockery\n ldflags:\n - -s -w -X github.com/vektra/mockery/v3/internal/logging.SemVer=v{{.Version}}\n env:\n - CGO_ENABLED=0\n goos:\n - darwin\n - linux\n - windows\n goarch:\n - amd64\n - arm64\narchives:\n - name_template: >-\n {{ .ProjectName }}_{{ .Version }}_{{- title .Os }}_\n {{- if eq .Arch \"amd64\" }}x86_64\n {{- else if eq .Arch \"386\" }}i386\n {{- else }}{{ .Arch }}{{ end }}\n files:\n - README.md\n - LICENSE\nchecksum:\n name_template: \"checksum.txt\"\nsnapshot:\n name_template: \"{{ .Tag }}-next\"\nchangelog:\n sort: asc\n use: github-native\ndockers:\n - image_templates: [\"vektra/mockery:{{ .Tag }}-amd64\"]\n goarch: amd64\n dockerfile: Dockerfile\n use: buildx\n build_flag_templates:\n - \"--pull\"\n - \"--label=org.opencontainers.image.created={{.Date}}\"\n - \"--label=org.opencontainers.image.name={{.ProjectName}}\"\n - \"--label=org.opencontainers.image.revision={{.FullCommit}}\"\n - \"--label=org.opencontainers.image.version={{.Version}}\"\n - \"--label=org.opencontainers.image.source={{.GitURL}}\"\n - \"--platform=linux/amd64\"\n - image_templates: [\"vektra/mockery:{{ .Tag }}-arm64\"]\n goarch: arm64\n dockerfile: Dockerfile\n use: buildx\n build_flag_templates:\n - \"--pull\"\n - \"--label=org.opencontainers.image.created={{.Date}}\"\n - \"--label=org.opencontainers.image.name={{.ProjectName}}\"\n - \"--label=org.opencontainers.image.revision={{.FullCommit}}\"\n - \"--label=org.opencontainers.image.version={{.Version}}\"\n - \"--label=org.opencontainers.image.source={{.GitURL}}\"\n - \"--platform=linux/arm64\"\ndocker_manifests:\n - name_template: vektra/mockery:{{ .Tag }}\n image_templates:\n - vektra/mockery:{{ .Tag }}-amd64\n - vektra/mockery:{{ .Tag }}-arm64\n - name_template: vektra/mockery:{{ .Major }}\n image_templates:\n - vektra/mockery:{{ .Tag }}-amd64\n - vektra/mockery:{{ .Tag }}-arm64\n - name_template: vektra/mockery:{{ .Major }}.{{ .Minor }}\n image_templates:\n - vektra/mockery:{{ .Tag }}-amd64\n - vektra/mockery:{{ .Tag }}-arm64\n - name_template: vektra/mockery:latest\n image_templates:\n - vektra/mockery:{{ .Tag }}-amd64\n - vektra/mockery:{{ .Tag }}-arm64\n\nrelease:\n prerelease: false\n make_latest: true\n\ngit:\n ignore_tags:\n - v2\n - v3\n prerelease_suffix: \"-\"\n" }, { "path": ".mockery_matryer.yml", "content": "template: matryer\nstructname: \"Moq{{.InterfaceName}}\"\nfilename: \"mocks_matryer_{{.SrcPackageName}}_test.go\"\nall: true\ntemplate-data:\n skip-ensure: False\n stub-impl: True\n with-resets: True\n boilerplate-file: \"./.boilerplate.txt\"\npackages:\n github.com/vektra/mockery/v3/internal/fixtures:\n config:\n all: false\n include-interface-regex: '.*'\n exclude-interface-regex: 'RequesterGenerics'\n interfaces:\n Requester:\n configs:\n - structname: \"Moq{{.InterfaceName}}SkipEnsure\"\n template-data:\n skip-ensure: True\n - {}\n - structname: StubMatyer{{.InterfaceName}}\n template-data:\n stub-impl: True\n github.com/vektra/mockery/v3/internal/fixtures/empty_return:\n interfaces:\n EmptyReturn:\n configs:\n - structname: StubMatyer{{.InterfaceName}}\n template-data:\n stub-impl: True\n github.com/vektra/mockery/v3/internal/fixtures/output_dir:\n interfaces:\n OutputDirWithDifferentPkgName:\n config:\n dir: \"{{.InterfaceDir}}/mock\"\n pkgname: \"mock\"\n OutputDirWithSamePkgNameAsSrc:\n config:\n dir: \"{{.InterfaceDir}}/output_dir\"\n" }, { "path": ".mockery_testify.yml", "content": "_anchors:\n foo: bar\ntemplate: \"testify\"\nforce-file-write: true\nformatter: \"goimports\"\nall: True\ndir: \"{{.InterfaceDirRelative}}\"\nstructname: \"{{.Mock}}{{.InterfaceName}}\"\npkgname: \"{{.SrcPackageName}}\"\nfilename: \"mocks_{{.Template}}_{{.SrcPackageName}}_test.go\"\ntemplate-data:\n boilerplate-file: \"./.boilerplate.txt\"\npackages:\n github.com/vektra/mockery/v3/internal/cmd:\n github.com/vektra/mockery/v3:\n config:\n dir: .\n github.com/vektra/mockery/v3/internal/fixtures/unexported:\n github.com/vektra/mockery/v3/internal/fixtures/buildtag/comment:\n github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type:\n config:\n recursive: True\n interfaces:\n RType:\n configs:\n - {}\n - structname: RTypeReplaced1\n replace-type:\n github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt1:\n RType1:\n pkg-path: github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt2\n type-name: RType2\n github.com/vektra/mockery/v3/internal/fixtures:\n interfaces:\n VariadicWithNoReturns:\n config:\n template-data:\n unroll-variadic: true \n VariadicWithMultipleReturns:\n configs:\n - structname: MockVariadicWithMultipleReturnsUnrollVariadic\n template-data:\n unroll-variadic: true\n - structname: MockVariadicWithMultipleReturns\n template-data:\n unroll-variadic: false\n RequesterVariadic:\n configs:\n - structname: MockRequesterVariadicOneArgument\n template-data:\n unroll-variadic: False\n - structname: MockRequesterVariadic\n template-data:\n unroll-variadic: True\n Expecter:\n configs:\n - structname: MockExpecterAndRolledVariadic\n template-data:\n unroll-variadic: False\n - structname: MockExpecter\n template-data:\n unroll-variadic: True\n VariadicNoReturnInterface:\n config:\n template-data:\n unroll-variadic: False\n github.com/vektra/mockery/v3/internal/fixtures/recursive_generation:\n config:\n recursive: True\n github.com/vektra/mockery/v3/internal/fixtures/recursive_generation_with_subpkg_exclude:\n config:\n recursive: True\n filename: mocks.go\n exclude-subpkg-regex:\n - subpkg2\n github.com/vektra/mockery/v3/internal/fixtures/empty_return:\n github.com/vektra/mockery/v3/internal/fixtures/method_args/same_name_arg_and_type:\n github.com/vektra/mockery/v3/internal/fixtures/iface_typed_param:\n github.com/vektra/mockery/v3/internal/fixtures/iface_typed_param_lowercase:\n github.com/vektra/mockery/v3/internal/fixtures/example_project:\n github.com/vektra/mockery/v3/internal/fixtures/index_list_expr:\n github.com/vektra/mockery/v3/internal/fixtures/iface_new_type:\n github.com/vektra/mockery/v3/internal/fixtures/auto_generated_skip:\n github.com/vektra/mockery/v3/internal/fixtures/type_alias:\n io:\n config:\n all: True\n dir: internal/fixtures/\n pkgname: test\n filename: mocks_io_test.go\n net/http:\n config:\n all: false\n dir: internal/fixtures/\n pkgname: test\n filename: mocks_net_http_test.go\n interfaces:\n ResponseWriter:\n github.com/vektra/mockery/v3/internal/fixtures/inpackage:\n config:\n dir: \"{{.InterfaceDirRelative}}/subpkg\"\n inpackage: true\n template-data:\n # Set a build tag that won't be picked up by tests. The generated\n # mock file is going to be invalid due to the inpackage: true \n # config.\n mock-build-tags: nobuild\n github.com/vektra/mockery/v3/internal/fixtures/include_auto_generated:\n config:\n include-auto-generated: true\n github.com/vektra/mockery/v3/internal/fixtures/multi_template:\n config:\n template: testify\n interfaces:\n Foo:\n configs:\n - structname: MockTestifyFoo\n template: testify\n - structname: MockMatryerFoo\n template: matryer\n github.com/vektra/mockery/v3/internal/fixtures/replace_type_pointers:\n interfaces:\n InterfaceWithPointers:\n config:\n replace-type:\n github.com/vektra/mockery/v3/internal/fixtures/replace_type_pointers:\n Foo:\n pkg-path: github.com/vektra/mockery/v3/internal/fixtures/replace_type_pointers\n type-name: Bar\n github.com/vektra/mockery/v3/internal/fixtures/directive_comments:\n config:\n all: False\n interfaces:\n MatryerRequester:\n config:\n structname: TheMatryerRequester\n InterfaceWithoutGenerate:\n ServerWithDifferentFile:\n configs:\n - structname: FunServerWithDifferentFile\n - structname: AnotherFunServerWithDifferentFile\n github.com/vektra/mockery/v3/internal/fixtures/constraint_ifaces:\n github.com/vektra/mockery/v3/internal/fixtures/interface_dir_relative:\n config:\n filename: mocks.go\n interfaces:\n Foo:\n configs:\n # This first option simply asserts that InterfaceDirRelative is an actual path. https://github.com/vektra/mockery/issues/1133\n - dir: '{{.InterfaceDir}}/{{ replaceAll \"internal/\" \"\" (index (splitAfterN \"/\" 2 .InterfaceDirRelative) 0) }}/mocks/{{index (splitAfterN \"/\" 2 .InterfaceDirRelative) 1}}'\n # The second option asserts that the value itself is sane. https://github.com/vektra/mockery/issues/1133#issuecomment-3758283921\n # This mock will be explicitly tested against so that we can assert in tests that the value\n # does not encounter breaking changes.\n - dir: '{{.InterfaceDir}}/{{.InterfaceDirRelative}}'" }, { "path": "CODE_OF_CONDUCT.md", "content": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nWe as members, contributors, and leaders pledge to make participation in our\ncommunity a harassment-free experience for everyone, regardless of age, body\nsize, visible or invisible disability, ethnicity, sex characteristics, gender\nidentity and expression, level of experience, education, socio-economic status,\nnationality, personal appearance, race, religion, or sexual identity\nand orientation.\n\nWe pledge to act and interact in ways that contribute to an open, welcoming,\ndiverse, inclusive, and healthy community.\n\n## Our Standards\n\nExamples of behavior that contributes to a positive environment for our\ncommunity include:\n\n* Demonstrating empathy and kindness toward other people\n* Being respectful of differing opinions, viewpoints, and experiences\n* Giving and gracefully accepting constructive feedback\n* Accepting responsibility and apologizing to those affected by our mistakes,\n and learning from the experience\n* Focusing on what is best not just for us as individuals, but for the\n overall community\n\nExamples of unacceptable behavior include:\n\n* The use of sexualized language or imagery, and sexual attention or\n advances of any kind\n* Trolling, insulting or derogatory comments, and personal or political attacks\n* Public or private harassment\n* Publishing others' private information, such as a physical or email\n address, without their explicit permission\n* Other conduct which could reasonably be considered inappropriate in a\n professional setting\n\n## Enforcement Responsibilities\n\nCommunity leaders are responsible for clarifying and enforcing our standards of\nacceptable behavior and will take appropriate and fair corrective action in\nresponse to any behavior that they deem inappropriate, threatening, offensive,\nor harmful.\n\nCommunity leaders have the right and responsibility to remove, edit, or reject\ncomments, commits, code, wiki edits, issues, and other contributions that are\nnot aligned to this Code of Conduct, and will communicate reasons for moderation\ndecisions when appropriate.\n\n## Scope\n\nThis Code of Conduct applies within all community spaces, and also applies when\nan individual is officially representing the community in public spaces.\nExamples of representing our community include using an official e-mail address,\nposting via an official social media account, or acting as an appointed\nrepresentative at an online or offline event.\n\n## Enforcement\n\nInstances of abusive, harassing, or otherwise unacceptable behavior may be\nreported to the community leaders responsible for enforcement at\nlandonclipp@gmail.com.\nAll complaints will be reviewed and investigated promptly and fairly.\n\nAll community leaders are obligated to respect the privacy and security of the\nreporter of any incident.\n\n## Enforcement Guidelines\n\nCommunity leaders will follow these Community Impact Guidelines in determining\nthe consequences for any action they deem in violation of this Code of Conduct:\n\n### 1. Correction\n\n**Community Impact**: Use of inappropriate language or other behavior deemed\nunprofessional or unwelcome in the community.\n\n**Consequence**: A private, written warning from community leaders, providing\nclarity around the nature of the violation and an explanation of why the\nbehavior was inappropriate. A public apology may be requested.\n\n### 2. Warning\n\n**Community Impact**: A violation through a single incident or series\nof actions.\n\n**Consequence**: A warning with consequences for continued behavior. No\ninteraction with the people involved, including unsolicited interaction with\nthose enforcing the Code of Conduct, for a specified period of time. This\nincludes avoiding interactions in community spaces as well as external channels\nlike social media. Violating these terms may lead to a temporary or\npermanent ban.\n\n### 3. Temporary Ban\n\n**Community Impact**: A serious violation of community standards, including\nsustained inappropriate behavior.\n\n**Consequence**: A temporary ban from any sort of interaction or public\ncommunication with the community for a specified period of time. No public or\nprivate interaction with the people involved, including unsolicited interaction\nwith those enforcing the Code of Conduct, is allowed during this period.\nViolating these terms may lead to a permanent ban.\n\n### 4. Permanent Ban\n\n**Community Impact**: Demonstrating a pattern of violation of community\nstandards, including sustained inappropriate behavior, harassment of an\nindividual, or aggression toward or disparagement of classes of individuals.\n\n**Consequence**: A permanent ban from any sort of public interaction within\nthe community.\n\n## Attribution\n\nThis Code of Conduct is adapted from the [Contributor Covenant][homepage],\nversion 2.0, available at\nhttps://www.contributor-covenant.org/version/2/0/code_of_conduct.html.\n\nCommunity Impact Guidelines were inspired by [Mozilla's code of conduct\nenforcement ladder](https://github.com/mozilla/diversity).\n\n[homepage]: https://www.contributor-covenant.org\n\nFor answers to common questions about this code of conduct, see the FAQ at\nhttps://www.contributor-covenant.org/faq. Translations are available at\nhttps://www.contributor-covenant.org/translations.\n" }, { "path": "CONTRIBUTING.md", "content": "# Contributing\n\nThank you for investing your time in contributing to our project!\n\nRead our [Code of Conduct](https://github.com/vektra/mockery/blob/master/CODE_OF_CONDUCT.md) to keep our community approachable and respectable.\n\n## Local development setup\n\nAll of the local development tools are go-based and are versioned in our go.mod file. Simply call `go download -x` to initialize and download all of our tooling.\n\nThis project uses Taskfile, a better alternative to Makefile. Run `task -l` for list of valid targets.\n\n## Working with documentation\n\nWe use [mkdocs](https://www.mkdocs.org/) with the [mkdocs-material theme](https://squidfunk.github.io/mkdocs-material/).\n\nTo preview the documentation locally, run `task mkdocs.serve`. The task will install the required mkdocs plugins and theme\nand run the mkdocs server with real-time updating/refreshing.\n\n## Submitting PRs\n\nBefore submitting PRs, it's strongly recommended you create an issue to discuss the problem, and possible solutions. PRs added without any discussion run the risk of not being accepted, which is a waste of your time. Issues marked with `approved feature` are features that the maintainers are willing to accept into the code, and are approved for development. PRs that implement an `approved feature` have a high likelihood of being accepted.\n" }, { "path": "Dockerfile", "content": "FROM golang:1.26-alpine as builder\n\nRUN apk --update add --no-cache gcc musl-dev git openssh\n\nCOPY mockery /usr/local/bin\n\n# Explicitly set a writable cache path when running --user=$(id -u):$(id -g)\n# see: https://github.com/golang/go/issues/26280#issuecomment-445294378\nENV GOCACHE /tmp/.cache\n\nENTRYPOINT [\"/usr/local/bin/mockery\"]\n" }, { "path": "LICENSE", "content": "Copyright (c) 2014, Opinionated Architecture\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n* Neither the name of the {organization} nor the names of its\n contributors may be used to endorse or promote products derived from\n this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n" }, { "path": "README.md", "content": "\nmockery\n=======\n[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/vektra/mockery/v3/template) ![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/vektra/mockery) ![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/vektra/mockery) [![Go Report Card](https://goreportcard.com/badge/github.com/vektra/mockery/v3)](https://goreportcard.com/report/github.com/vektra/mockery/v3) [![codecov](https://codecov.io/gh/vektra/mockery/branch/master/graph/badge.svg)](https://codecov.io/gh/vektra/mockery)\n\nmockery provides the ability to easily generate mocks for Golang interfaces using the [stretchr/testify/mock](https://pkg.go.dev/github.com/stretchr/testify/mock?tab=doc) package. It removes the boilerplate coding required to use mocks.\n\nDocumentation\n--------------\n\nDocumentation is found at our [GitHub Pages site](https://vektra.github.io/mockery/).\n\nDevelopment\n------------\n\ntaskfile.dev is used for build tasks. Initialize all go build tools:\n\n```\ngo mod download -x\n```\n\nYou can run any of the steps listed in `Taskfile.yml`:\n\n```\n$ task test\ntask: [test] go test -v -coverprofile=coverage.txt ./...\n```\n\nStargazers\n----------\n\n[![Stargazers over time](https://starchart.cc/vektra/mockery.svg)](https://starchart.cc/vektra/mockery)\n" }, { "path": "Taskfile.yml", "content": "version: \"3\"\n\ntasks:\n coverage:\n deps: [test]\n desc: run unit tests and create HTML coverage file\n cmds:\n - go tool cover -html=coverage.txt\n\n fmt:\n desc: auto-format all go files\n sources:\n - \"**/*.go\"\n cmds:\n - gofumpt -l -w .\n\n mocks:\n desc: generate new mocks from scratch\n cmds:\n - task: mocks.remove\n - task: mocks.generate\n\n mocks.remove:\n desc: remove all mock files\n deps:\n - mocks.remove.windows\n - mocks.remove.unix\n\n mocks.remove.windows:\n desc: remove all mock files on windows\n platforms: [\"windows\"]\n cmds:\n - rm -f files.txt\n - where /r . '*_mock.go' > files.txt || true\n - where /r . 'mock_*_test.go' >> files.txt || true\n - where /r . 'mocks_moq.go' >> files.txt || true\n - where /r . 'mocks_test.go' >> files.txt || true\n - where /r . 'mocks_*_test.go' >> files.txt || true\n - where /r . 'mocks_matryer_*.go' >> files.txt || true\n - where /r . 'mocks.go' >> files.txt || true\n - powershell -Command 'foreach ($file in Get-Content \"files.txt\") { If (Test-Path $file) {Remove-Item $file} }'\n - rm -rf mocks/\n - rm -f files.txt\n\n\n mocks.remove.unix:\n desc: remove all mock files on unix\n platforms: [\"darwin\", \"linux\"]\n cmds:\n - find . -name '*_mock.go' -o -name 'mock_*_test.go' -o -name \"mocks_moq.go\" -o -name 'mocks_test.go' -o -name 'mocks_*_test.go' -o -name 'mocks_matryer_*.go' -o -name 'mocks.go' | xargs -r rm\n - rm -rf mocks/\n\n mocks.generate.custom:\n cmds:\n - go run .\n\n mocks.generate.testify:\n desc: Generate testify mocks\n cmds:\n - MOCKERY_CONFIG=./.mockery_testify.yml go run .\n\n mocks.generate.matryer:\n desc: Generate matryer mocks\n cmds:\n - MOCKERY_CONFIG=./.mockery_matryer.yml go run .\n\n mocks.generate:\n desc: generate mocks\n deps:\n - mocks.generate.testify\n - mocks.generate.matryer\n\n git-state:\n desc: Check for a dirty git git-state\n cmds:\n - git diff --exit-code\n\n docker:\n desc: build the mockery docker image\n cmds:\n - docker build -t vektra/mockery .\n\n mkdocs.install:\n desc: install mkdocs and plugins\n sources:\n - \"docs/requirements.txt\"\n cmds:\n - pip install -r docs/requirements.txt\n\n mkdocs.serve:\n desc: serve mkdocs locally\n deps: [mkdocs.install]\n cmds:\n - mkdocs serve\n\n lint:\n desc: run all the defined linters\n sources:\n - \"**/*.go\"\n cmds:\n - go run github.com/golangci/golangci-lint/cmd/golangci-lint run\n\n test:\n cmds:\n - go run gotest.tools/gotestsum --format testname -- -v -coverprofile=coverage.txt ./internal/... ./template_funcs/... ./template/...\n desc: run unit tests\n generates:\n - coverage.txt\n\n test.e2e:\n desc: run end-to-end tests\n cmds:\n - bash ./e2e/run_all.sh\n - go run gotest.tools/gotestsum --format testname -- -v -count=1 ./e2e/...\n\n test.ci:\n deps: [lint]\n cmds:\n - task: mocks\n - task: git-state\n - task: test\n - task: mocks.remove\n - task: test.e2e\n\n default:\n deps: [test.ci]\n\n build-tools:\n desc: Build tools directory\n cmds:\n - cd ./tools && go build -o tools .\n\n tag:\n desc: Tag the git repo with the version specified.\n deps: [build-tools]\n cmds:\n - ./tools/tools tag --dry-run=false\n\n tag.push:\n desc: Push tags to origin\n cmds:\n - git push origin --tags --force\n" }, { "path": "codecov.yml", "content": "coverage:\n precision: 5\n round: down\n range: \"00...100\"\n status:\n patch:\n default:\n target: 40%\n threshold: 35%\n base: auto \n\n" }, { "path": "config/README.md", "content": "Config\n------\n\nThe `config` package provides mockery configuration semantics and behaviors. The [`RootConfig`](https://pkg.go.dev/github.com/vektra/mockery/v3/config#RootConfig) type defines the schema for the top-level `.mockery.yml` file.\n" }, { "path": "config/config.go", "content": "// Package config defines the schemas and functionality of the .mockery.yml\n// config files. This package is NOT meant to be used by external Go libraries.\n// We expose the contents of this package purely for documentation purposes.\n//\n// Do NOT import this package. We cannot guarantee backwards-compatibility of\n// the methods herein.\npackage config\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"fmt\"\n\t\"go/ast\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"reflect\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n\t\"text/template\"\n\n\t\"github.com/brunoga/deep\"\n\t\"github.com/go-viper/mapstructure/v2\"\n\tkoanfYAML \"github.com/knadh/koanf/parsers/yaml\"\n\t\"github.com/knadh/koanf/providers/env\"\n\t\"github.com/knadh/koanf/providers/file\"\n\t\"github.com/knadh/koanf/providers/posflag\"\n\t\"github.com/knadh/koanf/providers/structs\"\n\t\"github.com/knadh/koanf/v2\"\n\t\"github.com/rs/zerolog\"\n\t\"github.com/spf13/pflag\"\n\tinternalConfig \"github.com/vektra/mockery/v3/internal/config\"\n\t\"github.com/vektra/mockery/v3/internal/logging\"\n\t\"github.com/vektra/mockery/v3/internal/stackerr\"\n\t\"github.com/vektra/mockery/v3/template_funcs\"\n\t\"golang.org/x/tools/go/packages\"\n\t\"golang.org/x/tools/imports\"\n\t\"gopkg.in/yaml.v3\"\n)\n\n// TemplateData is the data sent to the template for the config file.\ntype TemplateData struct {\n\t// ConfigDir is the directory of where the mockery config file is located.\n\tConfigDir string\n\t// InterfaceDir is the directory of the interface being mocked.\n\tInterfaceDir string\n\t// InterfaceDirRelative is the same as InterfaceDir, but made relative to mockery's current working directory.\n\tInterfaceDirRelative string\n\t// InterfaceFile is the filename of where the interface is defined.\n\tInterfaceFile string\n\t// InterfaceName is the name of the interface (duh).\n\tInterfaceName string\n\t// Mock is a parameter that takes the value of \"Mock\" if the interface is exported, and \"mock\" otherwise.\n\tMock string\n\t// StructName is the configured name of the mock.\n\tStructName string\n\t// SrcPackageName is the name of the source package as defined by the `package [name]` in the source package.\n\tSrcPackageName string\n\t// SrcPackagePath is the fully qualified package path of the source package. e.g. \"github.com/vektra/mockery/v3\".\n\tSrcPackagePath string\n\t// Template is the value of the `template` parameter.\n\tTemplate string\n}\n\nfunc addr[T any](v T) *T {\n\treturn &v\n}\n\nfunc deref[T any](t *T) T {\n\tif t == nil {\n\t\treturn *new(T)\n\t}\n\n\treturn *t\n}\n\nfunc NewDefaultKoanf(ctx context.Context) (*koanf.Koanf, error) {\n\tc := Config{\n\t\tAll: addr(false),\n\t\tAnchors: map[string]any{},\n\t\tDir: addr(\"{{.InterfaceDir}}\"),\n\t\tFileName: addr(\"mocks_test.go\"),\n\t\tForceFileWrite: addr(true),\n\t\tFormatter: addr(\"goimports\"),\n\t\tFormatterOptions: defaultFormatterOptions(),\n\t\tGenerate: addr(true),\n\t\tIncludeAutoGenerated: addr(false),\n\t\tLogLevel: addr(\"info\"),\n\t\tStructName: addr(\"{{.Mock}}{{.InterfaceName}}\"),\n\t\tPkgName: addr(\"{{.SrcPackageName}}\"),\n\t\tRecursive: addr(false),\n\t\tRequireTemplateSchemaExists: addr(true),\n\t\tTemplate: addr(\"testify\"),\n\t\tTemplateData: map[string]any{},\n\t\tTemplateSchema: addr(\"{{.Template}}.schema.json\"),\n\t}\n\tk := koanf.New(\"|\")\n\tif err := k.Load(structs.Provider(c, \"koanf\"), nil); err != nil {\n\t\treturn nil, stackerr.NewStackErr(err)\n\t}\n\treturn k, nil\n}\n\nfunc defaultFormatterOptions() *FormatterOptions {\n\treturn &FormatterOptions{\n\t\t// Matches goimports defaults:\n\t\t// https://cs.opensource.google/go/x/tools/+/refs/tags/v0.41.0:imports/forward.go;l=53\n\t\tGoImports: &GoImports{\n\t\t\tAllErrors: addr(false),\n\t\t\tComments: addr(true),\n\t\t\tFormatOnly: addr(true),\n\t\t\tFragment: addr(false),\n\t\t\tLocalPrefix: addr(\"\"),\n\t\t\tTabIndent: addr(true),\n\t\t\tTabWidth: addr(8),\n\t\t},\n\t}\n}\n\ntype RootConfig struct {\n\tConfig `koanf:\",squash\" yaml:\",inline\"`\n\tPackages map[string]*PackageConfig `koanf:\"packages\" yaml:\"packages\"`\n\tkoanf *koanf.Koanf\n\tconfigFile string\n}\n\nfunc NewRootConfig(\n\tctx context.Context,\n\tflags *pflag.FlagSet,\n) (*RootConfig, *koanf.Koanf, error) {\n\tvar configFile string\n\n\tlog := zerolog.Ctx(ctx)\n\tvar err error\n\n\tconf := &Config{}\n\t// Set all parameters to their respective zero-values. Need to use\n\t// reflection for this sadly.\n\tv := reflect.ValueOf(conf).Elem()\n\tfor i := 0; i < v.NumField(); i++ {\n\t\tfield := v.Field(i)\n\t\tif field.Kind() != reflect.Pointer {\n\t\t\tcontinue\n\t\t}\n\t\tif !field.IsNil() {\n\t\t\tcontinue\n\t\t}\n\t\tfield.Set(reflect.New(field.Type().Elem()))\n\t}\n\n\t// There are some special cases where the default value of pointers\n\t// should be set to nil.\n\tconf.InPackage = nil\n\n\tk, err := NewDefaultKoanf(ctx)\n\tif err != nil {\n\t\treturn nil, nil, err\n\t}\n\tvar rootConfig RootConfig = RootConfig{\n\t\tConfig: *conf,\n\t\tkoanf: k,\n\t}\n\n\tconfigFileFromEnv := os.Getenv(\"MOCKERY_CONFIG\")\n\tif configFileFromEnv != \"\" {\n\t\tconfigFile = configFileFromEnv\n\t}\n\tif configFile == \"\" {\n\t\tconfigFileFromFlags, err := flags.GetString(\"config\")\n\t\tif err != nil {\n\t\t\treturn nil, nil, fmt.Errorf(\"getting --config from flags: %w\", err)\n\t\t}\n\t\tif configFileFromFlags != \"\" {\n\t\t\tconfigFile = configFileFromFlags\n\t\t}\n\t}\n\tif configFile == \"\" {\n\t\tlog.Debug().Msg(\"config file not specified, searching\")\n\t\tconfigFile, err = internalConfig.FindConfig()\n\t\tif err != nil {\n\t\t\treturn nil, k, fmt.Errorf(\"discovering mockery config: %w\", err)\n\t\t}\n\t\tlog.Debug().Str(\"config-file\", configFile).Msg(\"config file found\")\n\t}\n\trootConfig.configFile = configFile\n\n\tkoanfTags := conf.koanfTagNames()\n\tif err := k.Load(\n\t\tenv.ProviderWithValue(\n\t\t\t\"MOCKERY_\",\n\t\t\t\".\",\n\t\t\tfunc(key, value string) (string, any) {\n\t\t\t\tnormalizedKey := strings.Replace(strings.ToLower(strings.TrimPrefix(key, \"MOCKERY_\")), \"_\", \"-\", -1)\n\t\t\t\tif _, exists := koanfTags[normalizedKey]; !exists {\n\t\t\t\t\tlog.Debug().Str(\"env-var\", key).Msg(\"environment variable unknown, not including in config map.\")\n\t\t\t\t\treturn \"\", nil\n\t\t\t\t}\n\n\t\t\t\t// Loading from environment variables is kind of weird. Koanf doesn't seem to\n\t\t\t\t// have a good way to automatically convert values destined for boolean fields\n\t\t\t\t// without resorting to reflection. We do something gross here by\n\t\t\t\t// just checking to see if the string \"looks\" like it should be\n\t\t\t\t// a boolean. The proper solution is to use reflection on the destination\n\t\t\t\t// struct to see what the type actually should be cast to. I'm sure\n\t\t\t\t// the koanf project would appreciate a PR to add an environment\n\t\t\t\t// parser:\n\t\t\t\tif strings.ToLower(value) == \"true\" || strings.ToLower(value) == \"false\" {\n\t\t\t\t\tvalueAsBool, err := strconv.ParseBool(value)\n\t\t\t\t\tif err != nil {\n\t\t\t\t\t\tpanic(err)\n\t\t\t\t\t}\n\t\t\t\t\treturn normalizedKey, valueAsBool\n\t\t\t\t}\n\t\t\t\treturn normalizedKey, value\n\t\t\t}),\n\t\tnil,\n\t); err != nil {\n\t\tlog.Err(err).Msg(\"failed to load environment provider\")\n\t\treturn nil, nil, stackerr.NewStackErr(err)\n\t}\n\n\tif err := k.Load(file.Provider(configFile), koanfYAML.Parser()); err != nil {\n\t\treturn nil, k, fmt.Errorf(\"loading config file: %w\", err)\n\t}\n\n\tif flags != nil {\n\t\tif err := k.Load(posflag.Provider(flags, \".\", k), nil); err != nil {\n\t\t\treturn nil, k, fmt.Errorf(\"loading flags: %w\", err)\n\t\t}\n\t}\n\n\t// Second argument is nil because of a weird bug: https://github.com/knadh/koanf/issues/307\n\tif err := k.UnmarshalWithConf(\"\", &rootConfig, koanf.UnmarshalConf{\n\t\tDecoderConfig: &mapstructure.DecoderConfig{\n\t\t\tErrorUnused: true,\n\t\t},\n\t}); err != nil {\n\t\treturn nil, k, fmt.Errorf(\"unmarshalling config: %w\", err)\n\t}\n\tif err := rootConfig.Initialize(ctx); err != nil {\n\t\treturn nil, k, fmt.Errorf(\"initializing root config: %w\", err)\n\t}\n\treturn &rootConfig, k, nil\n}\n\nfunc (c *RootConfig) ConfigFileUsed() string {\n\treturn c.configFile\n}\n\n// mergreStringMaps merges two (possibly nested) maps.\nfunc mergeStringMaps(src, dest map[string]any) {\n\tfor srcKey, srcValue := range src {\n\t\tif destValue, exists := dest[srcKey]; exists {\n\t\t\t// If the source value is a map, merge recursively\n\t\t\tif destMap, ok := destValue.(map[string]any); ok {\n\t\t\t\tif srcMap, ok := srcValue.(map[string]any); ok {\n\t\t\t\t\tmergeStringMaps(srcMap, destMap)\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t}\n\t\t\tcontinue\n\t\t}\n\t\t// Otherwise, set the value directly\n\t\tdest[srcKey] = srcValue\n\t}\n}\n\n// mergeConfigs merges the values from c1 into c2.\nfunc mergeConfigs(ctx context.Context, src Config, dest *Config) {\n\tlog := zerolog.Ctx(ctx)\n\t// Merge root config with package config\n\tsrcValue := reflect.ValueOf(src)\n\tdestValue := reflect.ValueOf(dest)\n\n\tfor i := 0; i < srcValue.NumField(); i++ {\n\t\tfieldLog := log.With().\n\t\t\tInt(\"index\", i).\n\t\t\tStr(\"name\", srcValue.Type().Field(i).Name).\n\t\t\tLogger()\n\t\tfieldLog.Debug().Msg(\"Iterating over field for merging\")\n\t\tsrcFieldValue := srcValue.Field(i)\n\t\tdestFieldValue := destValue.Elem().Field(i)\n\n\t\tif srcFieldValue.Kind() == reflect.Map {\n\t\t\tsrcMap, ok := srcFieldValue.Interface().(map[string]any)\n\t\t\tif !ok {\n\t\t\t\tlog.Debug().Msg(\"field value is not `any`, skipping merge\")\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tdestMap, ok := destFieldValue.Interface().(map[string]any)\n\t\t\tif !ok {\n\t\t\t\tlog.Debug().Msg(\"dest map value is not `any`, skipping\")\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif destMap == nil {\n\t\t\t\tdestFieldValue.Set(reflect.ValueOf(make(map[string]any)))\n\t\t\t}\n\t\t\tdestMap = destFieldValue.Interface().(map[string]any)\n\t\t\tmergeStringMaps(srcMap, destMap)\n\t\t} else if srcFieldValue.Kind() == reflect.Pointer && srcFieldValue.IsNil() {\n\t\t\t// Do nothing, the src field is nil\n\t\t} else if srcFieldValue.Kind() == reflect.Pointer && destFieldValue.IsNil() {\n\t\t\t// Attribute is a pointer. We need to allocate a new value of the\n\t\t\t// same type as the type being pointed to.\n\t\t\tnewValue := reflect.New(srcFieldValue.Elem().Type())\n\t\t\t// Then, set this new value to the same value as the src.\n\t\t\tnewValue.Elem().Set(srcFieldValue.Elem())\n\t\t\t// newValue is already an address, so we can set destFieldValue\n\t\t\t// to it as-is.\n\t\t\tdestFieldValue.Set(newValue)\n\t\t} else if destFieldValue.CanSet() && destFieldValue.IsZero() {\n\t\t\tdestFieldValue.Set(srcFieldValue)\n\t\t} else {\n\t\t\tfieldLog.Debug().\n\t\t\t\tBool(\"can-set\", destFieldValue.CanSet()).\n\t\t\t\tBool(\"is-zero\", destFieldValue.IsZero()).\n\t\t\t\tMsg(\"field not addressable, not merging.\")\n\t\t}\n\t}\n}\n\nfunc (c *RootConfig) Initialize(ctx context.Context) error {\n\tlog := zerolog.Ctx(ctx)\n\trecursivePackages := []string{}\n\tfor pkgName, pkgConfig := range c.Packages {\n\t\tif pkgConfig == nil {\n\t\t\tpkgConfig = NewPackageConfig()\n\t\t\tc.Packages[pkgName] = pkgConfig\n\t\t}\n\t\tif pkgConfig.Config == nil {\n\t\t\tpkgConfig.Config = &Config{}\n\t\t}\n\t\tif pkgConfig.Interfaces == nil {\n\t\t\tpkgConfig.Interfaces = map[string]*InterfaceConfig{}\n\t\t}\n\t\tpkgLog := log.With().Str(\"package-path\", pkgName).Logger()\n\t\tpkgCtx := pkgLog.WithContext(ctx)\n\n\t\tmergeConfigs(pkgCtx, c.Config, pkgConfig.Config)\n\t\tif err := pkgConfig.Initialize(pkgCtx); err != nil {\n\t\t\treturn fmt.Errorf(\"initializing root config: %w\", err)\n\t\t}\n\t\tif *pkgConfig.Config.Recursive {\n\t\t\trecursivePackages = append(recursivePackages, pkgName)\n\t\t}\n\t}\n\n\tfor _, recursivePackageName := range recursivePackages {\n\t\tpkgLog := log.With().Str(logging.LogKeyPackagePath, recursivePackageName).Logger()\n\t\tpkgCtx := pkgLog.WithContext(ctx)\n\t\tpkgLog.Debug().Msg(\"package marked as recursive\")\n\n\t\tsubpkgs, err := c.subPackages(recursivePackageName)\n\t\tif err != nil {\n\t\t\treturn fmt.Errorf(\"discovering sub packages of %s: %w\", recursivePackageName, err)\n\t\t}\n\t\tparentPkgConfig := c.Packages[recursivePackageName]\n\t\tfor _, subpkg := range subpkgs {\n\t\t\trecursivePkgConfig, err := c.GetPackageConfig(ctx, recursivePackageName)\n\t\t\tif err != nil {\n\t\t\t\treturn fmt.Errorf(\"getting package config: %w\", err)\n\t\t\t}\n\t\t\tif recursivePkgConfig.Config.ShouldExcludeSubpkg(subpkg) {\n\t\t\t\tpkgLog.Debug().Msg(\"package was marked for exclusion\")\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tvar subPkgConfig *PackageConfig\n\t\t\tif existingSubPkg, exists := c.Packages[subpkg]; exists {\n\t\t\t\tsubPkgConfig = existingSubPkg\n\t\t\t} else {\n\t\t\t\tsubPkgConfig = NewPackageConfig()\n\t\t\t}\n\t\t\tmergeConfigs(pkgCtx, *parentPkgConfig.Config, subPkgConfig.Config)\n\t\t\tc.Packages[subpkg] = subPkgConfig\n\t\t}\n\t}\n\treturn nil\n}\n\nfunc (c *RootConfig) subPackages(pkgPath string) ([]string, error) {\n\tpkgs, err := packages.Load(&packages.Config{\n\t\tMode: packages.NeedName | packages.NeedFiles,\n\t}, pkgPath+\"/...\")\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to load packages: %w\", err)\n\t}\n\n\tconvertPkgPath := func(pkgs []*packages.Package) []string {\n\t\tpaths := make([]string, 0, len(pkgs))\n\t\tfor _, pkg := range pkgs {\n\t\t\tif len(pkg.GoFiles) == 0 {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tpaths = append(paths, pkg.PkgPath)\n\t\t}\n\t\treturn paths\n\t}\n\n\treturn convertPkgPath(pkgs), nil\n}\n\nfunc (c *RootConfig) GetPackageConfig(ctx context.Context, pkgPath string) (*PackageConfig, error) {\n\tpkgConfig, ok := c.Packages[pkgPath]\n\tif !ok {\n\t\treturn nil, stackerr.NewStackErr(fmt.Errorf(\"package %s does not exist in the config\", pkgPath))\n\t}\n\treturn pkgConfig, nil\n}\n\n// GetPackages returns a list of the packages that are defined in\n// the `packages` config section.\nfunc (c *RootConfig) GetPackages(ctx context.Context) ([]string, error) {\n\tpackages := []string{}\n\tfor key := range c.Packages {\n\t\tpackages = append(packages, key)\n\t}\n\treturn packages, nil\n}\n\ntype PackageConfig struct {\n\tConfig *Config `koanf:\"config\" yaml:\"config,omitempty\"`\n\tInterfaces map[string]*InterfaceConfig `koanf:\"interfaces\" yaml:\"interfaces,omitempty\"`\n}\n\nfunc NewPackageConfig() *PackageConfig {\n\treturn &PackageConfig{\n\t\tConfig: &Config{},\n\t\tInterfaces: map[string]*InterfaceConfig{},\n\t}\n}\n\nfunc (c *PackageConfig) Initialize(ctx context.Context) error {\n\tfor idx, ifaceConfig := range c.Interfaces {\n\t\tif ifaceConfig == nil {\n\t\t\tifaceConfig = NewInterfaceConfig()\n\t\t\tc.Interfaces[idx] = ifaceConfig\n\t\t}\n\t\tif ifaceConfig.Config == nil {\n\t\t\tifaceConfig.Config = &Config{}\n\t\t}\n\t\tmergeConfigs(ctx, *c.Config, ifaceConfig.Config)\n\t\tif err := ifaceConfig.Initialize(ctx); err != nil {\n\t\t\treturn fmt.Errorf(\"initializing package config: %w\", err)\n\t\t}\n\t}\n\treturn nil\n}\n\nfunc (c PackageConfig) GetInterfaceConfig(ctx context.Context, interfaceName string, directiveConfig *Config) (*InterfaceConfig, error) {\n\t// If the interface has an explicit config, override it with the directive config.\n\t// This favor any config set in the directive comment over the original file based config.\n\tif ifaceConfig, ok := c.Interfaces[interfaceName]; ok {\n\t\tif directiveConfig != nil {\n\t\t\tnewConfig, err := deep.Copy(directiveConfig)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, fmt.Errorf(\"cloning directive config: %w\", err)\n\t\t\t}\n\n\t\t\t// Merge the interface config into the directive config clone.\n\t\t\tmergeConfigs(ctx, *ifaceConfig.Config, newConfig)\n\n\t\t\tifaceConfig.Config = newConfig\n\n\t\t\tfor i, subCfg := range ifaceConfig.Configs {\n\t\t\t\tnewConfig, err := deep.Copy(directiveConfig)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn nil, fmt.Errorf(\"cloning directive config: %w\", err)\n\t\t\t\t}\n\n\t\t\t\t// Merge the interface config into the directive config clone.\n\t\t\t\tmergeConfigs(ctx, *subCfg, newConfig)\n\t\t\t\tifaceConfig.Configs[i] = newConfig\n\t\t\t}\n\t\t}\n\n\t\treturn ifaceConfig, nil\n\t}\n\n\t// We don't have a specific config for this interface,\n\t// we should create a new one.\n\tifaceConfig := NewInterfaceConfig()\n\n\t// If there is a directive config, use it as the base config.\n\tif directiveConfig != nil {\n\t\tnewConfig, err := deep.Copy(directiveConfig)\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"cloning directive config: %w\", err)\n\t\t}\n\t\tifaceConfig.Config = newConfig\n\t}\n\n\t// Finally, merge the package config into the new config\n\tmergeConfigs(ctx, *c.Config, ifaceConfig.Config)\n\n\tifaceConfig.Configs = []*Config{ifaceConfig.Config}\n\treturn ifaceConfig, nil\n}\n\nfunc (c PackageConfig) ShouldGenerateInterface(\n\tctx context.Context,\n\tinterfaceName string,\n\tifaceConfig Config,\n\thasDirectiveComment bool,\n) (bool, error) {\n\tlog := zerolog.Ctx(ctx)\n\tif hasDirectiveComment {\n\t\tif ifaceConfig.Generate != nil && !*ifaceConfig.Generate {\n\t\t\tlog.Debug().Msg(\"interface has directive comment with generate: false, skipping generation\")\n\t\t\treturn false, nil\n\t\t}\n\t\tlog.Debug().Msg(\"interface has directive comment, generating mock\")\n\t\treturn true, nil\n\t}\n\tif *c.Config.All {\n\t\tif *c.Config.IncludeInterfaceRegex != \"\" {\n\t\t\tlog.Warn().Msg(\"interface config has both `all` and `include-interface-regex` set: `include-interface-regex` will be ignored\")\n\t\t}\n\t\tif *c.Config.ExcludeInterfaceRegex != \"\" {\n\t\t\tlog.Warn().Msg(\"interface config has both `all` and `exclude-interface-regex` set: `exclude-interface-regex` will be ignored\")\n\t\t}\n\t\tlog.Debug().Msg(\"`all: true` is set, interface should be generated\")\n\t\treturn true, nil\n\t}\n\n\tif _, exists := c.Interfaces[interfaceName]; exists {\n\t\treturn true, nil\n\t}\n\n\tincludeRegex := *c.Config.IncludeInterfaceRegex\n\texcludeRegex := *c.Config.ExcludeInterfaceRegex\n\tif includeRegex == \"\" {\n\t\tif excludeRegex != \"\" {\n\t\t\tlog.Warn().Msg(\"interface config has `exclude-interface-regex` set but not `include-interface-regex`: `exclude-interface-regex` will be ignored\")\n\t\t}\n\t\treturn false, nil\n\t}\n\tincludedByRegex, err := regexp.MatchString(includeRegex, interfaceName)\n\tif err != nil {\n\t\treturn false, fmt.Errorf(\"evaluating `include-interface-regex`: %w\", err)\n\t}\n\tif !includedByRegex {\n\t\tlog.Debug().Msg(\"interface does not match include-interface-regex\")\n\t\treturn false, nil\n\t}\n\tlog.Debug().Msg(\"interface matches include-interface-regex\")\n\tif excludeRegex == \"\" {\n\t\treturn true, nil\n\t}\n\texcludedByRegex, err := regexp.MatchString(excludeRegex, interfaceName)\n\tif err != nil {\n\t\treturn false, fmt.Errorf(\"evaluating `exclude-interface-regex`: %w\", err)\n\t}\n\tif excludedByRegex {\n\t\tlog.Debug().Msg(\"interface matches exclude-interface-regex\")\n\t\treturn false, nil\n\t}\n\tlog.Debug().Msg(\"interface does not match exclude-interface-regex\")\n\treturn true, nil\n}\n\ntype InterfaceConfig struct {\n\tConfig *Config `koanf:\"config\" yaml:\"config,omitempty\"`\n\tConfigs []*Config `koanf:\"configs\" yaml:\"configs,omitempty\"`\n}\n\nfunc NewInterfaceConfig() *InterfaceConfig {\n\treturn &InterfaceConfig{\n\t\tConfig: &Config{},\n\t\tConfigs: []*Config{},\n\t}\n}\n\nfunc (c *InterfaceConfig) Initialize(ctx context.Context) error {\n\tif len(c.Configs) == 0 {\n\t\tc.Configs = []*Config{c.Config}\n\t} else {\n\t\tfor _, subCfg := range c.Configs {\n\t\t\tmergeConfigs(ctx, *c.Config, subCfg)\n\t\t}\n\t}\n\n\treturn nil\n}\n\ntype ReplaceType struct {\n\tPkgPath string `koanf:\"pkg-path\" yaml:\"pkg-path,omitempty\"`\n\tTypeName string `koanf:\"type-name\" yaml:\"type-name,omitempty\"`\n}\n\ntype GoImports struct {\n\tAllErrors *bool `koanf:\"all-errors\" yaml:\"all-errors,omitempty\"`\n\tComments *bool `koanf:\"comments\" yaml:\"comments,omitempty\"`\n\tFormatOnly *bool `koanf:\"format-only\" yaml:\"format-only,omitempty\"`\n\tFragment *bool `koanf:\"fragment\" yaml:\"fragment,omitempty\"`\n\tLocalPrefix *string `koanf:\"local-prefix\" yaml:\"local-prefix,omitempty\"`\n\tTabIndent *bool `koanf:\"tab-indent\" yaml:\"tab-indent,omitempty\"`\n\tTabWidth *int `koanf:\"tab-width\" yaml:\"tab-width,omitempty\"`\n}\n\nfunc (g *GoImports) GetLocalPrefix() string {\n\treturn deref(g.LocalPrefix)\n}\n\nfunc (g *GoImports) Options() *imports.Options {\n\treturn &imports.Options{\n\t\tAllErrors: deref(g.AllErrors),\n\t\tComments: deref(g.Comments),\n\t\tFormatOnly: deref(g.FormatOnly),\n\t\tFragment: deref(g.Fragment),\n\t\tTabIndent: deref(g.TabIndent),\n\t\tTabWidth: deref(g.TabWidth),\n\t}\n}\n\ntype FormatterOptions struct {\n\tGoImports *GoImports `koanf:\"goimports\" yaml:\"goimports,omitempty\"`\n}\n\ntype Config struct {\n\tAll *bool `koanf:\"all\" yaml:\"all,omitempty\"`\n\tAnchors map[string]any `koanf:\"_anchors\" yaml:\"_anchors,omitempty\"`\n\tBuildTags *string `koanf:\"build-tags\" yaml:\"build-tags,omitempty\"`\n\tConfigFile *string `koanf:\"config\" yaml:\"config,omitempty\"`\n\tDir *string `koanf:\"dir\" yaml:\"dir,omitempty\"`\n\tExcludeSubpkgRegex []string `koanf:\"exclude-subpkg-regex\" yaml:\"exclude-subpkg-regex,omitempty\"`\n\tExcludeInterfaceRegex *string `koanf:\"exclude-interface-regex\" yaml:\"exclude-interface-regex,omitempty\"`\n\tFileName *string `koanf:\"filename\" yaml:\"filename,omitempty\"`\n\t// ForceFileWrite controls whether mockery will overwrite existing files when generating mocks. This is by default set to false.\n\tForceFileWrite *bool `koanf:\"force-file-write\" yaml:\"force-file-write,omitempty\"`\n\tFormatter *string `koanf:\"formatter\" yaml:\"formatter,omitempty\"`\n\tFormatterOptions *FormatterOptions `koanf:\"formatter-options\" yaml:\"formatter-options,omitempty\"`\n\tGenerate *bool `koanf:\"generate\" yaml:\"generate,omitempty\"`\n\tIncludeAutoGenerated *bool `koanf:\"include-auto-generated\" yaml:\"include-auto-generated,omitempty\"`\n\tIncludeInterfaceRegex *string `koanf:\"include-interface-regex\" yaml:\"include-interface-regex,omitempty\"`\n\tInPackage *bool `koanf:\"inpackage\" yaml:\"inpackage,omitempty\"`\n\tLogLevel *string `koanf:\"log-level\" yaml:\"log-level,omitempty\"`\n\tStructName *string `koanf:\"structname\" yaml:\"structname,omitempty\"`\n\tPkgName *string `koanf:\"pkgname\" yaml:\"pkgname,omitempty\"`\n\tRecursive *bool `koanf:\"recursive\" yaml:\"recursive,omitempty\"`\n\t// ReplaceType is a nested map of format map[\"package path\"][\"type name\"]*ReplaceType\n\tReplaceType map[string]map[string]*ReplaceType `koanf:\"replace-type\" yaml:\"replace-type,omitempty\"`\n\t// RequireTemplateSchemaExists sets whether mockery will fail if the specified\n\t// template did not have an associated JSON schema.\n\tRequireTemplateSchemaExists *bool `koanf:\"require-template-schema-exists\" yaml:\"require-template-schema-exists,omitempty\"`\n\tTemplate *string `koanf:\"template\" yaml:\"template,omitempty\"`\n\tTemplateData map[string]any `koanf:\"template-data\" yaml:\"template-data,omitempty\"`\n\t// TemplateSchema is the URL of the template's JSON schema.\n\tTemplateSchema *string `koanf:\"template-schema\" yaml:\"template-schema,omitempty\"`\n}\n\nfunc (c Config) koanfTagNames() map[string]struct{} {\n\ttags := map[string]struct{}{}\n\tt := reflect.TypeOf(c)\n\n\tfor i := 0; i < t.NumField(); i++ {\n\t\tfield := t.Field(i)\n\t\ttag := field.Tag.Get(\"koanf\")\n\t\tif tag != \"\" && tag != \"-\" {\n\t\t\ttags[tag] = struct{}{}\n\t\t}\n\t}\n\treturn tags\n}\n\nfunc (c *Config) FilePath() string {\n\treturn filepath.ToSlash(filepath.Clean(filepath.Join(*c.Dir, *c.FileName)))\n}\n\nfunc (c *Config) ShouldExcludeSubpkg(pkgPath string) bool {\n\tfor _, regex := range c.ExcludeSubpkgRegex {\n\t\tmatched, err := regexp.MatchString(regex, pkgPath)\n\t\tif err != nil {\n\t\t\tpanic(err)\n\t\t}\n\t\tif matched {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\nvar ErrInfiniteLoop = fmt.Errorf(\"infinite loop in template variables detected\")\n\n// ParseTemplates parses various templated strings\n// in the config struct into their fully defined values. This mutates\n// the config object passed. An *Interface object can be supplied to satisfy\n// template variables that need information about the original\n// interface being mocked. If this argument is nil, interface-specific template\n// variables will be set to the empty string. The srcPkg is also needed to\n// satisfy template variables regarding the source package.\nfunc (c *Config) ParseTemplates(\n\tctx context.Context,\n\t// ifaceFilePath is the absolute path of the original interface.\n\tifaceFilePath string,\n\tifaceName string,\n\tsrcPkg *packages.Package,\n) error {\n\tlog := zerolog.Ctx(ctx)\n\n\tmock := \"mock\"\n\tif ast.IsExported(ifaceName) {\n\t\tmock = \"Mock\"\n\t}\n\n\tworkingDir, err := os.Getwd()\n\tif err != nil {\n\t\treturn fmt.Errorf(\"get working directory: %w\", err)\n\t}\n\tworkingDir = filepath.ToSlash(workingDir)\n\tifaceFilePath = filepath.ToSlash(filepath.Clean(ifaceFilePath))\n\tinterfaceDirPath := filepath.ToSlash(filepath.Dir(ifaceFilePath))\n\tinterfaceDirRelativePath, err := filepath.Rel(filepath.FromSlash(workingDir), filepath.FromSlash(interfaceDirPath))\n\n\tvar interfaceDirRelative string\n\n\tif err != nil {\n\t\tlog.Debug().\n\t\t\tErr(err).\n\t\t\tStr(\"working-dir\", workingDir).\n\t\t\tStr(\"interfaceDirPath\", interfaceDirPath).\n\t\t\tStr(\"interface-dir-relative-path\", interfaceDirRelativePath).\n\t\t\tStr(\"iface-file-path\", ifaceFilePath).\n\t\t\tMsg(\"can't make path relative to working dir, setting to './'\")\n\t\tinterfaceDirRelative = \".\"\n\t} else {\n\t\tinterfaceDirRelativePath = filepath.ToSlash(interfaceDirRelativePath)\n\t\tlog.Debug().\n\t\t\tStr(\"working-dir\", workingDir).\n\t\t\tStr(\"interfaceDirPath\", interfaceDirPath).\n\t\t\tStr(\"interface-dir-relative-path\", interfaceDirRelativePath).\n\t\t\tMsg(\"found relative path\")\n\t\tinterfaceDirRelative = interfaceDirRelativePath\n\t}\n\n\t// data is the struct sent to the template parser\n\tdata := TemplateData{\n\t\tConfigDir: filepath.Dir(*c.ConfigFile),\n\t\tInterfaceDir: interfaceDirPath,\n\t\tInterfaceDirRelative: interfaceDirRelative,\n\t\tInterfaceFile: ifaceFilePath,\n\t\tInterfaceName: ifaceName,\n\t\tMock: mock,\n\t\tStructName: *c.StructName,\n\t\tSrcPackageName: srcPkg.Types.Name(),\n\t\tSrcPackagePath: srcPkg.Types.Path(),\n\t\tTemplate: *c.Template,\n\t}\n\t// These are the config options that we allow\n\t// to be parsed by the templater. The keys are\n\t// just labels we're using for logs/errors\n\ttemplateMap := map[string]*string{\n\t\t\"dir\": c.Dir,\n\t\t\"filename\": c.FileName,\n\t\t\"pkgname\": c.PkgName,\n\t\t\"structname\": c.StructName,\n\t\t\"template-schema\": c.TemplateSchema,\n\t}\n\n\tchangesMade := true\n\tfor i := 0; changesMade; i++ {\n\t\tif i >= 20 {\n\t\t\tlog.Error().Msg(\"infinite loop in template variables detected\")\n\t\t\tfor key, val := range templateMap {\n\t\t\t\tl := log.With().Str(\"variable-name\", key).Str(\"variable-value\", *val).Logger()\n\t\t\t\tl.Error().Msg(\"config variable value\")\n\t\t\t}\n\t\t\treturn ErrInfiniteLoop\n\t\t}\n\t\t// Templated variables can refer to other templated variables,\n\t\t// so we need to continue parsing the templates until it can't\n\t\t// be parsed anymore.\n\t\tchangesMade = false\n\n\t\tfor name, attributePointer := range templateMap {\n\t\t\toldVal := *attributePointer\n\n\t\t\tattributeTempl, err := template.New(\"config-template\").Funcs(template_funcs.FuncMap).Parse(*attributePointer)\n\t\t\tif err != nil {\n\t\t\t\treturn fmt.Errorf(\"failed to parse %s template: %w\", name, err)\n\t\t\t}\n\t\t\tvar parsedBuffer bytes.Buffer\n\n\t\t\tlog.Debug().Str(\"template-data\", fmt.Sprintf(\"%+v\", data)).Msg(\"executing template with data\")\n\t\t\tif err := attributeTempl.Execute(&parsedBuffer, data); err != nil {\n\t\t\t\treturn fmt.Errorf(\"failed to execute %s template: %w\", name, err)\n\t\t\t}\n\t\t\t*attributePointer = parsedBuffer.String()\n\t\t\tif *attributePointer != oldVal {\n\t\t\t\tchangesMade = true\n\t\t\t}\n\t\t}\n\t}\n\n\treturn nil\n}\n\nfunc (c *Config) GetReplacement(pkgPath string, typeName string) *ReplaceType {\n\tpkgMap := c.ReplaceType[pkgPath]\n\tif pkgMap == nil {\n\t\treturn nil\n\t}\n\treturn pkgMap[typeName]\n}\n\n// ExtractDirectiveConfig parses interface's documentation from a declaration\n// node and extracts mockery's directive configuration.\n//\n// Mockery directives are comments that start with \"mockery:\" and can appear\n// multiple times in the interface's doc comments. All such comments are combined\n// and interpreted as YAML configuration.\nfunc ExtractDirectiveConfig(ctx context.Context, decl *ast.GenDecl) (*Config, error) {\n\tif decl == nil || decl.Doc == nil {\n\t\treturn nil, nil\n\t}\n\n\tvar yamlConfig []string\n\n\t// Extract all mockery directive comments and build a YAML document\n\tfor _, doc := range decl.Doc.List {\n\t\t// Look for directive comments `//mockery:: ` and convert them to YAML\n\t\tif value, found := strings.CutPrefix(doc.Text, \"//mockery:\"); found && value != \"\" {\n\t\t\tyamlConfig = append(yamlConfig, value)\n\t\t}\n\t}\n\n\tif len(yamlConfig) == 0 {\n\t\treturn nil, nil\n\t}\n\n\t// Combine all YAML lines into a single document\n\tyamlDoc := strings.Join(yamlConfig, \"\\n\")\n\n\t// Parse the YAML directly into the directiveConfig struct\n\tdirectiveConfig := Config{}\n\tif err := yaml.Unmarshal([]byte(yamlDoc), &directiveConfig); err != nil {\n\t\treturn nil, fmt.Errorf(\"unmarshaling directive yaml: %w\", err)\n\t}\n\n\treturn &directiveConfig, nil\n}\n" }, { "path": "config/config_test.go", "content": "package config\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"go/ast\"\n\t\"os\"\n\t\"path\"\n\t\"testing\"\n\n\t\"github.com/spf13/pflag\"\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestNewRootConfig(t *testing.T) {\n\ttests := []struct {\n\t\tname string\n\t\tconfig string\n\t\twantErr error\n\t}{\n\t\t{\n\t\t\tname: \"unrecognized parameter\",\n\t\t\tconfig: `\npackages:\n github.com/foo/bar:\n config:\n unknown: param\n`,\n\t\t\twantErr: fmt.Errorf(\"'packages[github.com/foo/bar].config' has invalid keys: unknown\"),\n\t\t},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.name, func(t *testing.T) {\n\t\t\tconfigFile := path.Join(t.TempDir(), \"config.yaml\")\n\t\t\trequire.NoError(t, os.WriteFile(configFile, []byte(tt.config), 0o600))\n\n\t\t\tflags := pflag.NewFlagSet(\"test\", pflag.ExitOnError)\n\t\t\tflags.String(\"config\", \"\", \"\")\n\n\t\t\trequire.NoError(t, flags.Parse([]string{\"--config\", configFile}))\n\n\t\t\t_, _, err := NewRootConfig(context.Background(), flags)\n\t\t\tif tt.wantErr == nil {\n\t\t\t\tassert.NoError(t, err)\n\t\t\t} else {\n\t\t\t\tvar original error\n\t\t\t\tcursor := err\n\t\t\t\tfor cursor != nil {\n\t\t\t\t\toriginal = cursor\n\t\t\t\t\tcursor = errors.Unwrap(cursor)\n\t\t\t\t}\n\t\t\t\tassert.Equal(t, tt.wantErr.Error(), original.Error())\n\t\t\t}\n\t\t})\n\t}\n}\n\nfunc TestNewRootConfigUnknownEnvVar(t *testing.T) {\n\tt.Setenv(\"MOCKERY_UNKNOWN\", \"foo\")\n\tconfigFile := path.Join(t.TempDir(), \"config.yaml\")\n\trequire.NoError(t, os.WriteFile(configFile, []byte(`\npackages:\n github.com/vektra/mockery/v3:\n`), 0o600))\n\n\tflags := pflag.NewFlagSet(\"test\", pflag.ExitOnError)\n\tflags.String(\"config\", \"\", \"\")\n\n\trequire.NoError(t, flags.Parse([]string{\"--config\", configFile}))\n\t_, _, err := NewRootConfig(context.Background(), flags)\n\tassert.NoError(t, err)\n}\n\nfunc TestNewRootConfigDefaultFormatterOptions(t *testing.T) {\n\tconfigFile := path.Join(t.TempDir(), \"config.yaml\")\n\trequire.NoError(t, os.WriteFile(configFile, []byte(`\nformatter: goimports\n`), 0o600))\n\n\tflags := pflag.NewFlagSet(\"test\", pflag.ExitOnError)\n\tflags.String(\"config\", \"\", \"\")\n\n\trequire.NoError(t, flags.Parse([]string{\"--config\", configFile}))\n\tcfg, _, err := NewRootConfig(context.Background(), flags)\n\trequire.NoError(t, err)\n\trequire.NotNil(t, cfg.FormatterOptions.GoImports)\n\tassert.Equal(t, \"goimports\", *cfg.Formatter)\n\tassert.False(t, *cfg.FormatterOptions.GoImports.AllErrors)\n\tassert.True(t, *cfg.FormatterOptions.GoImports.Comments)\n\tassert.True(t, *cfg.FormatterOptions.GoImports.FormatOnly)\n\tassert.Equal(t, \"\", *cfg.FormatterOptions.GoImports.LocalPrefix)\n\tassert.True(t, *cfg.FormatterOptions.GoImports.TabIndent)\n\tassert.Equal(t, 8, *cfg.FormatterOptions.GoImports.TabWidth)\n}\n\nfunc TestExtractConfigFromDirectiveComments(t *testing.T) {\n\tconfigs := []struct {\n\t\tname string\n\t\tcommentLines []string\n\t\texpected *Config\n\t\texpectError bool\n\t}{\n\t\t{\n\t\t\tname: \"no directive comments\",\n\t\t\tcommentLines: []string{\n\t\t\t\t\"// This is a regular comment.\",\n\t\t\t\t\"// Another regular comment.\",\n\t\t\t},\n\t\t\texpected: nil,\n\t\t\texpectError: false,\n\t\t},\n\t\t{\n\t\t\tname: \"regular comments are not directive comments\",\n\t\t\tcommentLines: []string{\n\t\t\t\t\"// Directive comments *must* shouldn't have spaces after the slashes.\",\n\t\t\t\t\"// mockery:structname: MyMock\",\n\t\t\t},\n\t\t\texpected: nil,\n\t\t\texpectError: false,\n\t\t},\n\t\t{\n\t\t\tname: \"valid single-line directive comment\",\n\t\t\tcommentLines: []string{\n\t\t\t\t\"//mockery:structname: MyMock\",\n\t\t\t},\n\t\t\texpected: &Config{\n\t\t\t\tStructName: ptr(\"MyMock\"),\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\tname: \"valid multi-line directive comments\",\n\t\t\tcommentLines: []string{\n\t\t\t\t\"// Some initial comment.\",\n\t\t\t\t\"//mockery:structname: MyMock\",\n\t\t\t\t\"//mockery:filename: my_mock.go\",\n\t\t\t\t\"// Some trailing comment.\",\n\t\t\t},\n\t\t\texpected: &Config{\n\t\t\t\tStructName: ptr(\"MyMock\"),\n\t\t\t\tFileName: ptr(\"my_mock.go\"),\n\t\t\t},\n\t\t\texpectError: false,\n\t\t},\n\t\t{\n\t\t\tname: \"invalid directive comment format\",\n\t\t\tcommentLines: []string{\n\t\t\t\t\"//mockery:structname MyMock\", // Missing ':'\n\t\t\t},\n\t\t\texpected: nil,\n\t\t\texpectError: true,\n\t\t},\n\t\t{\n\t\t\tname: \"unsupported configuration key are ignored\",\n\t\t\tcommentLines: []string{\n\t\t\t\t\"//mockery:unknown_key: value\",\n\t\t\t},\n\t\t\texpected: &Config{},\n\t\t\texpectError: false,\n\t\t},\n\t\t{\n\t\t\tname: \"mixed valid and invalid directive comments\",\n\t\t\tcommentLines: []string{\n\t\t\t\t\"//mockery:structname: MyMock\",\n\t\t\t\t\"//mockery:invalid_format\", // Invalid\n\t\t\t\t\"//mockery:filename: my_mock.go\",\n\t\t\t},\n\t\t\texpected: nil,\n\t\t\texpectError: true,\n\t\t},\n\t}\n\n\tfor _, tt := range configs {\n\t\tt.Run(tt.name, func(t *testing.T) {\n\t\t\tcomments := make([]*ast.Comment, len(tt.commentLines))\n\t\t\tfor i, line := range tt.commentLines {\n\t\t\t\tcomments[i] = &ast.Comment{Text: line}\n\t\t\t}\n\n\t\t\tresult, err := ExtractDirectiveConfig(context.Background(), &ast.GenDecl{\n\t\t\t\tDoc: &ast.CommentGroup{\n\t\t\t\t\tList: comments,\n\t\t\t\t},\n\t\t\t})\n\t\t\tif tt.expectError {\n\t\t\t\trequire.Error(t, err)\n\t\t\t} else {\n\t\t\t\trequire.NoError(t, err)\n\t\t\t\tassert.Equal(t, tt.expected, result)\n\t\t\t}\n\t\t})\n\t}\n}\n\nfunc ptr[T any](s T) *T {\n\treturn &s\n}\n" }, { "path": "docs/configuration.md", "content": "Configuration\n==============\n\n`mockery init`\n--------------\n\n`mockery init [module_name]` is a useful command that can bootstrap you with a fully-functioning configuration set. For example, if we run:\n\n``` title=\"\"\n$ mockery init github.com/vektra/mockery/v3/internal/fixtures\n2025-03-14T23:06:12.535709000-05:00 INF writing to file file=.mockery.yml version=v0.0.0-dev\n2025-03-14T23:06:12.536493000-05:00 INF done version=v0.0.0-dev\n```\n
\n```yaml title=\".mockery.yml\"\nall: false\ndir: '{{.InterfaceDir}}'\nfilename: mocks_test.go\nforce-file-write: false\nformatter: goimports\nlog-level: info\nstructname: '{{.Mock}}{{.InterfaceName}}'\npkgname: '{{.SrcPackageName}}'\nrecursive: false\ntemplate: testify\npackages:\n github.com/vektra/mockery/v3/internal/fixtures:\n config:\n all: true\n```\n
\n\nWe can then run mockery against this config to generate the code:\n\n``` title=\"\"\n$ mockery\n2025-03-14T23:42:17.014113000-05:00 INF Starting mockery config-file=/Users/landon/git/LandonTClipp/mockery/.mockery.yaml version=v0.0.0-dev\n2025-03-14T23:42:17.014258000-05:00 INF Parsing configured packages... version=v0.0.0-dev\n2025-03-14T23:42:17.527483000-05:00 INF Done parsing configured packages. version=v0.0.0-dev\n[...]\n2025-03-14T23:42:17.531239000-05:00 INF Executing template file=/Users/landon/git/LandonTClipp/mockery/internal/fixtures/mocks_test.go version=v0.0.0-dev\n2025-03-14T23:42:17.690601000-05:00 INF Writing template to file file=/Users/landon/git/LandonTClipp/mockery/internal/fixtures/mocks_test.go version=v0.0.0-dev\n```\n
\n\n```title=\"\"\n$ head -n 17 /Users/landon/git/LandonTClipp/mockery/internal/fixtures/mocks_test.go\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n\npackage test\n\nimport (\n \"encoding/json\"\n \"io\"\n \"net/http\"\n \"unsafe\"\n\n mock \"github.com/stretchr/testify/mock\"\n http1 \"github.com/vektra/mockery/v3/internal/fixtures/12345678/http\"\n \"github.com/vektra/mockery/v3/internal/fixtures/constraints\"\n http0 \"github.com/vektra/mockery/v3/internal/fixtures/http\"\n test \"github.com/vektra/mockery/v3/internal/fixtures/redefined_type_b\"\n)\n```\n\n
\n\n??? tip \"Extended Example\"\n\n A more complex configuration example can be seen below:\n\n ```yaml\n all: False\n template-data:\n boilerplate-file: ./path/to/boilerplate.txt\n template: testify\n packages:\n github.com/vektra/example:\n config:\n # Make use of the template variables to place the mock in the same\n # directory as the original interface.\n dir: \"{{.InterfaceDir}}\"\n filename: \"mocks_test.go\"\n pkgname: \"{{.PackageName}}_test\"\n structname: \"{{.Mock}}{{.InterfaceName}}\"\n interfaces:\n Foo:\n Bar:\n config:\n # Make it unexported instead\n structname: \"mock{{.InterfaceName}}\"\n Baz:\n # Create two mock implementations of Baz with different names.\n configs:\n - filename: \"mocks_baz_one_test.go\"\n structname: \"MockBazOne\"\n - filename: \"mocks_baz_two_test.go\"\n structname: \"MockBazTwo\"\n io:\n config:\n dir: path/to/io/mocks\n filename: \"mocks_io.go\"\n ```\n\n These are the highlights of the config scheme:\n\n 1. The parameters are merged hierarchically\n 2. There are a number of template variables available to generalize config values.\n 3. The style of mock to be generated is specified using the [`template`](template/index.md) parameter.\n\nParameter Descriptions\n-----------------------\n\n[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/vektra/mockery/v3/config#Config)\n\n| name | templated | default | description |\n|--------------------------------------------------------|---------------------------|---------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `all` | :fontawesome-solid-x: | `#!yaml false` | Generate all interfaces for the specified packages. |\n| `_anchors` | :fontawesome-solid-x: | `#!yaml {}` | Unused by mockery, but allowed in the config schema so that you may define arbitrary yaml anchors. |\n| `config` | :fontawesome-solid-x: | `#!yaml \"\"` | Set the location of the mockery config file. |\n| `dir` | :fontawesome-solid-check: | `#!yaml \"{{.InterfaceDir}}\"` | The directory where the mock file will be outputted to. |\n| `exclude-subpkg-regex` | :fontawesome-solid-x: | `#!yaml []` | A list of regular expressions that denote which subpackages should be excluded when `#!yaml recursive: true` |\n| `exclude-interface-regex` | :fontawesome-solid-x: | `#!yaml \"\"` | When set along with `include-interface-regex`, then interfaces which match `include-interface-regex` but also match `exclude-interface-regex` will not be generated. If `all` is set, or if `include-interface-regex` is not set, then `exclude-interface-regex` has no effect. |\n| `filename` | :fontawesome-solid-check: | `#!yaml \"mocks_test.go\"` | The name of the file the mock will reside in. Multiple interfaces from the same source package can be placed into the same output file. |\n| `force-file-write` | :fontawesome-solid-x: | `#!yaml true` | When set to `#!yaml force-file-write: true`, mockery will forcibly overwrite any existing files. Otherwise, it will fail if the output file already exists. |\n| `formatter` | :fontawesome-solid-x: | `#!yaml \"goimports\"` | The formatter to use on the rendered template. Choices are: `gofmt`, `goimports`, `noop`. |\n| `formatter-options` | :fontawesome-solid-x: | `#!yaml nil` | Additional options for the formatter. See below. |\n| `generate` | :fontawesome-solid-x: | `#!yaml true` | Can be used to selectively enable/disable generation of specific interfaces. See [the related docs](generate-directive.md) for more details. |\n| [`include-auto-generated`](include-auto-generated.md){ data-preview } | :fontawesome-solid-x: | `#!yaml false` | When set to `true`, mockery will parse files that are auto-generated. This can only be specified in the top-level config or package-level config. |\n| `include-interface-regex` | :fontawesome-solid-x: | `#!yaml \"\"` | When set, only interface names that match the expression will be generated. This setting is ignored if `all: True` is specified in the configuration. To further refine the interfaces generated, use `exclude-interface-regex`. |\n| [`inpackage`](inpackage.md){ data-preview } | :fontawesome-solid-x: | `#!yaml nil` | When set, this overrides mockery's auto-detection logic when determining if the mock file is inside or outside of the mocked interface's package. |\n| `log-level` | :fontawesome-solid-x: | `#!yaml \"info\"` | Set the level of the logger |\n| `structname` | :fontawesome-solid-check: | `#!yaml \"{{.Mock}}{{.InterfaceName}}\"` | The name of the generated interface implementation. |\n| `packages` | :fontawesome-solid-x: | `#!yaml null` | A dictionary containing configuration describing the packages and interfaces to generate mocks for. |\n| `pkgname` | :fontawesome-solid-check: | `#!yaml \"{{.SrcPackageName}}\"` | The `#!go package name` given to the generated mock files. |\n| `recursive` | :fontawesome-solid-x: | `#!yaml false` | When set to `true` on a particular package, mockery will recursively search for all sub-packages and inject those packages into the config map. |\n| [`replace-type`](replace-type.md){ data-preview } | :fontawesome-solid-x: | `#!yaml {}` | Use this parameter to specify type replacements. |\n| `build-tags` | :fontawesome-solid-x: | `#!yaml \"\"` | A space-separated list of additional build tags to load packages. |\n| `require-template-schema-exists` | :fontawesome-solid-x: | `#!yaml true` | If set to `#!yaml true` and the schema failed to download, mockery will fail. Otherwise, mockery will not attempt to download the file nor do any schema validation. |\n| `template` | :fontawesome-solid-x: | `#!yaml \"\"` | The template to use. The choices are defined in the [Templates](../template/) section. |\n| `template-data` | :fontawesome-solid-x: | `#!yaml {}` | A `map[string]any` that provides arbitrary options to the template. Each template will have a different set of accepted keys. Refer to each template's documentation for more details. |\n| `template-schema` | :fontawesome-solid-check: | `#!yaml \"{{.Template}}.schema.json\"` | The URL of the JSON schema to apply to the `template-data` parameter. See the [template docs](./template/index.md#schemas){ data-preview } for more details. |\n\n\nThe `formatter-options` field allows formatter-specific configuration. Currently goimports is supported. For\nexample:\n\n```yaml title=\"mockery.yaml\"\n---\nformatter: goimports\nformatter-options:\n goimports:\n local-prefix: github.com/myrepo\n tab-indent: true\n```\n\nTemplates\n---------\n\nParameters marked as being templated have access to a number of template variables and functions through the Go [`text/template`](https://pkg.go.dev/text/template#hdr-Examples) system.\n\n### Variables\n\nThe variables provided are specified in the [`config.TemplateData`](https://pkg.go.dev/github.com/vektra/mockery/v3/config#TemplateData) struct.\n\n### Functions\n\nAll of the functions defined in [`StringManipulationFuncs`](https://pkg.go.dev/github.com/vektra/mockery/v3/shared#pkg-variables) are available to templated parameters.\n\nConfig sources\n--------------\n\nConfig can not only be specified from the `.yml` file, but also from CLI parameters (where available) and environment variables. For example, specifying a boolean value for a particular parameter called `enable-feature` from each config source would look like this:\n\n| source | value |\n|----------------------|------------------------------|\n| command line | `--enable-feature=true` |\n| Environment variable | `MOCKERY_ENABLE_FEATURE=True` |\n| yaml | `#!yaml enable-feature: True` |\n\nConfig is loaded from each source in the following order:\n\n1. Default values\n2. Environment variables\n3. Config file\n4. CLI Parameters\n" }, { "path": "docs/dev-notes.md", "content": "Developer Notes\n===============\n\nGo Upgrades\n------------\n\nThe mockery project supports the most recent TWO stable Go versions. Testing matrices will only run on the two most recent stable Go versions. However, given the [Go backwards-compatibility guarantee](https://go.dev/blog/compat), it's very likely projects built off of older Go 1.x syntax will continue to work in perpetuity.(1)\n{ .annotate }\n\n1. The caveat, being noted, is the same as the above linked backwards compatibility guarantee:\n\n > There are a few qualifications to that. First, compatibility means source compatibility. When you update to a new version of Go, you do have to recompile your code. Second, we can add new APIs, but not in a way that breaks existing code.\n\n > The end of the document warns, “[It] is impossible to guarantee that no future change will break any program.” Then it lays out a number of reasons why programs might still break.\n\n > For example, it makes sense that if your program depends on a buggy behavior and we fix the bug, your program will break. But we try very hard to break as little as possible and keep Go boring. There are two main approaches we’ve used so far: API checking and testing.\n\n\n\nGo Syntax Updates\n------------------\n\nWhen Go releases new syntax, there are two approaches that the mockery project will take:\n\n### Mockery does not need to interact with the new syntax\n\nIn such cases, the mockery project _only_ needs to upgrade its `golang.org/x/tools` dependency. This is necessary for the parsing step to simply not fail if it encounters new syntax. If mockery does not need to interact or understand this syntax, this dependency upgrade is likely all that's needed.\n\nTake for example the problems mentioned [here] when mockery upgraded to `go 1.24` in its `go.mod` file. In this situation, the project maintainers wanted to allow mockery to not crash when it parses syntax containing generic type alias syntax. However, the project did not _parse_ this syntax, so the only thing we needed to do was upgrade `golang.org/x/tools`.\n\n### Mockery _does_ need to interact with the new syntax\n\nThis situation was encountered in Go 1.18 when generics were introduced. [In this case](https://github.com/vektra/mockery/pull/456/files#diff-33ef32bf6c23acb95f5902d7097b7a1d5128ca061167ec0716715b0b9eeaa5f6), the project needed to be upgraded to `go 1.18` because mockery now had to directly parse and interpret generic types through the `go/ast` package. This was needed in conjunction with an upgrade of `golang.org/x/tools` that handles the actual parsing into `go/ast` data.\n\nIt's possible in future versions of Go that only the `toolchain` directive needs to be upgraded to allow mockery to use a more recent `go/ast` package. The purposes of the `go` directive is supposed to inform the compiler what features of the Go language the module uses in its own syntax, so in this case as long as mockery does not itself use generics, it can parse generic type information from _other_ projects without needing to pin its `go` directive to the relevant version.\n" }, { "path": "docs/faq.md", "content": "---\ntitle: FAQ\n---\n\nFrequently Asked Questions\n===========================\n\nHow do I generate mocks for external packages?\n----------------------------\n\nTo generate mocks for external packages, you first need to `go get` the package in your project. Then, simply include the external package in your mockery config. For example:\n\n```yaml\npackages:\n go.temporal.io/sdk:\n config:\n all: true\n recursive: true\n dir: mocks/{{.SrcPackagePath}}\n filename: mocks.go\n```\n\nerror: `interface not found in source`\n--------------------------------------\n\n!!! tip \"v3.6.0\"\n\n Version [`v3.6.0`](https://github.com/vektra/mockery/releases/tag/v3.6.0) of mockery fixed a bug in how files were detected to be auto-generated. Many users may find that mockery is suddenly unable to find mocks after upgrading to `v3.6.0`. Try providing:\n\n ```yaml title=\"\"\n include-auto-generated: true\n ```\n\n in your mockery config to see if this resolves the issue.\n\nThis log message indicates that an interface was explicitly listed in the mockery config but it was not found in the source. This can happen for a number of reasons:\n\n1. The package name was misspelled\n2. The interface name was misspelled\n3. The `#!yaml include-auto-generated: false` parameter was set (of which `false` is the default) and the interface lived in an auto-generated file.\n\nSetting `#!yaml log-level: debug` can provide a lot of insight into mockery's decision tree, so we recommend inspecting these logs for further clues into why the interface was not found.\n\nFor more details on `include-auto-generated`, visit [the related documentation](include-auto-generated.md).\n\nerror: `no go files found in root search path`\n---------------------------------------------\n\nWhen using the `packages` feature, `recursive: true` and you have specified a package that contains no `*.go` files, mockery is unable to determine the on-disk location of the package in order to continue the recursive package search. This appears to be a limitation of the [golang.org/x/tools/go/packages](https://pkg.go.dev/golang.org/x/tools/go/packages) package that is used to parse package metadata.\n\nThe solution is to create a `.go` file in the package's path and add a `package [name]` directive at the top. It doesn't matter what the file is called. This allows mockery to properly read package metadata.\n\n[Discussion](https://github.com/vektra/mockery/discussions/636)\n\ninternal error: package without types was imported\n---------------------------------------------------\n\n[https://github.com/vektra/mockery/issues/475](https://github.com/vektra/mockery/issues/475)\n\nThis issue indicates that you have attempted to use package in your dependency tree (whether direct or indirect) that uses Go language semantics that your currently-running Go version does not support. The solution:\n\n1. Update to the latest go version\n2. Delete all cached packages with `go clean -modcache`\n3. Reinstall mockery\n\nAdditionally, this issue only happens when compiling mockery from source, such as with `go install`. Our docs [recommend not to use `go install`](../installation#go-install) as the success of your build depends on the compatibility of your Go version with the semantics in use. You would not encounter this issue if using one of the installation methods that install pre-built binaries, like downloading the `.tar.gz` binaries, or through `brew install`.\n\nSemantic Versioning\n-------------------\n\nThe mockery project follows the standard Semantic Versioning Semantics. The versioning applies to the following areas:\n\n1. The shape of mocks generated by pre-curated templates.\n2. Functions and data provided to templates specified with `#!yaml template: \"file://\"`.\n3. Configuration options.\n\nMockery is not meant to be used as an imported library. Importing mockery code in external modules is not supported.\n\nMocking interfaces in `main`\n----------------------------\n\nWhen your interfaces are in the main package, you should supply the `--inpackage` flag.\nThis will generate mocks in the same package as the target code, avoiding import issues.\n\nmockery fails to run when `MOCKERY_VERSION` environment variable is set\n------------------------------------------------------------------------\n\nThis issue was first highlighted [in this GitHub issue](https://github.com/vektra/mockery/issues/391).\n\nmockery uses the viper package for configuration mapping and parsing. Viper is set to automatically search for all config variables specified in its config struct. One of the config variables is named `version`, which gets mapped to an environment variable called `MOCKERY_VERSION`. If you set this environment variable, mockery attempts to parse it into the `version` bool config.\n\nThis is an adverse effect of how our config parsing is set up. The solution is to rename your environment variable to something other than `MOCKERY_VERSION`.\n" }, { "path": "docs/generate-directive.md", "content": "# `//mockery:generate`\n\n:octicons-tag-24: v3.6.0\n\nAn alternative way to configure mocks is to use the `#!go //mockery:generate` directive. Mockery parses the doc comments and allows you to override configuration of specific interfaces in the source code. For example:\n\n```yaml title=\".mockery.yml\"\nall: false\npackages:\n github.com/vektra/mockery/v3/internal/fixtures/directive_comments_example:\n```\n\nWe set the top-level `#!yaml all: false` (which is the default value, anyway) to ensure that interfaces are by default not generated. We can then specify the doc comment directive to include the interface:\n\n```go title=\"interface.go\"\npackage directivecommentsexample\n\n// Requester is an interface that defines a method for making HTTP requests.\n//\n//mockery:generate: true\ntype Requester interface {\n\tGet(path string) (string, error)\n}\n```\n\n
\n``` title=\"\"\n2025-11-11T14:40:22.897665000-05:00 INF adding interface to collection collection=/Users/landonclipp/git/LandonTClipp/mockery/internal/fixtures/directive_comments_example/mocks_test.go interface=Requester package-path=github.com/vektra/mockery/v3/internal/fixtures/directive_comments_example version=v0.0.0-dev\n```\n
\n\nWe can also specify any config value that mockery supports. For example, let's rename the mock's structname:\n\n```\n// Requester is an interface that defines a method for making HTTP requests.\n//\n//mockery:generate: true\n//mockery:structname: MockFoo\ntype Requester interface {\n\tGet(path string) (string, error)\n}\n```\n\nThe new `structname` is applied as expected:\n\n```go\n// MockFoo is an autogenerated mock type for the Requester type\ntype MockFoo struct {\n\tmock.Mock\n}\n```\n\n!!! note\n\n The `#!yaml generate:` parameter is only effectual from within the doc comment itself. It has no effect if specified within the mockery config file." }, { "path": "docs/include-auto-generated.md", "content": "# `#!yaml include-auto-generated:`\n\n:octicons-tag-24: v3.5.0\n\nThe `#!yaml include-auto-generated:` parameter specifies whether or not mockery should include source files that appear to be auto-generated. By default, mockery will search for the presence of a string in the source code that appears before the `#!go package foo` declaration that matches the regular expression `^\\/\\/ Code generated by .* DO NOT EDIT(\\.?)( )*$`. Sometimes, users may wish to override this behavior and unconditionally include these source files. For example:\n\n```yaml title=\".mockery.yml\"\npackages:\n github.com/vektra/mockery/v3/internal/fixtures/include_auto_generated:\n config:\n include-auto-generated: true\n```\n\nYou may also set this at the top-level as such:\n\n```yaml title=\".mockery.yml\"\ninclude-auto-generated: true\npackages:\n github.com/vektra/mockery/v3/internal/fixtures/include_auto_generated:\n```\n\nIt is not possible to set this parameter at the interface level config because mockery performs this regular expression check before parsing the syntax in the source file. Allowing users to specify this on the interface-level config would require mockery to unconditionally parse all files, which defeats the performance benefits of excluding such auto-generated files in the first place.\n" }, { "path": "docs/index.md", "content": "mockery\n========\n\n[v3 Migration Docs](v3.md){ .md-button .md-button--stretch }\n\nMockery is a project that creates mock implementations of Golang interfaces. It inspects source code and generates implementations of the interface that aid in testing.\n\nIn addition to providing a number of different styles of mocks, mockery also allows users to provide their own template files that will then be rendered using a set of template data, methods, and functions that provide comprehensive typing information about the Go interface in question.\n\n![](assets/images/demo.gif)\n![](assets/images/MockScreenshot.png)\n\nWhy mockery?\n-------------\n\nWhen you have an interface like this:\n\n```golang title=\"db.go\"\ntype DB interface {\n\tGet(val string) string\n}\n```\n\nand a function that takes this interface:\n\n```golang title=\"db_getter.go\"\nfunc getFromDB(db DB) string {\n\treturn db.Get(\"ice cream\")\n}\n```\n\nWe can use simple configuration to generate a mock implementation for the interface:\n\n```yaml title=\".mockery.yaml\"\npackages:\n\tgithub.com/org/repo:\n\t\tinterfaces:\n\t\t\tDB:\n```\n\n
\n```bash\n$ mockery\n05 Mar 23 21:49 CST INF Starting mockery dry-run=false version=v3.0.0\n05 Mar 23 21:49 CST INF Using config: .mockery.yaml dry-run=false version=v3.0.0\n05 Mar 23 21:49 CST INF Generating mock dry-run=false interface=DB qualified-name=github.com/org/repo version=v3.0.0\n```\n
\n\nWe can then use the mock object in a test:\n\n```go title=\"db_getter_test.go\"\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc Test_getFromDB(t *testing.T) {\n\tmockDB := NewMockDB(t)\n\tmockDB.EXPECT().Get(\"ice cream\").Return(\"chocolate\").Once()\n\tflavor := getFromDB(mockDB)\n\tassert.Equal(t, \"chocolate\", flavor)\n}\n```\n\nWhy use mockery?\n----------------\n\n1. You gain access to a number of pre-curated mock implementations that can be used in testing. This includes traditional \"mockery-style\" mocks, as well as other styles from the open source community such as from https://github.com/matryer/moq. Such mocks allow you to quickly define how the implementation should behave under test without having to manually curate your own mocks/stubs/fakes.\n2. Mockery benefits from a large number of performance improvements that almost all other Go code-generation projects currently have not employed. This means that it's orders of magnitude faster for large codebases.\n3. Mockery provides a comprehensive, centralized, flexible, and simple configuration scheme driven off of yaml instead of relying on sprawling `//go:generate` commands.\n4. Mockery is a code-generation framework. While its original goal is to provide mock implementations for testing purposes, users can supply their own templates to auto-generate any kind of code that needs to be based off of interfaces.\n5. A number of high profile companies, projects, and communities trust Mockery.\n\nWho uses mockery?\n------------------\n\n
\n-
\n\t[![Kubernetes logo](assets/images/logos/kubernetes.svg){ class=\"center\" width=\"100\" }](https://github.com/kubernetes/kubernetes)\n\t
[Kubernetes](https://github.com/search?q=repo%3Akubernetes%2Fkubernetes%20mockery&type=code)
\n
\n-
\n\t[![Grafana logo](assets/images/logos/grafana.svg){ class=\"center\" width=\"100\" }](https://github.com/grafana/grafana)\n\t
[Grafana](https://github.com/search?q=repo%3Agrafana%2Fgrafana%20mockery&type=code)
\n
\n-
\n\t[![Google logo](assets/images/logos/google.svg){ class=\"center\" width=\"100\" }](https://github.com/google/skia)\n\t
[Google skia](https://github.com/google/skia)
\n
\n-
\n\t[![Google logo](assets/images/logos/google.svg){ class=\"center\" width=\"100\" }](https://github.com/google/syzkaller)\n\t
[Google syzkaller](https://github.com/google/syzkaller)
\n
\n-
\n\t[![Hashicorp logo](assets/images/logos/hashicorp.svg){ class=\"center\" width=\"100\" }](https://github.com/search?q=org%3Ahashicorp%20mockery&type=code)\n\t
[Hashicorp](https://github.com/search?q=org%3Ahashicorp%20mockery&type=code)
\n
\n-
\n\t[![Jaeger logo](assets/images/logos/jaeger.png){ class=\"center\" width=\"300\" }](https://github.com/jaegertracing/jaeger)\n\t
[Jaegertracing](https://github.com/jaegertracing/jaeger)
\n
\n-
\n\t[![Splunk logo](assets/images/logos/splunk.svg){ class=\"center\" width=\"300\" }](https://github.com/splunk/kafka-mq-go)\n\t
[Splunk kafka-mq-go](https://github.com/splunk/kafka-mq-go)
\n
\n-
\n\t[![Ignite Logo](assets/images/logos/ignite-cli.png){ class=\"center\" width=\"300\" }](https://github.com/ignite/cli)\n
\n-
\n\t[![Tendermint Logo](assets/images/logos/tendermint.svg){ class=\"center\" width=\"300\" }](https://github.com/tendermint/tendermint)\n
\n-
\n\t[![Datadog logo](assets/images/logos/datadog.svg){ class=\"center\" width=\"300\" }](https://github.com/DataDog/datadog-agent)\n
\n- [![Seatgeek Logo](assets/images/logos/seatgeek.svg)](https://seatgeek.com)\n-
\n [![Amazon logo](assets/images/logos/amazon.svg){ class=\"center\" width=\"300\" }](https://github.com/eksctl-io/eksctl)\n\t
[eksctl](https://github.com/eksctl-io/eksctl)
\n
\n-
\n [![MongoDB Logo](assets/images/logos/mongodb.svg){ class=\"center\" width=\"300\" }](https://github.com/search?q=org%3Amongodb%20mockery&type=code)\n
\n-
\n\t[![go-task logo](assets/images/logos/go-task.svg){ class=\"center\" width=\"300\" }](https://taskfile.dev/)\n\t
[Task](https://taskfile.dev/)\n \n -
\n\t[![cerbos logo](assets/images/logos/cerbos.png){ class=\"center\" width=\"300\" }](https://github.com/cerbos/cerbos)\n \n
\n\n\n\n[Get Started](installation.md){ .md-button .md-button--primary .md-button--stretch }\n" }, { "path": "docs/inpackage.md", "content": "# `#!yaml inpackage:`\n\n:octicons-tag-24: v3.5.0\n\nThe `#!yaml inpackage` parameter overrides mockery's auto-detection logic that determines whether an output file resides inside or outside of the package of the original interface. Normally, import statements and type qualifiers (such as `srcpkg.TypeName`, the qualified variant of `TypeName`) are added when the mock references types in the original package _and_ the mock resides outside of that package. For example:\n\n```go\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/inpackage\"\n)\n\n// Bar provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Bar() inpackage.InternalStringType {\n```\n\nWhen `#!yaml inpackage: true` is set, the `\"github.com/vektra/mockery/v3/internal/fixtures/inpackage\"` import is removed and the type will be referred to as its unqualified name. For example:\n\n```go\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// Bar provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Bar() InternalStringType {\n```" }, { "path": "docs/installation.md", "content": "Getting Started\n================\n\nInstallation\n-------------\n\n### GitHub Release recommended\n\nVisit the [releases page](https://github.com/vektra/mockery/releases) to download one of the pre-built binaries for your platform.\n\n### go install\n\nSupported, but not recommended: [see wiki page](https://github.com/vektra/mockery/wiki/Installation-Methods#go-install) and [related discussions](https://github.com/vektra/mockery/pull/456).\n\n
\n\n!!! warning\n\n Do _not_ use `@latest` as this will pull from the latest, potentially untagged, commit on master.\n\n### Docker\n\nUse the [Docker image](https://hub.docker.com/r/vektra/mockery)\n\n docker pull vektra/mockery\n\nGenerate all the mocks for your project:\n\n\tdocker run -v \"$PWD\":/src -w /src vektra/mockery:3\n\n### Homebrew\n\nInstall through [brew](https://brew.sh/)\n\n brew install mockery\n brew upgrade mockery\n\n\n\n" }, { "path": "docs/javascripts/tablesort.js", "content": "document$.subscribe(function() {\n var tables = document.querySelectorAll(\"article table:not([class])\")\n tables.forEach(function(table) {\n new Tablesort(table)\n })\n })\n" }, { "path": "docs/replace-type.md", "content": "# `#!yaml replace-type:`\n\n:octicons-tag-24: v3.0.0\n\nThe `#!yaml replace-type:` parameter allows you to replace a type in the generated mocks with another type. Take for example the following interface:\n\n```go title=\"interface.go\"\npackage replace_type\n\nimport (\n \"github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt1\"\n \"github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt2\"\n)\n\ntype RType interface {\n Replace1(f rt1.RType1)\n}\n```\n\nYou can selectively replace the `rt1.RType1` with a new type if so desired. For example:\n\n### Schema\n\n```yaml title=\".mockery.yml\"\nreplace-type:\n github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt1:\n RType1:\n pkg-path: github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt2\n type-name: RType2\n```\n\n### Result\n\nThe mock will now replace all instances of `rt1.RType1` with `rt2.RType2`. You can see the before and after of `mockery`-style mocks:\n\n=== \"before\"\n\n ```go\n // Replace2 provides a mock function for the type RTypeReplaced1\n func (_mock *RTypeReplaced1) Replace1(f rt1.RType1) {\n _mock.Called(f)\n return\n }\n ```\n\n=== \"after\"\n\n ```go\n // Replace2 provides a mock function for the type RTypeReplaced1\n func (_mock *RTypeReplaced1) Replace1(f rt2.RType2) {\n _mock.Called(f)\n return\n }\n ```\n\n## Background\n\nThis parameter is useful if you need to need to work around packages that use internal types. Take for example the situation found [here](https://github.com/vektra/mockery/issues/864#issuecomment-2567788637), noted by [RangelReale](https://github.com/RangelReale).\n" }, { "path": "docs/requirements.txt", "content": "mike @ git+https://github.com/jimporter/mike.git\nmkdocs\nmkdocs-glightbox\nmkdocs-material==9.7.1\nmkdocs-open-in-new-tab\ncairosvg\npillow\nmkdocs-table-reader-plugin\n" }, { "path": "docs/stylesheets/extra.css", "content": ".md-button--stretch {\n width: 100%;\n text-align: center;\n}\n\n.center {\n display: block;\n margin-left: auto;\n margin-right: auto;\n margin-bottom: auto;\n}\n\n.md-grid {\n max-width: 200em;\n}\n" }, { "path": "docs/template/index.md", "content": "Templates\n=========\n\nMockery, in its essence, renders templates. This project provides a number of pre-curated templates that you can select with the `#!yaml template:` config parameter. Each template will render a specific kind of implementation of the interface in question. Historically, mocks (used in testing) are common to generate, but anything that implements the interface is fair game.\n\nMockery provides a few embedded templates you can render, or you can use a URL to specify a remotely-hosted template.\n\n## Template Options\n\n### [`#!yaml template: \"testify\"`](testify.md#description)\n\n[`testify`](testify.md#description){ data-preview } templates generate powerful, testify-based mock objects. They allow you to create expectations using argument-to-return-value matching logic.\n\n### [`#!yaml template: \"matryer\"`](matryer.md#description)\n\n[`matryer`](matryer.md#description){ data-preview } templates draw from the mocks generated from the project at https://github.com/matryer/moq. This project was folded into mockery, and thus moq-style mocks can be natively generated from within mockery.\n\nMocks generated using this template allow you to define precise functions to be run.\n\n### `#!yaml template: \"file://\"`\n\nYou may also provide mockery a path to your own file using the `file://` protocol specifier. The string after `file://` will be the relative or absolute path of your template.\n\nThe templates are rendered with the data as shown in the [section below](#template-data).\n\nYou can see examples of how the mockery project utilizes the template system to generate the different mock styles:\n\n- [`matryer.templ`](https://github.com/vektra/mockery/blob/v3/internal/mock_matryer.templ)\n- [`testify.templ`](https://github.com/vektra/mockery/blob/v3/internal/mock_testify.templ)\n\n### `#!yaml template: \"https://\"`\n\nYou can also host templates remotely. This allows you to specify something like:\n\n```yaml title=\"\"\ntemplate: https://raw.githubusercontent.com/vektra/mockery/refs/tags/v3.0.0-beta.8/e2e/test_template_exercise/exercise.templ\ntemplate-schema: https://raw.githubusercontent.com/vektra/mockery/refs/tags/v3.0.0-beta.8/e2e/test_template_exercise/exercise.templ.schema.json\n```\n\n!!! note \"Note on Versioning\"\n\n Templates hosted remotely should be versioned just like any other piece of code. We recommend hosting the template on a git repo so that you may reference explicit tags.\n\n It's best practice to maintain 3 sets of tags:\n\n 1. Major: `v3`\n 2. Minor: `v3.1`\n 3. Patch: `v3.1.2`\n\n This will give consumers of your template the ability to specify which level of granularity they want to track versions.\n\nThe non-TLS variant is also supported: `#!yaml template: \"http://\"`, but not recommended for obvious reasons.\n\n## Schemas\n\nTemplates can provide a JSON Schema file that describes the format of the `TemplateData` parameter. Mockery auto-discovers the location of these schema files by appending `.schema.json` to the path of the template. For example, if you provide to mockery `#!yaml template: file://./path/to/template.tmpl`, it will look for a file at `file://./path/to/template.tmpl.schema.json`. If found, this schema will be applied to the `TemplateData` type sent to the template.\n\nTo get started with JSON Schema, you can borrow an example JSON document used for the mockery project itself:\n\n```json title=\"schema.json\"\n{\n \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n \"title\": \"vektra/mockery testify mock\",\n \"type\": \"object\",\n \"additionalProperties\": false,\n \"properties\": {\n \"boilerplate-file\": {\n \"type\": \"string\"\n },\n \"mock-build-tags\": {\n \"type\": \"string\"\n },\n \"unroll-variadic\": {\n \"type\": \"boolean\"\n }\n },\n \"required\": []\n}\n```\n\nNote that the `#!json \"additionalProperties\": false` parameter is crucial to ensure only the specified parameters exist in the configured `#!yaml template-data: {}` map.\n\n!!! tip \"`template-schema`\"\n\n You can specify a custom schema path using the [`#!yaml template-schema:`](../configuration.md#parameter-descriptions)parameter.\n\n## Template Data\n\nTemplates are rendered with functions and data you can utilize to generate your mocks. Links are shown below:\n\n| Description | Link |\n|-|-|\n| Functions | [![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/vektra/mockery/v3/template_funcs#pkg-variables) | \n| Data | [![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/vektra/mockery/v3/template#Data) |\n" }, { "path": "docs/template/matryer.md", "content": "---\ntitle: matryer\n---\n\n`matryer` mocks are derived from the project at https://github.com/matryer/moq. These mocks create a struct that has a function field for each method, which you can declare in your test code.\n\n## Description\n\n=== \"Interface\"\n\n ```go\n package test\n\n type Requester interface {\n Get(path string) (string, error)\n }\n ```\n\n\n=== \"Example Usage\"\n\n ```go\n func TestRequesterMoq(t *testing.T) {\n m := &MoqRequester{\n GetFunc: func(path string) (string, error) {\n fmt.Printf(\"Go path: %s\\n\", path)\n return path + \"/foo\", nil\n },\n }\n result, err := m.Get(\"/path\")\n assert.NoError(t, err)\n assert.Equal(t, \"/path/foo\", result)\n }\n ```\n\n=== \"`.mockery.yml`\"\n\n ```yaml\n template: matryer\n packages:\n github.com/vektra/mockery/v3/pkg/fixtures:\n config:\n dir: \"{{.InterfaceDir}}\"\n filename: \"mocks_moq.go\"\n pkgname: \"test\"\n structname: \"Moq{{.InterfaceName}}\"\n interfaces:\n Requester:\n ```\n\n=== \"`mocks_matryer.go`\"\n\n ```go\n // Code generated by mockery; DO NOT EDIT.\n // github.com/vektra/mockery\n\n package test\n\n import (\n \"sync\"\n )\n\n // Ensure, that MoqRequester does implement Requester.\n // If this is not the case, regenerate this file with moq.\n var _ Requester = &MoqRequester{}\n\n // MoqRequester is a mock implementation of Requester.\n //\n //\tfunc TestSomethingThatUsesRequester(t *testing.T) {\n //\n //\t\t// make and configure a mocked Requester\n //\t\tmockedRequester := &MoqRequester{\n //\t\t\tGetFunc: func(path string) (string, error) {\n //\t\t\t\tpanic(\"mock out the Get method\")\n //\t\t\t},\n //\t\t}\n //\n //\t\t// use mockedRequester in code that requires Requester\n //\t\t// and then make assertions.\n //\n //\t}\n type MoqRequester struct {\n // GetFunc mocks the Get method.\n GetFunc func(path string) (string, error)\n\n // calls tracks calls to the methods.\n calls struct {\n // Get holds details about calls to the Get method.\n Get []struct {\n // Path is the path argument value.\n Path string\n }\n }\n lockGet sync.RWMutex\n }\n\n // Get calls GetFunc.\n func (mock *MoqRequester) Get(path string) (string, error) {\n // ...\n }\n\n // GetCalls gets all the calls that were made to Get.\n // Check the length with:\n //\n //\tlen(mockedRequester.GetCalls())\n func (mock *MoqRequester) GetCalls() []struct {\n Path string\n } {\n // ...\n }\n\n ```\n\n\nmatryer-style mocks are far simpler, and probably more intuitive, than testify-style mocks. All that's needed is to define the function that will be run when the mock's method is called.\n\n## `template-data`\n\n`moq` accepts the following `#!yaml template-data:` keys:\n\n| key | type | description |\n|-----|------|-------------|\n| `boilerplate-file` | `#!yaml string` | Specify a path to a file that contains comments you want displayed at the top of all generated mock files. This is commonly used to display license headers at the top of your source code. |\n| `mock-build-tags` | `#!yaml string` | Set the build tags of the generated mocks. Read more about the [format](https://pkg.go.dev/cmd/go#hdr-Build_constraints). |\n| `skip-ensure` | `#!yaml bool` | Suppress mock implementation check, avoid import cycle if mocks generated outside of the tested package. |\n| `stub-impl` | `#!yaml bool` | Return zero values when no mock implementation is provided, do not panic. |\n| `with-resets` | `#!yaml bool` | Generates methods that allow resetting calls made to the mocks. |\n\n\n### Schema\n\n```json\n--8<-- \"internal/mock_matryer.templ.schema.json\"\n```" }, { "path": "docs/template/testify.md", "content": "---\ntitle: testify\n---\n\nFeatures for `#!yaml template: testify`.\n\nChoosing this template will render a traditional \"mockery-style\" template. The\nsection below shows what will be rendered for the given interface.\n\n## Description\n\n=== \"Interface\"\n\n ```go\n package test\n\n type Requester interface {\n Get(path string) (string, error)\n }\n ```\n\n=== \"Example Usage\"\n\n ```go\n package test\n\n import (\n \"testing\"\n\n \"github.com/stretchr/testify/assert\"\n )\n\n func TestRequesterMock(t *testing.T) {\n m := NewMockRequester(t)\n m.EXPECT().Get(\"foo\").Return(\"bar\", nil).Once()\n retString, err := m.Get(\"foo\")\n assert.NoError(t, err)\n assert.Equal(t, retString, \"bar\")\n }\n ```\n\n=== \"`.mockery.yml`\"\n\n ```yaml\n template: testify\n packages:\n github.com/vektra/mockery/v3/pkg/fixtures:\n config:\n dir: \"{{.InterfaceDir}}\"\n filename: \"mocks.go\"\n pkgname: \"test\"\n structname: \"Mock{{.InterfaceName}}\"\n interfaces:\n Requester:\n ```\n\n=== \"`mocks.go`\"\n\n ```go\n // Code generated by mockery; DO NOT EDIT.\n // github.com/vektra/mockery\n\n package test\n\n import (\n mock \"github.com/stretchr/testify/mock\"\n )\n\n\n // NewRequester creates a new instance of Requester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n // The first argument is typically a *testing.T value.\n func NewRequester (t interface {\n mock.TestingT\n Cleanup(func())\n }) *Requester {\n // ...\n }\n\n\n // Requester is an autogenerated mock type for the Requester type\n type Requester struct {\n mock.Mock\n }\n\n type Requester_Expecter struct {\n mock *mock.Mock\n }\n\n func (_m *Requester) EXPECT() *Requester_Expecter {\n // ...\n }\n\n\n\n // Get provides a mock function for the type Requester\n func (_mock *Requester) Get(path string) (string, error) {\n // ...\n }\n\n\n\n // Requester_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\n type Requester_Get_Call struct {\n *mock.Call\n }\n\n\n\n // Get is a helper method to define mock.On call\n // - path\n func (_e *Requester_Expecter) Get(path interface{}, ) *Requester_Get_Call {\n // ...\n }\n\n func (_c *Requester_Get_Call) Run(run func(path string)) *Requester_Get_Call {\n // ...\n }\n\n func (_c *Requester_Get_Call) Return(s string, err error) *Requester_Get_Call {\n // ...\n }\n\n func (_c *Requester_Get_Call) RunAndReturn(run func(path string)(string, error)) *Requester_Get_Call {\n // ...\n }\n ```\n\nAs you can see, this mock utilizes `github.com/stretchr/testify` under the hood and registers call expectations with testify. When the mock receives a call to `Get()`, it retrieves the expected value from testify to be returned.\n\nThis style of mock also has other interesting methods:\n\n=== \"`#!go Run()`\"\n\n Run a side effect when the argument matches.\n\n ```go\n func TestRequesterMockRun(t *testing.T) {\n m := NewMockRequester(t)\n m.EXPECT().Get(mock.Anything).Return(\"\", nil)\n m.EXPECT().Get(mock.Anything).Run(func(path string) {\n fmt.Printf(\"Side effect! Argument is: %s\", path)\n })\n retString, err := m.Get(\"hello\")\n assert.NoError(t, err)\n assert.Equal(t, retString, \"\")\n }\n ```\n\n=== \"`#!go RunAndReturn()`\"\n\n Run a function to perform side-effects, and return the result of the function.\n\n ```go\n func TestRequesterMockRunAndReturn(t *testing.T) {\n m := NewMockRequester(t)\n m.EXPECT().Get(mock.Anything).RunAndReturn(func(path string) (string, error) {\n return path + \" world\", nil\n })\n retString, err := m.Get(\"hello\")\n assert.NoError(t, err)\n assert.Equal(t, retString, \"hello world\")\n }\n ```\n\n=== \"`github.com/stretchr/testify/mock.Mock`\"\n\n Because the mock embeds the testify `Mock` object, you can all any methods on that as well.\n\n ```go\n func TestRequesterMockTestifyEmbed(t *testing.T) {\n m := NewMockRequester(t)\n m.EXPECT().Get(mock.Anything).Return(\"\", nil).Twice()\n m.Get(\"hello\")\n m.Get(\"world\")\n assert.Equal(t, len(m.Mock.Calls), 2)\n }\n ```\n## `template-data`\n\n| key | type | description |\n|-----|------|-------------|\n| `boilerplate-file` | `#!yaml string` | Specify a path to a file that contains comments you want displayed at the top of all generated mock files. This is commonly used to display license headers at the top of your source code. |\n| `mock-build-tags` | `#!yaml string` | Set the build tags of the generated mocks. Read more about the [format](https://pkg.go.dev/cmd/go#hdr-Build_constraints). |\n| `unroll-variadic` | `#!yaml bool` | If set to `#!yaml unroll-variadic: true`, will expand the variadic argument to testify using the `...` syntax. See [notes](#variadic-arguments) for more details. |\n\n### Schema\n\n```json\n--8<-- \"internal/mock_testify.templ.schema.json\"\n```\n\n## Features\n\n### Mock Constructors\n\n:octicons-tag-24: v2.11.0\n\nAll mock objects have constructor functions. These constructors do basic test setup so that the expectations you set in the code are asserted before the test exits.\n\nPreviously something like this would need to be done:\n```go\nfactory := &mocks.Factory{}\nfactory.Test(t) // so that mock does not panic when a method is unexpected\ndefer factory.AssertExpectations(t)\n```\n\nInstead, you may simply use the constructor:\n```go\nfactory := mocks.NewFactory(t)\n```\n\nThe constructor sets up common functionalities automatically\n\n- The `AssertExpectations` method is registered to be called at the end of the tests via `t.Cleanup()` method.\n- The testing.TB interface is registered on the `mock.Mock` so that tests don't panic when a call on the mock is unexpected.\n\n\n### Expecter Structs\n\n:octicons-tag-24: v2.10.0 · `with-expecter: True`\n\nMockery now supports an \"expecter\" struct, which allows your tests to use type-safe methods to generate call expectations. When enabled through the `with-expecter: True` mockery configuration, you can enter into the expecter interface by simply calling `.EXPECT()` on your mock object.\n\nFor example, given an interface such as\n```go\ntype Requester interface {\n\tGet(path string) (string, error)\n}\n```\n\nYou can use the expecter interface as such:\n```go\nrequesterMock := mocks.NewRequester(t)\nrequesterMock.EXPECT().Get(\"some path\").Return(\"result\", nil)\n```\n\nA `RunAndReturn` method is also available on the expecter struct that allows you to dynamically set a return value based on the input to the mock's call.\n\n```go\nrequesterMock.EXPECT().\n\tGet(mock.Anything).\n\tRunAndReturn(func(path string) (string, error) {\n\t\tfmt.Println(path, \"was called\")\n\t\treturn (\"result for \" + path), nil\n\t})\n```\n\n!!! note\n\n\tNote that the types of the arguments on the `EXPECT` methods are `interface{}`, not the actual type of your interface. The reason for this is that you may want to pass `mock.Any` as an argument, which means that the argument you pass may be an arbitrary type. The types are still provided in the expecter method docstrings.\n\n\n### Return Value Providers\n\n:octicons-tag-24: v2.20.0\n\nReturn Value Providers can be used one of two ways. You may either define a single function with the exact same signature (number and type of input and return parameters) and pass that as a single value to `Return`, or you may pass multiple values to `Return` (one for each return parameter of the mocked function.) If you are using the second form, for each of the return values of the mocked function, `Return` needs a function which takes the same arguments as the mocked function, and returns one of the return values. For example, if the return argument signature of `passthrough` in the above example was instead `(string, error)` in the interface, `Return` would also need a second function argument to define the error value:\n\n```go\ntype Proxy interface {\n passthrough(ctx context.Context, s string) (string, error)\n}\n```\n\nFirst form:\n\n```go\nproxyMock := mocks.NewProxy(t)\nproxyMock.On(\"passthrough\", mock.AnythingOfType(\"context.Context\"), mock.AnythingOfType(\"string\")).\nReturn(\n func(ctx context.Context, s string) (string, error) {\n return s, nil\n }\n)\n```\n\n\nSecond form:\n\n```go\nproxyMock := mocks.NewProxy(t)\nproxyMock.On(\"passthrough\", mock.AnythingOfType(\"context.Context\"), mock.AnythingOfType(\"string\")).\nReturn(\n func(ctx context.Context, s string) string {\n return s\n },\n func(ctx context.Context, s string) error {\n return nil\n },\n)\n```\n\n## Notes\n\n### Variadic Arguments\n\nConsider if we have a function `#!go func Bar(message ...string) error`. A typical assertion might look like this:\n\n```go\nfunc TestFoo(t *testing.T) {\n m := NewMockFoo(t)\n m.On(\"Bar\", \"hello\", \"world\").Return(nil)\n```\n\nWe might also want to make an assertion that says \"any number of variadic arguments\":\n\n```go\nm.On(\"Bar\", mock.Anything).Return(nil)\n```\n\nHowever, what we've given to mockery is ambiguous because it is impossible to distinguish between these two intentions:\n\n1. Any number of variadic arguments of any value\n2. A single variadic argument of any value\n\nThis is fixed in [#359](https://github.com/vektra/mockery/pull/359) where you can provide `unroll-variadic: False` to get back to the old behavior. Thus, if you want to assert (1), you can then do:\n\n```go\nm.On(\"Bar\", mock.Anything).Return(nil)\n```\n\nIf you want to assert (2), you must set `unroll-variadic: True`. Then this assertion's intention will be modified to mean the second case:\n\n```go\nm.On(\"Bar\", mock.Anything).Return(nil)\n```\n\nAn upstream patch to `testify` is currently underway to allow passing `mock.Anything` directly to the variadic slice: [https://github.com/stretchr/testify/pull/1348](https://github.com/stretchr/testify/pull/1348)\n\nIf this is merged, it would become possible to describe the above two cases respectively:\n\n```go\n// case 1\nm.On(\"Bar\", mock.Anything).Return(nil)\n// case 2\nm.On(\"Bar\", []interface{}{mock.Anything}).Return(nil)\n```\n\nReferences:\n\n- [https://github.com/vektra/mockery/pull/359](https://github.com/vektra/mockery/pull/359)\n- [https://github.com/vektra/mockery/pull/123](https://github.com/vektra/mockery/pull/123)\n- [https://github.com/vektra/mockery/pull/550](https://github.com/vektra/mockery/pull/550)\n- [https://github.com/vektra/mockery/issues/541](https://github.com/vektra/mockery/issues/541)\n\n### Multiple Expectations With Identical Arguments\n\nThere might be instances where you want a mock to return different values on successive calls that provide the same arguments. For example, we might want to test this behavior:\n\n```go\n// Return \"foo\" on the first call\ngetter := NewGetter()\nassert(t, \"foo\", getter.Get(\"key\"))\n\n// Return \"bar\" on the second call\nassert(t, \"bar\", getter.Get(\"key\"))\n```\n\nThis can be done by using the `.Once()` method on the mock call expectation:\n\n```go\nmockGetter := NewMockGetter(t)\nmockGetter.EXPECT().Get(mock.anything).Return(\"foo\").Once()\nmockGetter.EXPECT().Get(mock.anything).Return(\"bar\").Once()\n```\n\nOr you can identify an arbitrary number of times each value should be returned:\n\n```go\nmockGetter := NewMockGetter(t)\nmockGetter.EXPECT().Get(mock.anything).Return(\"foo\").Times(4)\nmockGetter.EXPECT().Get(mock.anything).Return(\"bar\").Times(2)\n```\n\nNote that with proper Go support in your IDE, all the available methods are self-documented in autocompletion help contexts.\n" }, { "path": "docs/v3.md", "content": "v3 Migration\n==========\n\nMockery releases version 3 of the project that provides a number of high-profile benefits over v2:\n\n1. Generation of [`matryer`](template/matryer.md)-style templates. The https://github.com/matryer/moq project is being subsumed into mockery to combine the speed and configuration flexibility of mockery with the simplicity of moq-style mocks.\n2. The ability to specify [your own templates](template/index.md) for rendering.\n3. One output file for all generated mocks (for a particular package) instead of one output file per mock.\n4. Simplification and streamlining of the way mocks are generated using new configuration defaults.\n\nv3 has been architected in a way that will eventually make all other interface-based code generation frameworks obsolete.[^2]\n\nRead the maintainer's blog post on the history and background of v3:\n\n[![](https://topofmind.dev/assets/images/social/blog/2025/04/08/announcing-mockery-v3.png){ style=\"width: 600px; max-width: 100%\" }](https://topofmind.dev/blog/2025/04/08/announcing-mockery-v3/)\n\n## `mockery migrate`\n\nA tool is provided that will migrate your v2 config to v3 on a best-effort basis. Take for example a v2 schema config:\n\n```yaml title=\"\"\nquiet: False\ndisable-version-string: True\nwith-expecter: True\nstructname: \"{{.InterfaceNameCamel}}\"\nfilename: \"{{.StructName}}_mock.go\"\noutpkg: mocks\ntags: \"custom2\"\nissue-845-fix: True\nresolve-type-alias: False\npackages:\n github.com/vektra/mockery/v2/pkg/fixtures:\n config:\n all: True\n interfaces:\n RequesterVariadic:\n config:\n with-expecter: False\n configs:\n - structname: RequesterVariadicOneArgument\n unroll-variadic: False\n - structname: RequesterVariadic\n unroll-variadic: True\n ReplaceGeneric:\n config:\n replace-type:\n - github.com/vektra/mockery/v2/pkg/fixtures.ReplaceGeneric[-TImport]=github.com/vektra/mockery/v2/pkg/fixtures/redefined_type_b.B\n - github.com/vektra/mockery/v2/pkg/fixtures.ReplaceGeneric[TConstraint]=github.com/vektra/mockery/v2/pkg/fixtures/constraints.String\n```\n\n\n\nWe can run the command to migrate this to the v3 schema:\n\n```title=\"\"\n$ mockery migrate --config ./.mockery_v2.yml\n2025-03-28T00:26:44.762164000-05:00 INF using config config=./.mockery_v2.yml version=v0.0.0-dev\n2025-03-28T00:26:44.762804000-05:00 INF writing v3 config config=./.mockery_v2.yml v3-config=.mockery_v3.yml version=v0.0.0-dev\n2025-03-28T00:26:44.762914000-05:00 WRN breaking changes detected that possibly require manual intervention. See table below. config=./.mockery_v2.yml version=v0.0.0-dev\n```\n\nThis command will return two results:\n\n!!! info \"\"\n\n === \"`.mockery_v3.yml`\"\n\n The translated v3 config file.\n\n ```yaml\n structname: '{{.InterfaceNameCamel}}'\n pkgname: mocks\n template: testify\n template-data:\n with-expecter: true\n packages:\n github.com/vektra/mockery/v2/pkg/fixtures:\n config:\n all: true\n interfaces:\n ReplaceGeneric:\n config: {}\n RequesterVariadic:\n config:\n template-data:\n with-expecter: false\n configs:\n - structname: RequesterVariadicOneArgument\n template-data:\n unroll-variadic: false\n - structname: RequesterVariadic\n template-data:\n unroll-variadic: true\n ```\n\n === \"Deprecation Table\"\n\n A deprecation table that highlights situations that could not be resolved automatically. Each of these entries must be manually handled.\n\n Take for example the last entry mentioning `replace-type`. In v3, the [schema for `replace-type`](replace-type.md#schema){ data-preview } was changed from a parsed string to a more explicit key-value mapping.\n\n ```title=\"\"\n ╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮\n │ Deprecations │\n ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n │ IDX DEPRECATION TYPE MESSAGE │\n ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n │ 0 template-variable InterfaceNameCamel template variable has been deleted. Use \"{{ .InterfaceName | camelcase }}\" instead │\n ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n │ 1 deprecated-parameter `tags` is no longer supported, parameter not migrated. Use `mock-build-tags` instead. │\n ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n │ 2 deprecated-parameter `disable-func-mocks` permanently enabled in v3. │\n ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n │ 3 deprecated-parameter `fail-on-missing` is permanently set to True in v3. │\n ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n │ 4 deprecated-parameter `disable-version-string` is permanently set to True in v3. │\n ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n │ 5 deprecated-parameter `issue-845-fix` is permanently set to true in v3. │\n ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n │ 6 deprecated-parameter `replace-type` has moved to a new schema. Cannot automatically migrate. Please visit │\n │ https://vektra.github.io/mockery/latest-v3/replace-type/ for more information. │\n ╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\n ```\n\n!!! warning\n\n `mockery migrate` is not comprehensive and likely has missing edge cases. We encourage you to submit issues and PRs for any problems you encounter.\n\n## Config Templates\n\nTemplate functions used in configuration files have changed. The order of arugments for functions that take input strings is swapped. For example, in v2 the [`trimSuffix` function](https://github.com/vektra/mockery/blob/v2.53.3/pkg/outputter.go#L49) was set to the `strings.TrimSuffix` function from the stdlib. In v3, the argument orders are swapped, for example:\n\n```go\n\"trimSuffix\": func(suffix string, s string) string { return strings.TrimSuffix(s, suffix) },\n```\n\nThis is done to support [template pipelines](https://pkg.go.dev/text/template#hdr-Pipelines). You can see all of the reordered functions at [pkg.go.dev](https://pkg.go.dev/github.com/vektra/mockery/v3@v3.2.4/template_funcs#pkg-variables).\n\n## Layouts\n\nIn v2, mockery defaulted to placing mocks in a separate `mocks/` directory as [shown here](https://vektra.github.io/mockery/latest-v2/configuration/#layouts). In v3, mockery will by default place mocks adjacent to the mocked interface.\n\nIt is still possible to place mocks in a separate directory by making use of the [template variables and functions](configuration.md#templates) available to the configuration parameters.\n\n## Function Mocks\n\nMockery v2 allowed generating mocks for function types. v3 no longer does this as it provided little benefit for users.\n\n## Parameters\n\n### `#!yaml inpackage: True`\n\nMockery v2 has an `inpackage` parameter that informed mockery when a mock was being generated in the same package as the original interface. In v3, this parameter has been removed as mockery is now able to detect when the mock is placed in the same package.\n\n### `#!yaml keeptree: True`\n\nMockery v2 provided a `keeptree` parameter that was deprecated and used only in the pre-`packages` config schema. This parameter has no use in v3 and has been removed.\n\n### `#!yaml replace-type:`\n\nThe `#!yaml replace-type:` parameter has an updated schema. In v2, [users provided a list of strings](https://vektra.github.io/mockery/latest-v2/features/#replace-types), where each string needed to confirm to a specific format that was parsed at runtime. In v3, the [schema is more explicit](replace-type.md) to make it simpler.\n\n### `#!yaml resolve-type-alias:`\n\nIn v2, `resolve-type-alias` was set to `True` by default to retain backwards compatibility. In v3, this is permanently set to `False`.\n\n### `#!yaml with-expecter:`\n\nIn v3, this parameter has been removed. `testify`-style mocks will always generate expecter methods.\n\n### `#!yaml unroll-variadic:`\n\nThis parameter has been moved under the `#!yaml template-data:` parameter. Parameters that apply only to specific templates are not expressed in the top-level schema and are instead passed through the schemaless `#!yaml template-data:` map.\n\n### `#!yaml exclude:`\n\nThis parameter in v2 was renamed to `#! exclude-subpkg-regex:`.\n\n## v2 Support Lifecycle\n\nIn order to give the community ample time to adjust to v3, the mockery maintainers will support v2 until Dec 31, 2029 in the following ways:\n\n1. Bug fixes\n2. Security/vulnerability fixes\n3. Dependency updates to support future Go language versions.[^1]\n\nFrom the date at which v3 is released for full production, the Mockery project will support feature updates to v2 for a period of 6 months.\n\n[^1]: More specifically, we agree to update our dependencies used in parsing Go types such that Mockery is capable of parsing new syntax introduced in the Go language. The mockery project will _not_ support changes to the generated code in a manner that makes use of any new language features. The only promise is that Mockery will be able to parse modules that use such new syntax or other language features without failing.\n[^2]: A bold statement yes, but we hope to convince you of its truth with what's coming. The assumption of the https://github.com/matryer/moq project into mockery is a testament to this statement, and is only the first of many other projects we hope to integrate into mockery.\n" }, { "path": "e2e/run_all.sh", "content": "#!/bin/bash\nset -e\nSCRIPT_DIR=$( cd -- \"$( dirname -- \"${BASH_SOURCE[0]}\" )\" &> /dev/null && pwd )\n\nfor test in $(ls -d $SCRIPT_DIR/test_*); do\n file=\"$test\"\n if [ -d \"$test\" ]; then\n file=\"$test/run.sh\"\n if ! [ -f $file ]; then \n continue\n fi\n fi\n echo \"==========\"\n echo \"RUNNING $file\"\n echo \"==========\"\n $file\ndone\n" }, { "path": "e2e/test_infinite_mocking.sh", "content": "#!/bin/bash\n# This tests https://github.com/vektra/mockery/issues/632, where\n# mockery was generating mocks of its own auto-generated code.\ngo run github.com/go-task/task/v3/cmd/task mocks || exit 1\n\n# New mocks may legimitately be created, so we run mockery once first\nnum_files_before=$(find . -type f | wc -l)\nexport MOCKERY_FORCE_FILE_WRITE=\"true\"\ngo run github.com/go-task/task/v3/cmd/task mocks.generate || exit 1\nnum_files_after=$(find . -type f | wc -l)\n\nif [ $num_files_before -ne $num_files_after ]; then\n echo \"ERROR: detected increased file count over multiple mockery runs.\"\n echo \"before: $num_files_before. after: $num_files_after\"\n exit 1\nfi\necho \"SUCCESS: identical number of files over multiple mockery runs\"\n\n" }, { "path": "e2e/test_missing_interface/.mockery.yml", "content": "packages:\n github.com/vektra/mockery/v3/internal:\n interfaces:\n InterfaceDoesntExist:\n" }, { "path": "e2e/test_missing_interface/run.sh", "content": "#!/bin/bash\n\nSCRIPT_DIR=$( cd -- \"$( dirname -- \"${BASH_SOURCE[0]}\" )\" &> /dev/null && pwd )\nCONFIG=$SCRIPT_DIR/.mockery.yml\nexport MOCKERY_CONFIG=$CONFIG\n\ngo run github.com/go-task/task/v3/cmd/task mocks.generate.custom\n\nRT=$?\nif [ $RT -eq 0 ]; then\n echo \"ERROR: Expected mockery to fail.\"\n exit 1\nfi\necho \"SUCCESS: Mockery returned non-zero return code as expected.\"" }, { "path": "e2e/test_mockery_generation.sh", "content": "#!/bin/bash\n\ngo run github.com/go-task/task/v3/cmd/task mocks\nrt=$?\nif [ $rt -ne 0 ]; then\n echo \"ERROR: non-zero return code from mockery\"\n exit 1\nfi\necho \"SUCCESS: successfully generated mocks defined in .mockery.yaml\"" }, { "path": "e2e/test_remote_templates/remote_templates_test.go", "content": "package testremotetemplates\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nvar configTemplate = `\ndir: %s\nfilename: %s\ntemplate: %s\nformatter: noop\nforce-file-write: true\npkgname: test_pkgname\ntemplate-data:\n foo: foo\n bar: bar\npackages:\n github.com/vektra/mockery/v3/internal/fixtures/template_exercise:\n interfaces:\n Exercise:\n`\n\nfunc TestRemoteTemplates(t *testing.T) {\n\t// the temp dir needs to reside within the mockery project because mockery\n\t// requires a go.mod file to function correctly. Using t.TempDir() won't work\n\t// because of this.\n\ttmpDirBase := \"./test\"\n\t_ = os.RemoveAll(tmpDirBase)\n\trequire.NoError(t, os.Mkdir(tmpDirBase, 0o755))\n\n\t//nolint:errcheck\n\tdefer os.RemoveAll(tmpDirBase)\n\n\ttype test struct {\n\t\tname string\n\t\tschema string\n\t\texpectMockeryErr bool\n\t}\n\tfor _, tt := range []test{\n\t\t{\n\t\t\tname: \"schema validation OK\",\n\t\t\tschema: `{\n\t\"$schema\": \"http://json-schema.org/draft-07/schema#\",\n\t\"title\": \"vektra/mockery matryer mock\",\n\t\"type\": \"object\",\n\t\"additionalProperties\": false,\n\t\"properties\": {\n\t\t\"foo\": {\n\t\t\"type\": \"string\"\n\t\t},\n\t\t\"bar\": {\n\t\t\"type\": \"string\"\n\t\t}\n\t},\n\t\"required\": [\"foo\", \"bar\"]\n}`,\n\t\t\texpectMockeryErr: false,\n\t\t},\n\t\t{\n\t\t\tname: \"Required parameter doesn't exist\",\n\t\t\tschema: `{\n\t\"$schema\": \"http://json-schema.org/draft-07/schema#\",\n\t\"title\": \"vektra/mockery matryer mock\",\n\t\"type\": \"object\",\n\t\"additionalProperties\": false,\n\t\"properties\": {\n\t\t\"foo\": {\n\t\t\t\"type\": \"string\"\n\t\t},\n\t\t\"bar\": {\n\t\t\t\"type\": \"string\"\n\t\t},\n\t\t\"baz\": {\n\t\t\t\"type\": \"string\"\n\t\t}\n\t},\n\t\"required\": [\"foo\", \"bar\", \"baz\"]\n}`,\n\t\t\texpectMockeryErr: true,\n\t\t},\n\t} {\n\t\tt.Run(tt.name, func(t *testing.T) {\n\t\t\ttmpdir := path.Join(tmpDirBase, t.Name())\n\t\t\trequire.NoError(t, os.MkdirAll(tmpdir, 0o755))\n\n\t\t\tconfigFile := path.Join(tmpdir, \".mockery.yml\")\n\t\t\toutFile := path.Join(tmpdir, \"out.txt\")\n\n\t\t\ttemplateName := \"template.templ\"\n\t\t\tmux := http.NewServeMux()\n\t\t\tmux.HandleFunc(fmt.Sprintf(\"/%s\", templateName), func(w http.ResponseWriter, r *http.Request) {\n\t\t\t\tfmt.Fprint(w, \"Hello, world!\")\n\t\t\t})\n\t\t\tmux.HandleFunc(fmt.Sprintf(\"/%s.schema.json\", templateName), func(w http.ResponseWriter, r *http.Request) {\n\t\t\t\tfmt.Fprint(w, tt.schema)\n\t\t\t})\n\n\t\t\tts := httptest.NewServer(mux)\n\t\t\tdefer ts.Close()\n\n\t\t\tfullPath := fmt.Sprintf(\"%s/%s\", ts.URL, templateName)\n\n\t\t\tparent, name := path.Split(outFile)\n\t\t\tconfigFileContents := fmt.Sprintf(\n\t\t\t\tconfigTemplate,\n\t\t\t\tparent,\n\t\t\t\tname,\n\t\t\t\tfullPath,\n\t\t\t)\n\t\t\trequire.NoError(t, os.WriteFile(configFile, []byte(configFileContents), 0o600))\n\n\t\t\t//nolint: gosec\n\t\t\tout, err := exec.Command(\n\t\t\t\t\"go\", \"run\", \"github.com/vektra/mockery/v3\",\n\t\t\t\t\"--config\", configFile).CombinedOutput()\n\t\t\tif tt.expectMockeryErr {\n\t\t\t\tassert.Error(t, err)\n\t\t\t} else {\n\t\t\t\trequire.NoError(t, err, string(out))\n\t\t\t\toutFileBytes, err := os.ReadFile(outFile)\n\t\t\t\trequire.NoError(t, err)\n\t\t\t\tassert.Equal(t, \"Hello, world!\", string(outFileBytes))\n\t\t\t}\n\t\t})\n\t}\n}\n" }, { "path": "e2e/test_template_data_schema_validation/.mockery.yml", "content": "dir: ./\nfilename: exercise.txt\ntemplate: file://./template.templ\nformatter: noop\nforce-file-write: true\npkgname: test_pkgname\ntemplate-data:\n bar: bar\npackages:\n github.com/vektra/mockery/v3/internal/fixtures/template_exercise:\n interfaces:\n Exercise:\n" }, { "path": "e2e/test_template_data_schema_validation/template.templ", "content": "" }, { "path": "e2e/test_template_data_schema_validation/template.templ.schema.json", "content": "{\n \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n \"title\": \"vektra/mockery matryer mock\",\n \"type\": \"object\",\n \"additionalProperties\": false,\n \"properties\": {\n \"foo\": {\n \"type\": \"string\"\n },\n \"bar\": {\n \"type\": \"string\"\n }\n },\n \"required\": [\"foo\", \"bar\"]\n }" }, { "path": "e2e/test_template_data_schema_validation/validation_test.go", "content": "package test_template_exercise\n\nimport (\n\t\"os\"\n\t\"os/exec\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestExercise(t *testing.T) {\n\tt.Parallel()\n\toutfile := \"./exercise.txt\"\n\t//nolint:errcheck\n\tdefer os.Remove(outfile)\n\n\tout, err := exec.Command(\n\t\t\"go\", \"run\", \"github.com/vektra/mockery/v3\",\n\t\t\"--config\", \"./.mockery.yml\").CombinedOutput()\n\tassert.Error(t, err)\n\texpectedString := \"ERR (root): foo is required\"\n\tassert.True(t, strings.Contains(string(out), expectedString), \"expected string in stdout not found: \\\"%s\\\"\", expectedString)\n}\n" }, { "path": "e2e/test_template_exercise/.mockery.yml", "content": "dir: ./\nfilename: exercise.txt\ntemplate: file://./exercise.templ\nformatter: noop\nforce-file-write: true\npkgname: test_pkgname\ntemplate-data:\n foo: foo\n bar: bar\npackages:\n github.com/vektra/mockery/v3/internal/fixtures/template_exercise:\n interfaces:\n Exercise:\n" }, { "path": "e2e/test_template_exercise/exercise.templ", "content": ".PkgName: {{ .PkgName }}\n.SrcPkgQualifier: {{ .SrcPkgQualifier }}\n{{ range $i, $import := .Imports }}\n$import.Alias: {{ $import.Alias }}\n$import.Path: {{ $import.Path }}\n$import.Qualifier: {{ $import.Qualifier }}\n{{ end }}\n\n{{ range $i, $interface := .Interfaces }}\n# MOCK: {{ $i }}\n$interface.Name: {{ $interface.Name }}\n$interface.StructName: {{ $interface.StructName }}\n\n# COMMENTS\n$interface.Comments.GenDeclDoc.Text: {{ $interface.Comments.GenDeclDoc.Text }}\n$interface.Comments.GenDeclDoc.List:\n{{- range $_, $comment := $interface.Comments.GenDeclDoc.List }}\n{{ $comment }}\n{{- end }}\n$interface.Comments.TypeSpecDoc.Text: {{ $interface.Comments.TypeSpecDoc.Text }}\n$interface.Comments.TypeSpecDoc.List:\n{{- range $_, $comment := $interface.Comments.TypeSpecDoc.List }}\n{{ $comment }}\n{{- end }}\n$interface.Comments.TypeSpecComment.Text: {{ $interface.Comments.TypeSpecComment.Text }}\n$interface.Comments.TypeSpecComment.List:\n{{- range $_, $comment := $interface.Comments.TypeSpecComment.List }}\n{{ $comment }}\n{{- end }}\n\n{{ range $j, $typeparam := .TypeParams }}\n# TYPE PARAM: {{ $j }}\n$typeparam.Var.Name: {{ $typeparam.Var.Name }}\n$typeparam.Var.IsSlice: {{ $typeparam.Var.IsSlice }}\n$typeparam.Var.Nillable: {{ $typeparam.Var.Nillable }}\n$typeparam.Var.Type.String: {{ $typeparam.Var.Type.String }}\n$typeparam.Var.TypeString: {{ $typeparam.Var.TypeString }}\n$typeparam.CallName: {{ $typeparam.CallName true }}\n$typeparam.CallName: {{ $typeparam.CallName false }}\n$typeparam.MethodArg: {{ $typeparam.MethodArg }}\n$typeparam.Name: {{ $typeparam.Name }}\n$typeparam.TypeString: {{ $typeparam.TypeString }}\n$typeparam.TypeStringEllipsis: {{ $typeparam.TypeStringEllipsis }}\n$typeparam.TypeStringVariadicUnderlying: {{ $typeparam.TypeStringVariadicUnderlying }}\n{{- if $typeparam.Constraint }}\n$typeparam.Constraint.String: {{ $typeparam.Constraint.String }}\n{{- end }}\n{{ end }}\n{{ range $j, $method := .Methods }}\n# METHOD: {{ $j }}\n$method.Name: {{ $method.Name }}\n$method.ReturnStatement: {{ $method.ReturnStatement }}\n$method.Call: {{ $method.Call }}\n$method.AcceptsContext: {{ $method.AcceptsContext}}\n$method.Signature: {{ $method.Signature }}\n$method.SignatureNoName: {{ $method.SignatureNoName }}\n$method.Declaration: {{ $method.Declaration }}\n$method.ReturnsError: {{ $method.ReturnsError }}\n$method.HasParams: {{ $method.HasParams }}\n$method.HasReturns: {{ $method.HasReturns }}\n$method.ReturnArgList: {{ $method.ReturnArgList }}\n$method.ReturnArgListNoName: {{ $method.ReturnArgListNoName }}\n$method.ArgList: {{ $method.ArgList }}\n$method.ArgListNoName: {{ $method.ArgListNoName }}\n\n{{ range $k, $param := .Params }}\n# PARAM: {{ $k }}\n$param.Var.Name: {{ $param.Var.Name }}\n$param.Var.IsSlice: {{ $param.Var.IsSlice }}\n$param.Var.Nillable: {{ $param.Var.Nillable }}\n$param.Var.Type.String: {{ $param.Var.Type.String }}\n$param.Var.TypeString: {{ $param.Var.TypeString }}\n$param.MethodArg: {{ $param.MethodArg }}\n$param.MethodArgNoName: {{ $param.MethodArgNoName }}\n\n{{ end }}\n{{ range $k, $return := .Returns }}\n# RETURN: {{ $k }}\n$return.Var.Name: {{ $return.Var.Name }}\n$return.Var.IsSlice: {{ $return.Var.IsSlice }}\n$return.Var.Nillable: {{ $return.Var.Nillable }}\n$return.Var.Type.String: {{ $return.Var.Type.String }}\n$return.Var.TypeString: {{ $return.Var.TypeString }}\n{{ end }}\n# SCOPE\n$method.Scope.AllocateName \"foo\": {{ $method.Scope.AllocateName \"foo\" }}\n$method.Scope.AllocateName \"foo\": {{ $method.Scope.AllocateName \"foo\" }}\n$method.Scope.NameExists \"foo\": {{ $method.Scope.NameExists \"foo\" }}\n$method.Scope.NameExists \"foo1\": {{ $method.Scope.NameExists \"foo1\" }}\n$method.Scope.NameExists \"notexists\": {{ $method.Scope.NameExists \"notexists\" }}\n{{ end }}\n{{ end }}\n" }, { "path": "e2e/test_template_exercise/exercise.templ.schema.json", "content": "{\n \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n \"title\": \"vektra/mockery matryer mock\",\n \"type\": \"object\",\n \"additionalProperties\": false,\n \"properties\": {\n \"foo\": {\n \"type\": \"string\"\n },\n \"bar\": {\n \"type\": \"string\"\n }\n },\n \"required\": [\"foo\", \"bar\"]\n }" }, { "path": "e2e/test_template_exercise/exercise_expected.txt", "content": ".PkgName: test_pkgname\n.SrcPkgQualifier: templateexercise.\n\n$import.Alias: \n$import.Path: context\n$import.Qualifier: context\n\n$import.Alias: \n$import.Path: golang.org/x/exp/constraints\n$import.Qualifier: constraints\n\n\n\n# MOCK: 0\n$interface.Name: Exercise\n$interface.StructName: MockExercise\n\n# COMMENTS\n$interface.Comments.GenDeclDoc.Text: GenDecl comments\n\n$interface.Comments.GenDeclDoc.List:\n// GenDecl comments\n$interface.Comments.TypeSpecDoc.Text: Exercise is an interface that is used to render a template that exercises\nall parts of the template data passed to the template.\n\n$interface.Comments.TypeSpecDoc.List:\n// Exercise is an interface that is used to render a template that exercises\n// all parts of the template data passed to the template.\n$interface.Comments.TypeSpecComment.Text: This is a line comment\n\n$interface.Comments.TypeSpecComment.List:\n// This is a line comment\n\n\n# TYPE PARAM: 0\n$typeparam.Var.Name: T\n$typeparam.Var.IsSlice: false\n$typeparam.Var.Nillable: true\n$typeparam.Var.Type.String: any\n$typeparam.Var.TypeString: any\n$typeparam.CallName: T\n$typeparam.CallName: T\n$typeparam.MethodArg: T any\n$typeparam.Name: T\n$typeparam.TypeString: any\n$typeparam.TypeStringEllipsis: any\n$typeparam.TypeStringVariadicUnderlying: any\n\n# TYPE PARAM: 1\n$typeparam.Var.Name: Ordered\n$typeparam.Var.IsSlice: false\n$typeparam.Var.Nillable: true\n$typeparam.Var.Type.String: golang.org/x/exp/constraints.Ordered\n$typeparam.Var.TypeString: constraints.Ordered\n$typeparam.CallName: Ordered\n$typeparam.CallName: Ordered\n$typeparam.MethodArg: Ordered constraints.Ordered\n$typeparam.Name: Ordered\n$typeparam.TypeString: constraints.Ordered\n$typeparam.TypeStringEllipsis: constraints.Ordered\n$typeparam.TypeStringVariadicUnderlying: constraints.Ordered\n$typeparam.Constraint.String: int\n\n\n# METHOD: 0\n$method.Name: Foo\n$method.ReturnStatement: return\n$method.Call: Foo(ctx, typeParam, ordered)\n$method.AcceptsContext: true\n$method.Signature: (ctx context.Context, typeParam T, ordered Ordered) (err error)\n$method.SignatureNoName: (context.Context, T, Ordered) (error)\n$method.Declaration: Foo(ctx context.Context, typeParam T, ordered Ordered) (err error)\n$method.ReturnsError: true\n$method.HasParams: true\n$method.HasReturns: true\n$method.ReturnArgList: err error\n$method.ReturnArgListNoName: error\n$method.ArgList: ctx context.Context, typeParam T, ordered Ordered\n$method.ArgListNoName: context.Context, T, Ordered\n\n\n# PARAM: 0\n$param.Var.Name: ctx\n$param.Var.IsSlice: false\n$param.Var.Nillable: true\n$param.Var.Type.String: context.Context\n$param.Var.TypeString: context.Context\n$param.MethodArg: ctx context.Context\n$param.MethodArgNoName: context.Context\n\n\n# PARAM: 1\n$param.Var.Name: typeParam\n$param.Var.IsSlice: false\n$param.Var.Nillable: true\n$param.Var.Type.String: T\n$param.Var.TypeString: T\n$param.MethodArg: typeParam T\n$param.MethodArgNoName: T\n\n\n# PARAM: 2\n$param.Var.Name: ordered\n$param.Var.IsSlice: false\n$param.Var.Nillable: true\n$param.Var.Type.String: Ordered\n$param.Var.TypeString: Ordered\n$param.MethodArg: ordered Ordered\n$param.MethodArgNoName: Ordered\n\n\n\n# RETURN: 0\n$return.Var.Name: err\n$return.Var.IsSlice: false\n$return.Var.Nillable: true\n$return.Var.Type.String: error\n$return.Var.TypeString: error\n\n# SCOPE\n$method.Scope.AllocateName \"foo\": foo\n$method.Scope.AllocateName \"foo\": foo1\n$method.Scope.NameExists \"foo\": true\n$method.Scope.NameExists \"foo1\": true\n$method.Scope.NameExists \"notexists\": false\n\n\n" }, { "path": "e2e/test_template_exercise/exercise_test.go", "content": "package test_template_exercise\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"os/exec\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestExercise(t *testing.T) {\n\tt.Parallel()\n\n\toutfile := \"./exercise.txt\"\n\t//nolint:errcheck\n\tdefer os.Remove(outfile)\n\n\tout, err := exec.Command(\n\t\t\"go\", \"run\", \"github.com/vektra/mockery/v3\",\n\t\t\"--config\", \"./.mockery.yml\").CombinedOutput()\n\tif err != nil {\n\t\tfmt.Println(err)\n\t\tfmt.Println(string(out))\n\t\tos.Exit(1)\n\t}\n\n\tb, err := os.ReadFile(outfile)\n\tif err != nil {\n\t\tfmt.Println(err)\n\t\tos.Exit(1)\n\t}\n\texpectedPath := \"exercise_expected.txt\"\n\texpected, err := os.ReadFile(expectedPath)\n\tif err != nil {\n\t\tfmt.Println(err)\n\t\tos.Exit(1)\n\t}\n\tassert.Equal(t, string(expected), string(b))\n}\n" }, { "path": "foo.go", "content": "package main\n\ntype baz string\n\ntype foo interface {\n\tBar() baz\n}\n" }, { "path": "foo_test.go", "content": "package main\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestFoo(t *testing.T) {\n\tm := newMockfoo(t)\n\tm.EXPECT().Bar().Return(baz(\"foo\"))\n\tassert.Equal(t, \"foo\", m.Bar())\n}\n" }, { "path": "go.mod", "content": "module github.com/vektra/mockery/v3\n\ngo 1.25.0\n\nrequire (\n\tgithub.com/brunoga/deep v1.3.1\n\tgithub.com/go-viper/mapstructure/v2 v2.5.0\n\tgithub.com/huandu/xstrings v1.5.0\n\tgithub.com/jedib0t/go-pretty/v6 v6.7.8\n\tgithub.com/knadh/koanf/parsers/yaml v1.1.0\n\tgithub.com/knadh/koanf/providers/env v1.1.0\n\tgithub.com/knadh/koanf/providers/file v1.2.1\n\tgithub.com/knadh/koanf/providers/posflag v1.0.1\n\tgithub.com/knadh/koanf/providers/structs v1.0.0\n\tgithub.com/knadh/koanf/v2 v2.3.2\n\tgithub.com/rs/zerolog v1.34.0\n\tgithub.com/spf13/cobra v1.10.2\n\tgithub.com/spf13/pflag v1.0.10\n\tgithub.com/stretchr/testify v1.11.1\n\tgithub.com/xeipuuv/gojsonschema v1.2.0\n\tgolang.org/x/exp v0.0.0-20260212183809-81e46e3db34a\n\tgolang.org/x/term v0.40.0\n\tgolang.org/x/tools v0.42.0\n\tgopkg.in/yaml.v3 v3.0.1\n)\n\nrequire (\n\tgithub.com/clipperhouse/uax29/v2 v2.2.0 // indirect\n\tgithub.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect\n\tgithub.com/fatih/structs v1.1.0 // indirect\n\tgithub.com/fsnotify/fsnotify v1.9.0 // indirect\n\tgithub.com/inconshreveable/mousetrap v1.1.0 // indirect\n\tgithub.com/knadh/koanf/maps v0.1.2 // indirect\n\tgithub.com/kr/pretty v0.3.1 // indirect\n\tgithub.com/mattn/go-colorable v0.1.14 // indirect\n\tgithub.com/mattn/go-isatty v0.0.20 // indirect\n\tgithub.com/mattn/go-runewidth v0.0.19 // indirect\n\tgithub.com/mitchellh/copystructure v1.2.0 // indirect\n\tgithub.com/mitchellh/reflectwalk v1.0.2 // indirect\n\tgithub.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect\n\tgithub.com/rogpeppe/go-internal v1.14.1 // indirect\n\tgithub.com/stretchr/objx v0.5.3 // indirect\n\tgithub.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect\n\tgithub.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect\n\tgo.yaml.in/yaml/v3 v3.0.4 // indirect\n\tgolang.org/x/mod v0.33.0 // indirect\n\tgolang.org/x/sync v0.19.0 // indirect\n\tgolang.org/x/sys v0.41.0 // indirect\n\tgolang.org/x/text v0.34.0 // indirect\n\tgopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect\n)\n" }, { "path": "go.sum", "content": "github.com/brunoga/deep v1.3.1 h1:bSrL6FhAZa6JlVv4vsi7Hg8SLwroDb1kgDERRVipBCo=\ngithub.com/brunoga/deep v1.3.1/go.mod h1:GDV6dnXqn80ezsLSZ5Wlv1PdKAWAO4L5PnKYtv2dgaI=\ngithub.com/clipperhouse/uax29/v2 v2.2.0 h1:ChwIKnQN3kcZteTXMgb1wztSgaU+ZemkgWdohwgs8tY=\ngithub.com/clipperhouse/uax29/v2 v2.2.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=\ngithub.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=\ngithub.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=\ngithub.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=\ngithub.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=\ngithub.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=\ngithub.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=\ngithub.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=\ngithub.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=\ngithub.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=\ngithub.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=\ngithub.com/go-viper/mapstructure/v2 v2.5.0 h1:vM5IJoUAy3d7zRSVtIwQgBj7BiWtMPfmPEgAXnvj1Ro=\ngithub.com/go-viper/mapstructure/v2 v2.5.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=\ngithub.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=\ngithub.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=\ngithub.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=\ngithub.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI=\ngithub.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=\ngithub.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=\ngithub.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=\ngithub.com/jedib0t/go-pretty/v6 v6.7.8 h1:BVYrDy5DPBA3Qn9ICT+PokP9cvCv1KaHv2i+Hc8sr5o=\ngithub.com/jedib0t/go-pretty/v6 v6.7.8/go.mod h1:YwC5CE4fJ1HFUDeivSV1r//AmANFHyqczZk+U6BDALU=\ngithub.com/knadh/koanf/maps v0.1.2 h1:RBfmAW5CnZT+PJ1CVc1QSJKf4Xu9kxfQgYVQSu8hpbo=\ngithub.com/knadh/koanf/maps v0.1.2/go.mod h1:npD/QZY3V6ghQDdcQzl1W4ICNVTkohC8E73eI2xW4yI=\ngithub.com/knadh/koanf/parsers/yaml v1.1.0 h1:3ltfm9ljprAHt4jxgeYLlFPmUaunuCgu1yILuTXRdM4=\ngithub.com/knadh/koanf/parsers/yaml v1.1.0/go.mod h1:HHmcHXUrp9cOPcuC+2wrr44GTUB0EC+PyfN3HZD9tFg=\ngithub.com/knadh/koanf/providers/env v1.1.0 h1:U2VXPY0f+CsNDkvdsG8GcsnK4ah85WwWyJgef9oQMSc=\ngithub.com/knadh/koanf/providers/env v1.1.0/go.mod h1:QhHHHZ87h9JxJAn2czdEl6pdkNnDh/JS1Vtsyt65hTY=\ngithub.com/knadh/koanf/providers/file v1.2.1 h1:bEWbtQwYrA+W2DtdBrQWyXqJaJSG3KrP3AESOJYp9wM=\ngithub.com/knadh/koanf/providers/file v1.2.1/go.mod h1:bp1PM5f83Q+TOUu10J/0ApLBd9uIzg+n9UgthfY+nRA=\ngithub.com/knadh/koanf/providers/posflag v1.0.1 h1:EnMxHSrPkYCFnKgBUl5KBgrjed8gVFrcXDzaW4l/C6Y=\ngithub.com/knadh/koanf/providers/posflag v1.0.1/go.mod h1:3Wn3+YG3f4ljzRyCUgIwH7G0sZ1pMjCOsNBovrbKmAk=\ngithub.com/knadh/koanf/providers/structs v1.0.0 h1:DznjB7NQykhqCar2LvNug3MuxEQsZ5KvfgMbio+23u4=\ngithub.com/knadh/koanf/providers/structs v1.0.0/go.mod h1:kjo5TFtgpaZORlpoJqcbeLowM2cINodv8kX+oFAeQ1w=\ngithub.com/knadh/koanf/v2 v2.3.2 h1:Ee6tuzQYFwcZXQpc2MiVeC6qHMandf5SMUJJNoFp/c4=\ngithub.com/knadh/koanf/v2 v2.3.2/go.mod h1:gRb40VRAbd4iJMYYD5IxZ6hfuopFcXBpc9bbQpZwo28=\ngithub.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=\ngithub.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=\ngithub.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=\ngithub.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=\ngithub.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=\ngithub.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=\ngithub.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=\ngithub.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=\ngithub.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=\ngithub.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=\ngithub.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=\ngithub.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=\ngithub.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=\ngithub.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=\ngithub.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=\ngithub.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=\ngithub.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=\ngithub.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=\ngithub.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=\ngithub.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=\ngithub.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=\ngithub.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=\ngithub.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=\ngithub.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=\ngithub.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=\ngithub.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=\ngithub.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=\ngithub.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=\ngithub.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=\ngithub.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=\ngithub.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=\ngithub.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=\ngithub.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=\ngithub.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=\ngithub.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=\ngithub.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=\ngithub.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=\ngithub.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=\ngithub.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4=\ngithub.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0=\ngithub.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=\ngithub.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=\ngithub.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=\ngithub.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=\ngithub.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo=\ngithub.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=\ngithub.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=\ngithub.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=\ngithub.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=\ngithub.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=\ngo.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=\ngo.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=\ngolang.org/x/exp v0.0.0-20260212183809-81e46e3db34a h1:ovFr6Z0MNmU7nH8VaX5xqw+05ST2uO1exVfZPVqRC5o=\ngolang.org/x/exp v0.0.0-20260212183809-81e46e3db34a/go.mod h1:K79w1Vqn7PoiZn+TkNpx3BUWUQksGO3JcVX6qIjytmA=\ngolang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=\ngolang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=\ngolang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=\ngolang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=\ngolang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=\ngolang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=\ngolang.org/x/term v0.40.0 h1:36e4zGLqU4yhjlmxEaagx2KuYbJq3EwY8K943ZsHcvg=\ngolang.org/x/term v0.40.0/go.mod h1:w2P8uVp06p2iyKKuvXIm7N/y0UCRt3UfJTfZ7oOpglM=\ngolang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=\ngolang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=\ngolang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=\ngolang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=\ngopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=\ngopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=\ngopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=\ngopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=\ngopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=\n" }, { "path": "go.work", "content": "go 1.25.0\n\nuse (\n\t.\n\t./internal/fixtures/example_project/pkg_with_submodules\n\t./tools\n)\n" }, { "path": "go.work.sum", "content": "cloud.google.com/go v0.115.0 h1:CnFSK6Xo3lDYRoBKEcAtia6VSC837/ZkJuRduSFnr14=\ncloud.google.com/go v0.115.0/go.mod h1:8jIM5vVgoAEoiVxQ/O4BFTfHqulPZgs/ufEzMcFMdWU=\ncloud.google.com/go/ai v0.8.0 h1:rXUEz8Wp2OlrM8r1bfmpF2+VKqc1VJpafE3HgzRnD/w=\ncloud.google.com/go/ai v0.8.0/go.mod h1:t3Dfk4cM61sytiggo2UyGsDVW3RF1qGZaUKDrZFyqkE=\ncloud.google.com/go/auth v0.8.1 h1:QZW9FjC5lZzN864p13YxvAtGUlQ+KgRL+8Sg45Z6vxo=\ncloud.google.com/go/auth v0.8.1/go.mod h1:qGVp/Y3kDRSDZ5gFD/XPUfYQ9xW1iI7q8RIRoCyBbJc=\ncloud.google.com/go/auth/oauth2adapt v0.2.3 h1:MlxF+Pd3OmSudg/b1yZ5lJwoXCEaeedAguodky1PcKI=\ncloud.google.com/go/auth/oauth2adapt v0.2.3/go.mod h1:tMQXOfZzFuNuUxOypHlQEXgdfX5cuhwU+ffUuXRJE8I=\ncloud.google.com/go/bigquery v1.8.0 h1:PQcPefKFdaIzjQFbiyOgAqyx8q5djaE7x9Sqe712DPA=\ncloud.google.com/go/compute/metadata v0.5.0 h1:Zr0eK8JbFv6+Wi4ilXAR8FJ3wyNdpxHKJNPos6LTZOY=\ncloud.google.com/go/compute/metadata v0.5.0/go.mod h1:aHnloV2TPI38yx4s9+wAZhHykWvVCfu7hQbF+9CWoiY=\ncloud.google.com/go/datastore v1.1.0 h1:/May9ojXjRkPBNVrq+oWLqmWCkr4OU5uRY29bu0mRyQ=\ncloud.google.com/go/longrunning v0.5.7 h1:WLbHekDbjK1fVFD3ibpFFVoyizlLRl73I7YKuAKilhU=\ncloud.google.com/go/longrunning v0.5.7/go.mod h1:8GClkudohy1Fxm3owmBGid8W0pSgodEMwEAztp38Xng=\ncloud.google.com/go/pubsub v1.3.1 h1:ukjixP1wl0LpnZ6LWtZJ0mX5tBmjp1f8Sqer8Z2OMUU=\ncloud.google.com/go/storage v1.10.0 h1:STgFzyU5/8miMl0//zKh2aQeTyeaUH3WN9bSUiJ09bA=\ndmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9 h1:VpgP7xuJadIUuKccphEpTJnWhS2jkQyMt6Y7pJCD7fY=\ngithub.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802 h1:1BDTz0u9nC3//pOCMdNH+CiXJVYJh5UQNCOBG7jbELc=\ngithub.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751 h1:JYp7IbQjafoB+tBA3gMyHYHrpOtNuDiK/uB5uXxq5wM=\ngithub.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d h1:UQZhZ2O0vMHr2cI+DC1Mbh0TJxzA3RcLoMsFw+aXw7E=\ngithub.com/bwesterb/go-ristretto v1.2.3 h1:1w53tCkGhCQ5djbat3+MH0BAQ5Kfgbt56UZQ/JMzngw=\ngithub.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=\ngithub.com/census-instrumentation/opencensus-proto v0.2.1 h1:glEXhBS5PSLLv4IXzLA5yPRVX4bilULVyxxbrfOtDAk=\ngithub.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=\ngithub.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e h1:fY5BOSpyZCqRo5OhCuC+XN+r/bBCmeuuJtjz+bCNIf8=\ngithub.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1 h1:q763qf9huN11kDQavWsoZXJNW3xEE4JJyHa5Q25/sd8=\ngithub.com/client9/misspell v0.3.4 h1:ta993UF76GwbvJcIo3Y68y/M3WxlpEHPWIGDkJYwzJI=\ngithub.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f h1:WBZRG4aNOuI15bLRrCgN8fCq8E5Xuty6jGbmSNEvSsU=\ngithub.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=\ngithub.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=\ngithub.com/cpuguy83/go-md2man/v2 v2.0.6 h1:XJtiaUW6dEEqVuZiMTn1ldk455QWwEIsMIJlo5vtkx0=\ngithub.com/cristalhq/acmd v0.12.0 h1:RdlKnxjN+txbQosg8p/TRNZ+J1Rdne43MVQZ1zDhGWk=\ngithub.com/cristalhq/acmd v0.12.0/go.mod h1:LG5oa43pE/BbxtfMoImHCQN++0Su7dzipdgBjMCBVDQ=\ngithub.com/envoyproxy/go-control-plane v0.9.4 h1:rEvIZUSZ3fx39WIi3JkQqQBitGwpELBIYWeBVh6wn+E=\ngithub.com/envoyproxy/protoc-gen-validate v0.1.0 h1:EQciDnbrYxy13PgWoY8AqoxGiPrpgBZ1R8UNe3ddc+A=\ngithub.com/felixge/fgprof v0.9.5 h1:8+vR6yu2vvSKn08urWyEuxx75NWPEvybbkBirEpsbVY=\ngithub.com/felixge/fgprof v0.9.5/go.mod h1:yKl+ERSa++RYOs32d8K6WEXCB4uXdLls4ZaZPpayhMM=\ngithub.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=\ngithub.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=\ngithub.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1 h1:QbL/5oDUmRBzO9/Z7Seo6zf912W/a6Sr4Eu0G/3Jho0=\ngithub.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4 h1:WtGNWLvXpe6ZudgnXrq0barxBImvnnJoMEhXAzcbM0I=\ngithub.com/go-kit/kit v0.9.0 h1:wDJmvq38kDhkVxi50ni9ykkdUr1PKgqKOoi01fa0Mdk=\ngithub.com/go-kit/log v0.1.0 h1:DGJh0Sm43HbOeYDNnVZFl8BvcYVvjD5bqYJvp0REbwQ=\ngithub.com/go-logfmt/logfmt v0.5.0 h1:TrB8swr/68K7m9CcGut2g3UOihhbcbiMAYiuTXdEih4=\ngithub.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=\ngithub.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=\ngithub.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=\ngithub.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=\ngithub.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=\ngithub.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=\ngithub.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=\ngithub.com/godbus/dbus/v5 v5.0.4 h1:9349emZab16e7zQvpmsbtjc18ykshndd8y2PG3sgJbA=\ngithub.com/gogo/protobuf v1.1.1 h1:72R+M5VuhED/KujmZVcIquuo8mBgX4oVda//DQb3PXo=\ngithub.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=\ngithub.com/golang/mock v1.4.4 h1:l75CXGRSwbaYNpl/Z2X1XIIAMSCquvXgpVZDhwEIJsc=\ngithub.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo=\ngithub.com/google/generative-ai-go v0.17.0 h1:kUmCXUIwJouD7I7ev3OmxzzQVICyhIWAxaXk2yblCMY=\ngithub.com/google/generative-ai-go v0.17.0/go.mod h1:JYolL13VG7j79kM5BtHz4qwONHkeJQzOCkKXnpqtS/E=\ngithub.com/google/gofuzz v1.0.0 h1:A8PeW59pxE9IoFRqBp37U+mSNaQoZ46F1f0f863XSXw=\ngithub.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no=\ngithub.com/google/martian/v3 v3.0.0 h1:pMen7vLs8nvgEYhywH3KDWJIJTeEr2ULsVWHWYHQyBs=\ngithub.com/google/renameio v0.1.0 h1:GOZbcHa3HfsPKPlmyPyN2KEohoMXOhdMbHrvbpl2QaA=\ngithub.com/google/renameio/v2 v2.0.0 h1:UifI23ZTGY8Tt29JbYFiuyIU3eX+RNFtUwefq9qAhxg=\ngithub.com/google/renameio/v2 v2.0.0/go.mod h1:BtmJXm5YlszgC+TD4HOEEUFgkJP3nLxehU6hfe7jRt4=\ngithub.com/google/s2a-go v0.1.8 h1:zZDs9gcbt9ZPLV0ndSyQk6Kacx2g/X+SKYovpnz3SMM=\ngithub.com/google/s2a-go v0.1.8/go.mod h1:6iNWHTpQ+nfNRN5E00MSdfDwVesa8hhS32PhPO8deJA=\ngithub.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=\ngithub.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=\ngithub.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs=\ngithub.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0=\ngithub.com/googleapis/gax-go/v2 v2.13.0 h1:yitjD5f7jQHhyDsnhKEBU52NdvvdSeGzlAnDPT0hH1s=\ngithub.com/googleapis/gax-go/v2 v2.13.0/go.mod h1:Z/fvTZXF8/uw7Xu5GuslPw+bplx6SS338j1Is2S+B7A=\ngithub.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=\ngithub.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=\ngithub.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU=\ngithub.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=\ngithub.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=\ngithub.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6 h1:UDMh68UUwekSh5iP2OMhRRZJiiBccgV7axzUG8vi56c=\ngithub.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=\ngithub.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=\ngithub.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=\ngithub.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=\ngithub.com/jackc/pgx/v5 v5.4.3 h1:cxFyXhxlvAifxnkKKdlxv8XqUf59tDlYjnV5YYfsJJY=\ngithub.com/jackc/pgx/v5 v5.4.3/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA=\ngithub.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=\ngithub.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=\ngithub.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=\ngithub.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=\ngithub.com/jpillora/backoff v1.0.0 h1:uvFg412JmmHBHw7iwprIxkPMI+sGQ4kzOWsMeHnm2EA=\ngithub.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=\ngithub.com/jstemmer/go-junit-report v0.9.1 h1:6QPYqodiu3GuPL+7mfx+NwDdp2eTkp9IfEUpgAwUN0o=\ngithub.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=\ngithub.com/kisielk/gotool v1.0.0 h1:AV2c/EiW3KqPNT9ZKl07ehoAGi4C5/01Cfbblndcapg=\ngithub.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=\ngithub.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=\ngithub.com/kr/pty v1.1.1 h1:VkoXIwSboBpnk99O/KFauAEILuNHv5DVFKZMBN/gUgw=\ngithub.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=\ngithub.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=\ngithub.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4=\ngithub.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I=\ngithub.com/magefile/mage v1.14.0 h1:6QDX3g6z1YvJ4olPhT1wksUcSa/V0a1B+pJb73fBjyo=\ngithub.com/magefile/mage v1.14.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A=\ngithub.com/magiconair/properties v1.8.6 h1:5ibWZ6iY0NctNGWo87LalDlEZ6R41TqbbDamhfG/Qzo=\ngithub.com/magiconair/properties v1.8.6/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=\ngithub.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 h1:zpIH83+oKzcpryru8ceC6BxnoG8TBrhgAvRg8obzup0=\ngithub.com/mgechev/dots v0.0.0-20210922191527-e955255bf517/go.mod h1:KQ7+USdGKfpPjXk4Ga+5XxQM4Lm4e3gAogrreFAYpOg=\ngithub.com/mitchellh/go-ps v1.0.0 h1:i6ampVEEF4wQFF+bkYfwYgY+F/uYJDktmvLPf7qIgjc=\ngithub.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg=\ngithub.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=\ngithub.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=\ngithub.com/mmcloughlin/avo v0.5.0 h1:nAco9/aI9Lg2kiuROBY6BhCI/z0t5jEvJfjWbL8qXLU=\ngithub.com/mmcloughlin/avo v0.5.0/go.mod h1:ChHFdoV7ql95Wi7vuq2YT1bwCJqiWdZrQ1im3VujLYM=\ngithub.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=\ngithub.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=\ngithub.com/mozilla/tls-observatory v0.0.0-20210609171429-7bc42856d2e5 h1:0KqC6/sLy7fDpBdybhVkkv4Yz+PmB7c9Dz9z3dLW804=\ngithub.com/mozilla/tls-observatory v0.0.0-20210609171429-7bc42856d2e5/go.mod h1:FUqVoUPHSEdDR0MnFM3Dh8AU0pZHLXUD127SAJGER/s=\ngithub.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f h1:KUppIJq7/+SVif2QVs3tOP0zanoHgBEVAwHxUSIzRqU=\ngithub.com/otiai10/curr v1.0.0 h1:TJIWdbX0B+kpNagQrjgq8bCMrbhiuX73M2XwgtDMoOI=\ngithub.com/otiai10/mint v1.3.1 h1:BCmzIS3n71sGfHB5NMNDB3lHYPz8fWSkCAErHed//qc=\ngithub.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8=\ngithub.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=\ngithub.com/phayes/checkstyle v0.0.0-20170904204023-bfd46e6a821d h1:CdDQnGF8Nq9ocOS/xlSptM1N3BbrA6/kmaep5ggwaIA=\ngithub.com/phayes/checkstyle v0.0.0-20170904204023-bfd46e6a821d/go.mod h1:3OzsM7FXDQlpCiw2j81fOmAwQLnZnLGXVKUzeKQXIAw=\ngithub.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e h1:aoZm08cpOy4WuID//EZDgcC4zIxODThtZNPirFr42+A=\ngithub.com/pkg/profile v1.7.0 h1:hnbDkaNWPCLMO9wGLdBFTIZvzDrDfBM2072E1S9gJkA=\ngithub.com/pkg/profile v1.7.0/go.mod h1:8Uer0jas47ZQMJ7VD+OHknK4YDY07LPUC6dEvqDjvNo=\ngithub.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw=\ngithub.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=\ngithub.com/quasilyte/go-ruleguard/rules v0.0.0-20211022131956-028d6511ab71 h1:CNooiryw5aisadVfzneSZPswRWvnVW8hF1bS/vo8ReI=\ngithub.com/quasilyte/go-ruleguard/rules v0.0.0-20211022131956-028d6511ab71/go.mod h1:4cgAphtvu7Ftv7vOT2ZOYhC6CvBxZixcasr8qIOTA50=\ngithub.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=\ngithub.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=\ngithub.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=\ngithub.com/shirou/gopsutil/v3 v3.24.5 h1:i0t8kL+kQTvpAYToeuiVk3TgDeKOFioZO3Ztz/iZ9pI=\ngithub.com/shirou/gopsutil/v3 v3.24.5/go.mod h1:bsoOS1aStSs9ErQ1WWfxllSeS1K5D+U30r2NfcubMVk=\ngithub.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=\ngithub.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=\ngithub.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e h1:MZM7FHLqUHYI0Y/mQAt3d2aYa0SiNms/hFqC9qJYolM=\ngithub.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041 h1:llrF3Fs4018ePo4+G/HV/uQUqEI1HMDjCeOf2V6puPc=\ngithub.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=\ngithub.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=\ngithub.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU=\ngithub.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI=\ngithub.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk=\ngithub.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY=\ngithub.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=\ngithub.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=\ngithub.com/valyala/quicktemplate v1.8.0 h1:zU0tjbIqTRgKQzFY1L42zq0qR3eh4WoQQdIdqCysW5k=\ngithub.com/valyala/quicktemplate v1.8.0/go.mod h1:qIqW8/igXt8fdrUln5kOSb+KWMaJ4Y8QUsfd1k6L2jM=\ngithub.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 h1:QldyIu/L63oPpyvQmHgvgickp1Yw510KJOqX7H24mg8=\ngithub.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=\ngithub.com/yuin/goldmark v1.4.13 h1:fVcFKWvrslecOb/tg+Cc05dkeYx540o0FuFt3nUVDoE=\ngithub.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=\ngithub.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=\ngo.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=\ngo.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=\ngo.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.51.0 h1:A3SayB3rNyt+1S6qpI9mHPkeHTZbD7XILEqWnYZb2l0=\ngo.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.51.0/go.mod h1:27iA5uvhuRNmalO+iEUdVn5ZMj2qy10Mm+XRIpRmyuU=\ngo.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.51.0 h1:Xs2Ncz0gNihqu9iosIZ5SkBbWo5T8JhhLJFMQL1qmLI=\ngo.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.51.0/go.mod h1:vy+2G/6NvVMpwGX/NyLqcC41fxepnuKHk16E6IZUcJc=\ngo.opentelemetry.io/otel v1.26.0 h1:LQwgL5s/1W7YiiRwxf03QGnWLb2HW4pLiAhaA5cZXBs=\ngo.opentelemetry.io/otel v1.26.0/go.mod h1:UmLkJHUAidDval2EICqBMbnAd0/m2vmpf/dAM+fvFs4=\ngo.opentelemetry.io/otel/metric v1.26.0 h1:7S39CLuY5Jgg9CrnA9HHiEjGMF/X2VHvoXGgSllRz30=\ngo.opentelemetry.io/otel/metric v1.26.0/go.mod h1:SY+rHOI4cEawI9a7N1A4nIg/nTQXe1ccCNWYOJUrpX4=\ngo.opentelemetry.io/otel/trace v1.26.0 h1:1ieeAUb4y0TE26jUFrCIXKpTuVK7uJGN9/Z/2LP5sQA=\ngo.opentelemetry.io/otel/trace v1.26.0/go.mod h1:4iDxvGDQuUkHve82hJJ8UqrwswHYsZuWCBllGV2U2y0=\ngolang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=\ngolang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=\ngolang.org/x/image v0.0.0-20190802002840-cff245a6509b h1:+qEpEAPhDZ1o0x3tHzZTQDArnOixOzGD9HUJfcg0mb4=\ngolang.org/x/lint v0.0.0-20210508222113-6edffad5e616 h1:VLliZ0d+/avPrXXH+OakdXhpJuEoBZuwh1m2j7U6Iug=\ngolang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=\ngolang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028 h1:4+4C/Iv2U4fMZBiMCc98MG1In4gJY5YRhtpDNeDeHWs=\ngolang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=\ngolang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=\ngolang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=\ngolang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=\ngolang.org/x/oauth2 v0.22.0 h1:BzDx2FehcG7jJwgWLELCdmLuxk2i+x9UDpSiss2u0ZA=\ngolang.org/x/oauth2 v0.22.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=\ngolang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=\ngolang.org/x/telemetry v0.0.0-20250807160809-1a19826ec488 h1:3doPGa+Gg4snce233aCWnbZVFsyFMo/dR40KK/6skyE=\ngolang.org/x/telemetry v0.0.0-20250807160809-1a19826ec488/go.mod h1:fGb/2+tgXXjhjHsTNdVEEMZNWA0quBnfrO+AfoDSAKw=\ngolang.org/x/telemetry v0.0.0-20260209163413-e7419c687ee4 h1:bTLqdHv7xrGlFbvf5/TXNxy/iUwwdkjhqQTJDjW7aj0=\ngolang.org/x/telemetry v0.0.0-20260209163413-e7419c687ee4/go.mod h1:g5NllXBEermZrmR51cJDQxmJUHUOfRAaNyWBM+R+548=\ngolang.org/x/time v0.6.0 h1:eTDhh4ZXt5Qf0augr54TN6suAUudPcawVZeIAPU7D4U=\ngolang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=\ngolang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=\ngolang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=\ngoogle.golang.org/api v0.192.0 h1:PljqpNAfZaaSpS+TnANfnNAXKdzHM/B9bKhwRlo7JP0=\ngoogle.golang.org/api v0.192.0/go.mod h1:9VcphjvAxPKLmSxVSzPlSRXy/5ARMEw5bf58WoVXafQ=\ngoogle.golang.org/appengine v1.6.6 h1:lMO5rYAqUxkmaj76jAkRUvt5JZgFymx/+Q5Mzfivuhc=\ngoogle.golang.org/genproto v0.0.0-20200825200019-8632dd797987 h1:PDIOdWxZ8eRizhKa1AAvY53xsvLB1cWorMjslvY3VA8=\ngoogle.golang.org/genproto/googleapis/api v0.0.0-20240711142825-46eb208f015d h1:kHjw/5UfflP/L5EbledDrcG4C2597RtymmGRZvHiCuY=\ngoogle.golang.org/genproto/googleapis/api v0.0.0-20240711142825-46eb208f015d/go.mod h1:mw8MG/Qz5wfgYr6VqVCiZcHe/GJEfI+oGGDCohaVgB0=\ngoogle.golang.org/genproto/googleapis/rpc v0.0.0-20240730163845-b1a4ccb954bf h1:liao9UHurZLtiEwBgT9LMOnKYsHze6eA6w1KQCMVN2Q=\ngoogle.golang.org/genproto/googleapis/rpc v0.0.0-20240730163845-b1a4ccb954bf/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=\ngoogle.golang.org/grpc v1.64.1 h1:LKtvyfbX3UGVPFcGqJ9ItpVWW6oN/2XqTxfAnwRRXiA=\ngoogle.golang.org/grpc v1.64.1/go.mod h1:hiQF4LFZelK2WKaP6W0L92zGHtiQdZxk8CrSdvyjeP0=\ngopkg.in/alecthomas/kingpin.v2 v2.2.6 h1:jMFz6MfLP0/4fUyZle81rXUoxOBFi19VUFKVDOQfozc=\ngopkg.in/errgo.v2 v2.1.0 h1:0vLT13EuvQ0hNvakwLuFZ/jYrLp5F3kcWHXdRggjCE8=\ngopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=\ngopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=\nmvdan.cc/editorconfig v0.2.1-0.20231228180347-1925077f8eb2 h1:8nmqQGVnHUtHuT+yvuA49lQK0y5il5IOr2PtCBkDI2M=\nmvdan.cc/editorconfig v0.2.1-0.20231228180347-1925077f8eb2/go.mod h1:r8RiQJRtzrPrZdcdEs5VCMqvRxAzYDUu9a4S9z7fKh8=\nrsc.io/binaryregexp v0.2.0 h1:HfqmD5MEmC0zvwBuF187nq9mdnXjXsSivRiXN7SmRkE=\nrsc.io/quote/v3 v3.1.0 h1:9JKUTTIUgS6kzR9mK1YuGKv6Nl+DijDNIc0ghT58FaY=\nrsc.io/sampler v1.3.0 h1:7uVkIFmeBqHfdjD+gZwtXXI+RODJ2Wc4O7MPEh/QiW4=\n" }, { "path": "internal/cmd/init.go", "content": "package cmd\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"os\"\n\n\t\"github.com/spf13/cobra\"\n\t\"github.com/vektra/mockery/v3/config\"\n\t\"github.com/vektra/mockery/v3/internal/logging\"\n\t\"gopkg.in/yaml.v3\"\n)\n\nfunc addr[T any](v T) *T {\n\treturn &v\n}\n\nfunc NewInitCmd() *cobra.Command {\n\treturn &cobra.Command{\n\t\tUse: \"init [module_name]\",\n\t\tShort: \"Generate a basic .mockery.yml file\",\n\t\tLong: `This command generates a basic .mockery.yml file that can be used as a starting point for your config.`,\n\t\tArgs: cobra.ExactArgs(1),\n\t\tRun: func(cmd *cobra.Command, args []string) {\n\t\t\tinitRun(args, cmd.Parent().PersistentFlags())\n\t\t},\n\t}\n}\n\ntype argGetter interface {\n\tGetString(name string) (string, error)\n}\n\nfunc initRun(args []string, params argGetter) {\n\tlog, err := logging.GetLogger(\"info\")\n\tif err != nil {\n\t\tfmt.Println(err)\n\t\tos.Exit(1)\n\t}\n\tfilename, err := params.GetString(\"config\")\n\tif err != nil {\n\t\tlog.Err(err).Msg(\"failed to get --config value\")\n\t\tos.Exit(1)\n\t}\n\tif filename == \"\" {\n\t\tfilename = \".mockery.yml\"\n\t}\n\n\tmoduleName := args[0]\n\tlog.Info().Str(\"file\", filename).Msg(\"writing to file\")\n\tdefer log.Info().Msg(\"done\")\n\n\tctx := log.WithContext(context.Background())\n\tk, err := config.NewDefaultKoanf(ctx)\n\tif err != nil {\n\t\tlog.Err(err).Msg(\"failed getting koanf\")\n\t\tos.Exit(1)\n\t}\n\trootConf := &config.RootConfig{}\n\tif err := k.Unmarshal(\"\", rootConf); err != nil {\n\t\tlog.Err(err).Msg(\"failed to unmarshal koanf\")\n\t\tos.Exit(1)\n\t}\n\trootConf.Packages = map[string]*config.PackageConfig{\n\t\tmoduleName: {\n\t\t\tConfig: &config.Config{\n\t\t\t\tAll: addr(true),\n\t\t\t},\n\t\t\tInterfaces: map[string]*config.InterfaceConfig{},\n\t\t},\n\t}\n\n\toutFile := filename\n\tf, err := os.Create(outFile)\n\tif err != nil {\n\t\tlog.Err(err).Msg(\"failed to open file\")\n\t\tos.Exit(1)\n\t}\n\tdefer f.Close()\n\n\tencoder := yaml.NewEncoder(f)\n\tdefer encoder.Close()\n\tencoder.SetIndent(2)\n\tif err := encoder.Encode(rootConf); err != nil {\n\t\tlog.Err(err).Msg(\"failed to encode\")\n\t\tos.Exit(1)\n\t}\n}\n" }, { "path": "internal/cmd/init_test.go", "content": "package cmd\n\nimport (\n\t\"os\"\n\t\"path/filepath\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nvar expectedConfig string = `all: false\ndir: '{{.InterfaceDir}}'\nfilename: mocks_test.go\nforce-file-write: true\nformatter: goimports\nformatter-options:\n goimports:\n all-errors: false\n comments: true\n format-only: true\n fragment: false\n local-prefix: \"\"\n tab-indent: true\n tab-width: 8\ngenerate: true\ninclude-auto-generated: false\nlog-level: info\nstructname: '{{.Mock}}{{.InterfaceName}}'\npkgname: '{{.SrcPackageName}}'\nrecursive: false\nrequire-template-schema-exists: true\ntemplate: testify\ntemplate-schema: '{{.Template}}.schema.json'\npackages:\n github.com/org/repo:\n config:\n all: true\n`\n\nfunc Test_initRun(t *testing.T) {\n\ttype args struct {\n\t\targs []string\n\t\tparams func(t *testing.T, configPath string) argGetter\n\t}\n\ttests := []struct {\n\t\tname string\n\t\tconfigPath string\n\t\targs args\n\t}{\n\t\t{\n\t\t\tname: \"specify --config case\",\n\t\t\targs: args{\n\t\t\t\targs: []string{\"github.com/org/repo\"},\n\t\t\t\tparams: func(t *testing.T, configPath string) argGetter {\n\t\t\t\t\tm := newMockargGetter(t)\n\t\t\t\t\tm.EXPECT().GetString(\"config\").Return(configPath, nil)\n\t\t\t\t\treturn m\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.name, func(t *testing.T) {\n\t\t\ttmpDir := t.TempDir()\n\t\t\tconfig := filepath.Join(tmpDir, \"out.yml\")\n\t\t\tinitRun(tt.args.args, tt.args.params(t, config))\n\n\t\t\tb, err := os.ReadFile(config)\n\t\t\trequire.NoError(t, err)\n\t\t\tassert.Equal(t, expectedConfig, string(b))\n\t\t})\n\t}\n}\n" }, { "path": "internal/cmd/migrate.go", "content": "package cmd\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"os\"\n\t\"reflect\"\n\t\"strings\"\n\n\t\"github.com/jedib0t/go-pretty/v6/table\"\n\t\"github.com/jedib0t/go-pretty/v6/text\"\n\t\"github.com/rs/zerolog\"\n\t\"github.com/spf13/cobra\"\n\t\"github.com/vektra/mockery/v3/config\"\n\tinternalConfig \"github.com/vektra/mockery/v3/internal/config\"\n\t\"github.com/vektra/mockery/v3/internal/logging\"\n\t\"golang.org/x/term\"\n\t\"gopkg.in/yaml.v3\"\n)\n\nfunc NewMigrateCmd() *cobra.Command {\n\tcmd := &cobra.Command{\n\t\tUse: \"migrate\",\n\t\tShort: \"Migrate v2 config to v3.\",\n\t\tLong: `This command automatically migrates a v2 config to v3.`,\n\t\tRun: func(cmd *cobra.Command, args []string) {\n\t\t\tlogLevel, err := cmd.Flags().GetString(\"log-level\")\n\t\t\tif err != nil {\n\t\t\t\tfmt.Printf(\"%v\\n\", err)\n\t\t\t\tos.Exit(1)\n\t\t\t}\n\t\t\tif logLevel == \"\" {\n\t\t\t\tlogLevel = \"info\"\n\t\t\t}\n\t\t\tlog, err := logging.GetLogger(logLevel)\n\t\t\tif err != nil {\n\t\t\t\tfmt.Printf(\"%v\\n\", err)\n\t\t\t\tos.Exit(1)\n\t\t\t}\n\n\t\t\tctx := log.WithContext(context.Background())\n\t\t\tv2ConfPath, err := cmd.Flags().GetString(\"config\")\n\t\t\tif err != nil {\n\t\t\t\tlog.Err(err).Msg(\"failed to get parameter\")\n\t\t\t\tos.Exit(1)\n\t\t\t}\n\t\t\tv3ConfigPath, err := cmd.Flags().GetString(\"outfile\")\n\t\t\tif err != nil {\n\t\t\t\tlog.Err(err).Msg(\"failed to get parameter\")\n\t\t\t\tos.Exit(1)\n\t\t\t}\n\n\t\t\tif err := run(\n\t\t\t\tctx,\n\t\t\t\tv2ConfPath,\n\t\t\t\tv3ConfigPath,\n\t\t\t); err != nil {\n\t\t\t\tlog.Err(err).Msg(\"failed to run\")\n\t\t\t\tfmt.Printf(\"%v\\n\", err)\n\t\t\t\tos.Exit(1)\n\t\t\t}\n\t\t},\n\t}\n\tflags := cmd.PersistentFlags()\n\tflags.String(\"outfile\", \".mockery_v3.yml\", \"Location of the ouptut v3 file.\")\n\n\treturn cmd\n}\n\ntype tableWriter struct {\n\tseenMessages map[string]any\n\ttbl table.Writer\n\tidx int\n\ttermWidth int\n\tmessageWrapWidth int\n}\n\nfunc newTableWriter(ctx context.Context) *tableWriter {\n\tlog := zerolog.Ctx(ctx)\n\ttbl := table.NewWriter()\n\n\twidth, _, err := term.GetSize(int(os.Stdout.Fd())) //nolint:gosec // integer overflow warnings are inevitable because of argument types\n\tif err != nil {\n\t\tlog.Warn().Err(err).Msg(\"failed to get terminal size\")\n\t} else {\n\t\ttbl.SetOutputMirror(os.Stdout)\n\t}\n\n\ttbl.SetTitle(\"Deprecations\")\n\ttbl.Style().Title.Align = text.AlignCenter\n\ttbl.Style().Box = table.StyleBoxRounded\n\ttbl.Style().Size.WidthMax = width\n\ttbl.Style().Options.SeparateRows = true\n\ttbl.Style().Options.SeparateColumns = false\n\n\ttbl.AppendHeader(\n\t\ttable.Row{\n\t\t\t\"Idx\",\n\t\t\t\"Deprecation Type\",\n\t\t\t\"Message\",\n\t\t},\n\t)\n\n\treturn &tableWriter{\n\t\tseenMessages: map[string]any{},\n\t\ttbl: tbl,\n\t\tidx: 0,\n\t\ttermWidth: width,\n\t\tmessageWrapWidth: width - 35,\n\t}\n}\n\nfunc (t *tableWriter) Append(depType string, msg string) {\n\tif _, seen := t.seenMessages[msg]; seen {\n\t\treturn\n\t}\n\tt.seenMessages[msg] = struct{}{}\n\tt.tbl.AppendRow(table.Row{\n\t\tfmt.Sprintf(\"%d\", t.idx),\n\t\tdepType,\n\t\ttext.WrapSoft(msg, t.messageWrapWidth),\n\t})\n\tt.idx++\n}\n\nfunc (t *tableWriter) Render() {\n\tt.tbl.Render()\n}\n\nfunc run(ctx context.Context, confPathStr string, v3ConfPath string) error {\n\tvar confPath string\n\tvar err error\n\n\tlog := zerolog.Ctx(ctx)\n\tif confPathStr == \"\" {\n\t\tconfPath, err = internalConfig.FindConfig()\n\t\tif err != nil {\n\t\t\treturn fmt.Errorf(\"finding config: %w\", err)\n\t\t}\n\t} else {\n\t\tconfPath = confPathStr\n\t}\n\tlog.UpdateContext(func(c zerolog.Context) zerolog.Context {\n\t\treturn c.Str(\"config\", confPath)\n\t})\n\tlog.Info().Msg(\"using config\")\n\n\tvar v2 V2RootConfig\n\tf, err := os.Open(confPath)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"opening config file: %w\", err)\n\t}\n\tdefer f.Close()\n\tdecoder := yaml.NewDecoder(f)\n\tdecoder.KnownFields(true)\n\tif err := decoder.Decode(&v2); err != nil {\n\t\tlog.Error().Msg(\"v2 config could not be decoded. Are you sure this is a v2 config file?\")\n\t\treturn fmt.Errorf(\"decoding v2 config: %w\", err)\n\t}\n\n\tvar v3 config.RootConfig\n\tvar v3Config *config.Config = &config.Config{}\n\tv3Config.TemplateData = map[string]any{}\n\t// unroll-variadic is defaulted to true in v2, so we should set this as\n\t// the top-level default (unless of course it has been explicitly set\n\t// at the top-level v2 config)\n\tv3Config.TemplateData[\"unroll-variadic\"] = addr(true)\n\n\ttbl := newTableWriter(ctx)\n\n\tmigrateConfig(ctx, tbl, &v2.V2Config, &v3Config)\n\tv3Config.Template = addr(\"testify\")\n\tv3.Config = *v3Config\n\n\tfor pkgName, pkgConfig := range v2.Packages {\n\t\tpkgLog := log.With().Str(\"pkg-name\", pkgName).Logger()\n\t\tpkgCtx := pkgLog.WithContext(ctx)\n\n\t\tv3PkgConfig := &config.PackageConfig{}\n\t\tif v3.Packages == nil {\n\t\t\tv3.Packages = map[string]*config.PackageConfig{}\n\t\t}\n\t\tv3.Packages[pkgName] = v3PkgConfig\n\t\tmigrateConfig(pkgCtx, tbl, pkgConfig.Config, &v3PkgConfig.Config)\n\n\t\tfor interfaceName, interfaceConfig := range pkgConfig.Interfaces {\n\t\t\tifaceLog := pkgLog.With().Str(\"interface-name\", interfaceName).Logger()\n\t\t\tifaceCtx := ifaceLog.WithContext(pkgCtx)\n\n\t\t\tv3InterfaceConfig := config.InterfaceConfig{}\n\t\t\tif v3PkgConfig.Interfaces == nil {\n\t\t\t\tv3PkgConfig.Interfaces = map[string]*config.InterfaceConfig{}\n\t\t\t}\n\t\t\tv3PkgConfig.Interfaces[interfaceName] = &v3InterfaceConfig\n\n\t\t\tmigrateConfig(ifaceCtx, tbl, interfaceConfig.Config, &v3InterfaceConfig.Config)\n\n\t\t\tfor _, v2SubConfig := range interfaceConfig.Configs {\n\t\t\t\tv3SubConfig := &config.Config{}\n\t\t\t\tv3InterfaceConfig.Configs = append(v3InterfaceConfig.Configs, v3SubConfig)\n\t\t\t\tmigrateConfig(ifaceCtx, tbl, &v2SubConfig, &v3SubConfig)\n\t\t\t}\n\t\t}\n\t}\n\n\toutFile := v3ConfPath\n\tfile, err := os.Create(outFile)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"opening .mockery_v3.yml: %w\", err)\n\t}\n\tdefer file.Close()\n\n\tencoder := yaml.NewEncoder(file)\n\tdefer encoder.Close()\n\tencoder.SetIndent(2)\n\n\tlog.Info().Str(\"v3-config\", outFile).Msg(\"writing v3 config\")\n\tif err := encoder.Encode(v3); err != nil {\n\t\treturn fmt.Errorf(\"encoding .mockery_v3.yml: %w\", err)\n\t}\n\n\tif len(tbl.seenMessages) != 0 {\n\t\tlog.Warn().Msg(\"breaking changes detected that possibly require manual intervention. See table below.\")\n\t\ttbl.Render()\n\t}\n\treturn nil\n}\n\nfunc checkDeprecatedTemplateVariables(\n\tctx context.Context,\n\tconf *V2Config,\n\ttbl *tableWriter,\n) {\n\tlog := zerolog.Ctx(ctx)\n\tconfValue := reflect.ValueOf(conf).Elem()\n\tfor i := range confValue.NumField() {\n\t\tfieldValue := confValue.Field(i)\n\n\t\tisPointerToString := fieldValue.Kind() == reflect.Pointer && fieldValue.Elem().Kind() == reflect.String\n\t\tisString := fieldValue.Kind() == reflect.String\n\n\t\tif !isPointerToString && !isString {\n\t\t\tlog.Debug().Str(\"field\", fieldValue.String()).Bool(\"pointerToString\", isPointerToString).Bool(\"string\", isString).Msg(\"field is not a pointer\")\n\t\t\tcontinue\n\t\t}\n\t\tvar fieldAsString string\n\t\tif isString {\n\t\t\tfieldAsString = fieldValue.Interface().(string)\n\t\t} else {\n\t\t\tfieldAsString = fieldValue.Elem().Interface().(string)\n\t\t}\n\t\tlog.Debug().Str(\"field-as-string\", fieldAsString).Str(\"field-name\", confValue.Type().Field(i).Name).Msg(\"field as string\")\n\n\t\tfor _, deprecatedVariable := range []struct {\n\t\t\tname string\n\t\t\tmessage string\n\t\t}{\n\t\t\t{\n\t\t\t\tname: \"InterfaceNameCamel\",\n\t\t\t\tmessage: \"InterfaceNameCamel template variable has been deleted. Use \\\"{{ .InterfaceName | camelcase }}\\\" instead\",\n\t\t\t},\n\t\t\t{\n\t\t\t\tname: \"InterfaceNameLowerCamel\",\n\t\t\t\tmessage: \"InterfaceNameLowerCamel template variable has been deleted. Use \\\"{{ .InterfaceName | camelcase | firstLower }}\\\" instead\",\n\t\t\t},\n\t\t\t{\n\t\t\t\tname: \"InterfaceNameSnake\",\n\t\t\t\tmessage: \"InterfaceNameSnake template variable has been deleted. Use \\\"{{ .InterfaceName | snakecase }}\\\" instead\",\n\t\t\t},\n\t\t\t{\n\t\t\t\tname: \"InterfaceNameLower\",\n\t\t\t\tmessage: \"InterfaceNameLower template variable has been deleted. Use \\\"{{ .InterfaceName | lower }}\\\" instead\",\n\t\t\t},\n\t\t\t{\n\t\t\t\tname: \"PackageName\",\n\t\t\t\tmessage: \"PackageName template variable has been deleted. Use \\\"{{ .SrcPackageName }}\\\" instead\",\n\t\t\t},\n\t\t} {\n\t\t\tif strings.Contains(fieldAsString, deprecatedVariable.name) {\n\t\t\t\ttbl.Append(\"template-variable\", deprecatedVariable.message)\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunc migrateConfig(\n\tctx context.Context,\n\ttbl *tableWriter,\n\tv2Config *V2Config,\n\tv3Config **config.Config,\n) {\n\tif v2Config == nil {\n\t\treturn\n\t}\n\tcheckDeprecatedTemplateVariables(ctx, v2Config, tbl)\n\n\t// We do this so we can lazily create a new `config` section if necessary.\n\t// It's kind of gross, but the double pointer is necessary to update the struct\n\t// that contains the *config.Config pointer.\n\tif *v3Config == nil {\n\t\t*v3Config = &config.Config{}\n\t}\n\tv3 := *v3Config\n\tv3.All = v2Config.All\n\tv3.Anchors = v2Config.Anchors\n\tif v2Config.BoilerplateFile != nil {\n\t\tif v3.TemplateData == nil {\n\t\t\tv3.TemplateData = map[string]any{}\n\t\t}\n\t\tv3.TemplateData[\"boilerplate-file\"] = v2Config.BoilerplateFile\n\t}\n\n\tif v2Config.BuildTags != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`tags` is no longer supported, parameter not migrated. Use `template-data.mock-build-tags` instead.\")\n\t}\n\tif v2Config.Case != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`case` is no longer supported. Use `structname` to specify the name and exported-ness of the output mocks.\")\n\t}\n\tv3.ConfigFile = v2Config.Config\n\tif v2Config.Cpuprofile != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`cpuprofile` is not supported in v3, however we welcome PRs to implement the feature: https://github.com/vektra/mockery/issues/956\")\n\t}\n\tv3.Dir = v2Config.Dir\n\tif v2Config.DisableConfigSearch != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`disable-config-search` is permanently disabled in v3.\")\n\t}\n\t// disable-deprecation-warnings: no deprecations in v3\n\t// disabled-deprecation-warnings: no deprecations in v3\n\tif v2Config.DisableFuncMocks == nil || !*v2Config.DisableFuncMocks {\n\t\ttbl.Append(\"deprecated-parameter\", \"`disable-func-mocks` permanently enabled in v3.\")\n\t}\n\tif v2Config.DisableVersionString == nil || !*v2Config.DisableVersionString {\n\t\ttbl.Append(\"deprecated-parameter\", \"`disable-version-string` is permanently set to True in v3.\")\n\t}\n\tif v2Config.DryRun != nil && *v2Config.DryRun {\n\t\ttbl.Append(\"deprecated-parameter\", \"`dry-run` not supported in v3.\")\n\t}\n\tv3.ExcludeSubpkgRegex = v2Config.Exclude\n\tv3.ExcludeInterfaceRegex = v2Config.ExcludeRegex\n\tif v2Config.Exported != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`exported` is no longer supported. Use `structname` instead.\")\n\t}\n\tif v2Config.FailOnMissing == nil || (v2Config.FailOnMissing != nil && *v2Config.FailOnMissing == false) {\n\t\ttbl.Append(\"deprecated-parameter\", \"`fail-on-missing` is permanently set to True in v3.\")\n\t}\n\t// inpackage: deleted, should work automatically.\n\tif v2Config.InPackageSuffix != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`inpackage-suffix` is no longer supported in v3.\")\n\t}\n\tif v2Config.IncludeAutoGenerated != nil {\n\t\tv3.IncludeAutoGenerated = v2Config.IncludeAutoGenerated\n\t}\n\tv3.IncludeInterfaceRegex = v2Config.IncludeRegex\n\tif v2Config.Issue845Fix == nil || *v2Config.Issue845Fix == false {\n\t\ttbl.Append(\"deprecated-parameter\", \"`issue-845-fix` is permanently set to True in v3.\")\n\t}\n\tif v2Config.KeepTree != nil && *v2Config.KeepTree == true {\n\t\ttbl.Append(\"deprecated-parameter\", \"`keeptree` is not supported in v3. Use `dir` to specify where interfaces are located.\")\n\t}\n\tv3.LogLevel = v2Config.LogLevel\n\tif v2Config.MockBuildTags != nil {\n\t\tif v3.TemplateData == nil {\n\t\t\tv3.TemplateData = map[string]any{}\n\t\t}\n\t\tv3.TemplateData[\"mock-build-tags\"] = *v2Config.MockBuildTags\n\t}\n\tv3.StructName = v2Config.MockName\n\tif v2Config.Name != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`name` is no longer supported. Use `structname` instead.\")\n\t}\n\tif v2Config.Note != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`note` is no longer supported.\")\n\t}\n\tv3.PkgName = v2Config.Outpkg\n\tif v2Config.Output != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`output` was replaced by `dir` in v2. This value is ignored.\")\n\t}\n\tif v2Config.Packageprefix != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`packageprefix` was replaced by `outpkg` in v2. This value is ignored.\")\n\t}\n\tif v2Config.Print != nil && *v2Config.Print == true {\n\t\ttbl.Append(\"deprecated-parameter\", \"`print` is not supported in v3.\")\n\t}\n\tif v2Config.Profile != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`profile` is not supported in v3, but PRs are welcome to implement it: https://github.com/vektra/mockery/issues/955\")\n\t}\n\tif v2Config.Quiet != nil && *v2Config.Quiet == true {\n\t\ttbl.Append(\"deprecated-parameter\", \"`quiet` is not supported in v3. Use `log-level` instead.\")\n\t}\n\tv3.Recursive = v2Config.Recursive\n\tif len(v2Config.ReplaceType) != 0 {\n\t\ttbl.Append(\"deprecated-parameter\", \"`replace-type` has moved to a new schema. Cannot automatically migrate. Please visit https://vektra.github.io/mockery/latest-v3/replace-type/ for more information.\")\n\t}\n\tif v2Config.ResolveTypeAlias != nil && *v2Config.ResolveTypeAlias == true {\n\t\ttbl.Append(\"deprecated-parameter\", \"`resolve-type-alias` is permanently set to False in v3. Type aliases typically should never be resolved.\")\n\t}\n\tif v2Config.SrcPkg != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`srcpkg` is not supported in v3. Use the `packages` configuration instead.\")\n\t}\n\tif v2Config.StructName != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`structname` was replaced by `structname` in v2. This value is ignored.\")\n\t}\n\tif v2Config.TestOnly != nil {\n\t\ttbl.Append(\"deprecated-parameter\", \"`testonly` was replaced by `filename` in v2. This value is ignored and not supported in v3.\")\n\t}\n\tif v2Config.UnrollVariadic != nil {\n\t\tif v3.TemplateData == nil {\n\t\t\tv3.TemplateData = map[string]any{}\n\t\t}\n\t\tv3.TemplateData[\"unroll-variadic\"] = *v2Config.UnrollVariadic\n\t}\n\tif v2Config.WithExpecter != nil && *v2Config.WithExpecter == false {\n\t\ttbl.Append(\"deprecated-parameter\", \"`with-expecter` was removed in v3 because it is permanently enabled.\")\n\t}\n}\n\ntype V2RootConfig struct {\n\tV2Config `yaml:\",inline\"`\n\tPackages map[string]V2PackageConfig `yaml:\"packages\"`\n}\n\ntype V2PackageConfig struct {\n\tConfig *V2Config `yaml:\"config\"`\n\tInterfaces map[string]V2InterfaceConfig `yaml:\"interfaces\"`\n}\n\ntype V2InterfaceConfig struct {\n\tConfig *V2Config `yaml:\"config\"`\n\tConfigs []V2Config `yaml:\"configs\"`\n}\n\ntype V2Config struct {\n\tAll *bool `yaml:\"all\"`\n\tAnchors map[string]any `yaml:\"_anchors\"`\n\tBoilerplateFile *string `yaml:\"boilerplate-file\"` // MOVED: moved to `template-data.boilerplate-file`\n\tBuildTags *string `yaml:\"tags\"` // DELETED: use mock-build-tags instead\n\tCase *string `yaml:\"case\"` // DELETED: caseness is specified using template variables/functions in `structname`.\n\tConfig *string `yaml:\"config\"`\n\tCpuprofile *string `yaml:\"cpuprofile\"` // DELETED: not an option in v3\n\tDir *string `yaml:\"dir\"`\n\tDisableConfigSearch *bool `yaml:\"disable-config-search\"` // DEPRECATED: permanently set to `false` in v3\n\tDisableDeprecationWarnings *bool `yaml:\"disable-deprecation-warnings\"`\n\tDisabledDeprecationWarnings *[]string `yaml:\"disabled-deprecation-warnings\"`\n\tDisableFuncMocks *bool `yaml:\"disable-func-mocks\"` // DEPRECATED: func-mocks no longer generated.\n\tDisableVersionString *bool `yaml:\"disable-version-string\"` // DEPRECATED: set to true in v3\n\tDryRun *bool `yaml:\"dry-run\"`\n\tExclude []string `yaml:\"exclude\"` // MOVED: moved to `exclude-subpkg-regex` in v3\n\tExcludeRegex *string `yaml:\"exclude-regex\"`\n\tExported *bool `yaml:\"exported\"` // DELETED: Use templated parameters to define upper/lower case-ness of mock names.\n\tFailOnMissing *bool `yaml:\"fail-on-missing\"` // DEPRECATED: set to true permanently in v3\n\tFileName *string `yaml:\"filename\"`\n\tInPackage *bool `yaml:\"inpackage\"` // DELETED: mockery automatically detects the appropriate value for the parameter.\n\tInPackageSuffix *bool `yaml:\"inpackage-suffix\"` // DELETED: Use `packages` config.\n\tIncludeAutoGenerated *bool `yaml:\"include-auto-generated\"` // DELETED: not supported in v3. PRs to port functionality to v3 welcome.\n\tIncludeRegex *string `yaml:\"include-regex\"`\n\tIssue845Fix *bool `yaml:\"issue-845-fix\"` // DEPRECATED: set to true in v3\n\tKeepTree *bool `yaml:\"keeptree\"` // DELETED: mockery uses templated parameters to specify directory and filename locations.\n\tLogLevel *string `yaml:\"log-level\"`\n\tMockBuildTags *string `yaml:\"mock-build-tags\"` // MOVED: moved to `template-data.mock-build-tags`\n\tMockName *string `yaml:\"mockname\"`\n\tName *string `yaml:\"name\"` // DELETED: not supported\n\tNote *string `yaml:\"note\"` // DELETED: not supported\n\tOutpkg *string `yaml:\"outpkg\"` // DEPRECATED: Use `pkgname` instead\n\tOutput *string `yaml:\"output\"` // DELETED: Use `packages` config\n\tPackageprefix *string `yaml:\"packageprefix\"` // DEPRECATED: use `pkgname`\n\tPrint *bool `yaml:\"print\"` // DEPRECATED: printing mocks not an option\n\tProfile *string `yaml:\"profile\"` // DELETED: not an option in v3\n\tQuiet *bool `yaml:\"quiet\"` // DEPRECATED: deleted in v3 in favor of log-level\n\tRecursive *bool `yaml:\"recursive\"`\n\tReplaceType []string `yaml:\"replace-type\"` // DEPRECATED: moved to new schema in v3\n\tResolveTypeAlias *bool `yaml:\"resolve-type-alias\"` // DEPRECATED: permanently set to false in v3\n\tSrcPkg *string `yaml:\"srcpkg\"` // DELETED: Use `packages` config.\n\tStructName *string `yaml:\"structname\"` // MOVED: moved to `structname` in v3\n\tTestOnly *bool `yaml:\"testonly\"` // DEPRECATED: use `filename` to generate `_test.go` suffix.\n\tUnrollVariadic *bool `yaml:\"unroll-variadic\"` // MOVED: moved to `template-data.unroll-variadic`\n\tVersion *bool `yaml:\"version\"`\n\tWithExpecter *bool `yaml:\"with-expecter\"` // DEPRECATED: set to true in v3\n}\n" }, { "path": "internal/cmd/migrate_test.go", "content": "package cmd\n\nimport (\n\t\"context\"\n\t\"os\"\n\t\"path\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nvar v2ConfigExample string = `\nquiet: False\ndisable-version-string: True\nwith-expecter: True\nmockname: \"{{.InterfaceName}}\"\nfilename: \"{{.StructName}}_mock.go\"\noutpkg: mocks\ntags: \"custom2\"\nissue-845-fix: True\nresolve-type-alias: False\n_anchors: &inpackage_config\n all: True\n dir: \"{{.InterfaceDir}}\"\n mockname: \"Mock{{.InterfaceName}}\"\n outpkg: \"{{.PackageName}}_test\"\n filename: \"mock_{{.InterfaceNameSnake}}_test.go\"\n inpackage: False\npackages:\n github.com/vektra/mockery/v2/pkg/fixtures/buildtag/comment:\n config:\n mock-build-tags: \"custom3 && (!windows || !darwin || !freebsd)\"\n disable-version-string: true\n interfaces:\n IfaceWithCustomBuildTagInComment:\n github.com/vektra/mockery/v2/pkg:\n interfaces:\n TypesPackage:\n github.com/vektra/mockery/v2/pkg/fixtures:\n config:\n all: True\n interfaces:\n RequesterArgSameAsNamedImport:\n RequesterVariadic:\n config:\n with-expecter: False\n configs:\n - mockname: RequesterVariadicOneArgument\n unroll-variadic: False\n - mockname: RequesterVariadic\n unroll-variadic: True\n Expecter:\n config:\n with-expecter: True\n configs:\n - mockname: ExpecterAndRolledVariadic\n unroll-variadic: False\n - mockname: Expecter\n unroll-variadic: True\n RequesterReturnElided:\n VariadicNoReturnInterface:\n config:\n with-expecter: True\n unroll-variadic: False\n # Replace generic params with a new constraint and a new fixed value\n ReplaceGeneric:\n config:\n replace-type:\n - github.com/vektra/mockery/v2/pkg/fixtures.ReplaceGeneric[-TImport]=github.com/vektra/mockery/v2/pkg/fixtures/redefined_type_b.B\n - github.com/vektra/mockery/v2/pkg/fixtures.ReplaceGeneric[TConstraint]=github.com/vektra/mockery/v2/pkg/fixtures/constraints.String\n # Replace a generic param with the parent type\n ReplaceGenericSelf:\n config:\n replace-type:\n - github.com/vektra/mockery/v2/pkg/fixtures.ReplaceGenericSelf[-T]=github.com/vektra/mockery/v2/pkg/fixtures.*ReplaceGenericSelf\n github.com/vektra/mockery/v2/pkg/fixtures/recursive_generation:\n config:\n recursive: True\n all: True\n dir: \"{{.InterfaceDir}}\"\n filename: \"{{.InterfaceName}}_mock.go\"\n mockname: \"Mock{{.InterfaceName}}\"\n outpkg: \"{{.PackageName}}\"\n inpackage: True\n github.com/vektra/mockery/v2/pkg/fixtures/empty_return:\n config:\n all: True\n dir: \"{{.InterfaceDir}}\"\n mockname: \"{{.InterfaceName}}Mock\"\n outpkg: \"{{.PackageName}}\"\n filename: \"mock_{{.InterfaceName}}_test.go\"\n inpackage: True\n keeptree: False\n github.com/vektra/mockery/v2/pkg/fixtures/method_args/same_name_arg_and_type:\n config:\n all: True\n dir: \"{{.InterfaceDir}}\"\n mockname: \"{{.InterfaceName}}Mock\"\n outpkg: \"{{.PackageName}}\"\n filename: \"mock_{{.InterfaceName}}_test.go\"\n inpackage: True\n keeptree: False\n github.com/vektra/mockery/v2/pkg/fixtures/iface_typed_param:\n config: *inpackage_config\n github.com/vektra/mockery/v2/pkg/fixtures/example_project:\n config: *inpackage_config\n github.com/vektra/mockery/v2/pkg/fixtures/index_list_expr:\n config: *inpackage_config\n github.com/vektra/mockery/v2/pkg/fixtures/iface_new_type:\n config: *inpackage_config\n github.com/vektra/mockery/v2/pkg/fixtures/issue845:\n config:\n <<: *inpackage_config\n filename: \"mock_{{.StructName}}_test.go\"\n interfaces:\n Interface:\n configs:\n - issue-845-fix: False\n mockname: WithoutFix\n - issue-845-fix: True\n mockname: WithFix\n github.com/vektra/mockery/v2/pkg/fixtures/type_alias:\n config:\n all: True\n dir: \"{{.InterfaceDir}}\"\n filename: \"mock_{{.StructName}}_test.go\"\n outpkg: \"{{.PackageName}}_test\"\n inpackage: False\n interfaces:\n Interface1:\n configs:\n - resolve-type-alias: False\n mockname: InterfaceWithUnresolvedAlias\n - resolve-type-alias: True\n mockname: InterfaceWithResolvedAlias\n Interface2:\n configs:\n - resolve-type-alias: False\n mockname: Interface2WithUnresolvedAlias\n - resolve-type-alias: True\n mockname: Interface2WithResolvedAlias\n github.com/vektra/mockery/v2/pkg/:\n interfaces:\n InterfaceDoesntExist:\n github.com/vektra/mockery/v2/pkg/fixtures/auto_generated:\n config:\n all: True\n include-auto-generated: false\n interfaces:\n AutoGenerated: # include-auto-generated is false, so should be ignored\n`\n\nvar expectedV3Conf string = `_anchors:\n all: true\n dir: '{{.InterfaceDir}}'\n filename: mock_{{.InterfaceNameSnake}}_test.go\n inpackage: false\n mockname: Mock{{.InterfaceName}}\n outpkg: '{{.PackageName}}_test'\nstructname: '{{.InterfaceName}}'\npkgname: mocks\ntemplate: testify\ntemplate-data:\n unroll-variadic: true\npackages:\n github.com/vektra/mockery/v2/pkg:\n interfaces:\n TypesPackage: {}\n github.com/vektra/mockery/v2/pkg/:\n interfaces:\n InterfaceDoesntExist: {}\n github.com/vektra/mockery/v2/pkg/fixtures:\n config:\n all: true\n interfaces:\n Expecter:\n config: {}\n configs:\n - structname: ExpecterAndRolledVariadic\n template-data:\n unroll-variadic: false\n - structname: Expecter\n template-data:\n unroll-variadic: true\n ReplaceGeneric:\n config: {}\n ReplaceGenericSelf:\n config: {}\n RequesterArgSameAsNamedImport: {}\n RequesterReturnElided: {}\n RequesterVariadic:\n config: {}\n configs:\n - structname: RequesterVariadicOneArgument\n template-data:\n unroll-variadic: false\n - structname: RequesterVariadic\n template-data:\n unroll-variadic: true\n VariadicNoReturnInterface:\n config:\n template-data:\n unroll-variadic: false\n github.com/vektra/mockery/v2/pkg/fixtures/auto_generated:\n config:\n all: true\n include-auto-generated: false\n interfaces:\n AutoGenerated: {}\n github.com/vektra/mockery/v2/pkg/fixtures/buildtag/comment:\n config:\n template-data:\n mock-build-tags: custom3 && (!windows || !darwin || !freebsd)\n interfaces:\n IfaceWithCustomBuildTagInComment: {}\n github.com/vektra/mockery/v2/pkg/fixtures/empty_return:\n config:\n all: true\n dir: '{{.InterfaceDir}}'\n structname: '{{.InterfaceName}}Mock'\n pkgname: '{{.PackageName}}'\n github.com/vektra/mockery/v2/pkg/fixtures/example_project:\n config:\n all: true\n dir: '{{.InterfaceDir}}'\n structname: Mock{{.InterfaceName}}\n pkgname: '{{.PackageName}}_test'\n github.com/vektra/mockery/v2/pkg/fixtures/iface_new_type:\n config:\n all: true\n dir: '{{.InterfaceDir}}'\n structname: Mock{{.InterfaceName}}\n pkgname: '{{.PackageName}}_test'\n github.com/vektra/mockery/v2/pkg/fixtures/iface_typed_param:\n config:\n all: true\n dir: '{{.InterfaceDir}}'\n structname: Mock{{.InterfaceName}}\n pkgname: '{{.PackageName}}_test'\n github.com/vektra/mockery/v2/pkg/fixtures/index_list_expr:\n config:\n all: true\n dir: '{{.InterfaceDir}}'\n structname: Mock{{.InterfaceName}}\n pkgname: '{{.PackageName}}_test'\n github.com/vektra/mockery/v2/pkg/fixtures/issue845:\n config:\n all: true\n dir: '{{.InterfaceDir}}'\n structname: Mock{{.InterfaceName}}\n pkgname: '{{.PackageName}}_test'\n interfaces:\n Interface:\n configs:\n - structname: WithoutFix\n - structname: WithFix\n github.com/vektra/mockery/v2/pkg/fixtures/method_args/same_name_arg_and_type:\n config:\n all: true\n dir: '{{.InterfaceDir}}'\n structname: '{{.InterfaceName}}Mock'\n pkgname: '{{.PackageName}}'\n github.com/vektra/mockery/v2/pkg/fixtures/recursive_generation:\n config:\n all: true\n dir: '{{.InterfaceDir}}'\n structname: Mock{{.InterfaceName}}\n pkgname: '{{.PackageName}}'\n recursive: true\n github.com/vektra/mockery/v2/pkg/fixtures/type_alias:\n config:\n all: true\n dir: '{{.InterfaceDir}}'\n pkgname: '{{.PackageName}}_test'\n interfaces:\n Interface1:\n configs:\n - structname: InterfaceWithUnresolvedAlias\n - structname: InterfaceWithResolvedAlias\n Interface2:\n configs:\n - structname: Interface2WithUnresolvedAlias\n - structname: Interface2WithResolvedAlias\n`\n\nfunc TestMigrate(t *testing.T) {\n\ttmpdir := t.TempDir()\n\tv2File := path.Join(tmpdir, \"v2_config.yml\")\n\tv3File := path.Join(tmpdir, \"v3_config.yml\")\n\n\trequire.NoError(t, os.WriteFile(v2File, []byte(v2ConfigExample), 0o600))\n\trequire.NoError(t, run(context.Background(), v2File, v3File))\n\n\tb, err := os.ReadFile(v3File)\n\trequire.NoError(t, err)\n\tassert.Equal(t, expectedV3Conf, string(b))\n}\n" }, { "path": "internal/cmd/mockery.go", "content": "package cmd\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strings\"\n\n\t\"github.com/vektra/mockery/v3/config\"\n\t\"github.com/vektra/mockery/v3/internal\"\n\tpkg \"github.com/vektra/mockery/v3/internal\"\n\t\"github.com/vektra/mockery/v3/internal/file\"\n\t\"github.com/vektra/mockery/v3/internal/logging\"\n\t\"github.com/vektra/mockery/v3/internal/stackerr\"\n\n\t\"github.com/rs/zerolog\"\n\t\"github.com/spf13/cobra\"\n\t\"github.com/spf13/pflag\"\n\t\"golang.org/x/tools/go/packages\"\n)\n\nvar ErrCfgFileNotFound = errors.New(\"config file not found\")\n\nfunc NewRootCmd() (*cobra.Command, error) {\n\tvar pFlags *pflag.FlagSet\n\tcmd := &cobra.Command{\n\t\tUse: \"mockery\",\n\t\tShort: \"Generate mock objects for your Go interfaces\",\n\t\tRun: func(cmd *cobra.Command, args []string) {\n\t\t\tif err := pFlags.Parse(args); err != nil {\n\t\t\t\tfmt.Printf(\"failed to parse flags: %s\", err.Error())\n\t\t\t\tos.Exit(1)\n\t\t\t}\n\t\t\tlog, err := logging.GetLogger(\"info\")\n\t\t\tif err != nil {\n\t\t\t\tfmt.Printf(\"failed to get logger: %s\\n\", err.Error())\n\t\t\t\tos.Exit(1)\n\t\t\t}\n\t\t\tctx := log.WithContext(context.Background())\n\n\t\t\tr, err := GetRootApp(ctx, pFlags)\n\t\t\tif err != nil {\n\t\t\t\tlogFatalErr(ctx, err)\n\t\t\t}\n\t\t\tif err := r.Run(); err != nil {\n\t\t\t\tlogFatalErr(ctx, err)\n\t\t\t}\n\t\t},\n\t}\n\tpFlags = cmd.PersistentFlags()\n\tpFlags.String(\"config\", \"\", \"config file to use\")\n\tpFlags.String(\"log-level\", os.Getenv(\"MOCKERY_LOG_LEVEL\"), \"Level of logging\")\n\n\tcmd.AddCommand(NewShowConfigCmd())\n\tcmd.AddCommand(NewVersionCmd())\n\tcmd.AddCommand(NewInitCmd())\n\tcmd.AddCommand(NewMigrateCmd())\n\treturn cmd, nil\n}\n\nfunc logFatalErr(ctx context.Context, err error) {\n\tlog := zerolog.Ctx(ctx)\n\tlog.Fatal().Err(err).Msg(\"app failed\")\n}\n\n// Execute executes the cobra CLI workflow\nfunc Execute() {\n\tcmd, err := NewRootCmd()\n\tif err != nil {\n\t\tos.Exit(1)\n\t}\n\tif err := cmd.Execute(); err != nil {\n\t\tos.Exit(1)\n\t}\n}\n\ntype RootApp struct {\n\tConfig config.RootConfig\n}\n\nfunc GetRootApp(ctx context.Context, flags *pflag.FlagSet) (*RootApp, error) {\n\tr := &RootApp{}\n\tconfig, _, err := config.NewRootConfig(ctx, flags)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"getting config: %w\", err)\n\t}\n\tr.Config = *config\n\treturn r, nil\n}\n\n// CollectionConfig contains the common, file-global configuration\n// parameters for an InterfaceCollection. Some mockery config parameters\n// are attributes of the entire file, rather than specific interfaces.\n// For such attributes, we must assert that all interfaces within\n// a collection have these values identically set.\ntype CollectionConfig struct {\n\tInPackage *bool\n\tOutFilePath string\n\tOutPkgName string\n\tSrcPkgPath string\n\tTemplate string\n\tTemplateSchema string\n\tRequireTemplateSchemaExists bool\n}\n\n// InterfaceCollection maintains a list of *pkg.Interface and asserts that all\n// the interfaces in the collection belong to the same source package. It also\n// asserts that various properties of the interfaces added to the collection are\n// uniform.\ntype InterfaceCollection struct {\n\tsrcPkg *packages.Package\n\tinterfaces []*internal.Interface\n\tconfig CollectionConfig\n}\n\nfunc NewInterfaceCollection(\n\tsrcPkgPath string,\n\toutFilePath string,\n\tsrcPkg *packages.Package,\n\toutPkgName string,\n\ttemplate string,\n\ttemplateSchema string,\n\tinPackage *bool,\n\trequireTemplateSchemaExists bool,\n) *InterfaceCollection {\n\tconfig := CollectionConfig{\n\t\tInPackage: inPackage,\n\t\tSrcPkgPath: srcPkgPath,\n\t\tOutFilePath: outFilePath,\n\t\tOutPkgName: outPkgName,\n\t\tTemplate: template,\n\t\tTemplateSchema: templateSchema,\n\t\tRequireTemplateSchemaExists: requireTemplateSchemaExists,\n\t}\n\treturn &InterfaceCollection{\n\t\tsrcPkg: srcPkg,\n\t\tinterfaces: make([]*internal.Interface, 0),\n\t\tconfig: config,\n\t}\n}\n\nfunc (i *InterfaceCollection) Append(ctx context.Context, iface *internal.Interface) error {\n\tcollectionFilepath := i.config.OutFilePath\n\tinterfaceFilepath := iface.Config.FilePath()\n\tlog := zerolog.Ctx(ctx).With().\n\t\tStr(logging.LogKeyInterface, iface.Name).\n\t\tStr(\"collection-pkgname\", i.config.OutPkgName).\n\t\tStr(\"interface-pkgname\", *iface.Config.PkgName).\n\t\tStr(\"collection-pkgpath\", i.config.SrcPkgPath).\n\t\tStr(\"interface-pkgpath\", iface.Pkg.PkgPath).\n\t\tStr(\"collection-filepath\", collectionFilepath).\n\t\tStr(\"interface-filepath\", interfaceFilepath).\n\t\tLogger()\n\n\tif collectionFilepath != interfaceFilepath {\n\t\tmsg := \"all mocks in an InterfaceCollection must have the same output file path\"\n\t\tlog.Error().Msg(msg)\n\t\treturn errors.New(msg)\n\t}\n\tif i.config.OutPkgName != *iface.Config.PkgName {\n\t\tmsg := \"all mocks in an output file must have the same pkgname\"\n\t\tlog.Error().Str(\"interface-pkgname\", *iface.Config.PkgName).Msg(msg)\n\t\treturn errors.New(msg)\n\t}\n\tif i.config.SrcPkgPath != iface.Pkg.PkgPath {\n\t\tmsg := \"all mocks in an output file must come from the same source package\"\n\t\tlog.Error().Msg(msg)\n\t\treturn errors.New(msg)\n\t}\n\tif i.config.Template != *iface.Config.Template {\n\t\tmsg := \"all mocks in an output file must use the same template\"\n\t\tlog.Error().Str(\"expected-template\", i.config.Template).Str(\"interface-template\", *iface.Config.Template).Msg(msg)\n\t\treturn errors.New(msg)\n\t}\n\ti.interfaces = append(i.interfaces, iface)\n\treturn nil\n}\n\nfunc (r *RootApp) Run() error {\n\tremoteTemplateCache := make(map[string]*internal.RemoteTemplate)\n\n\tlog, err := logging.GetLogger(*r.Config.LogLevel)\n\tif err != nil {\n\t\tfmt.Fprintf(os.Stderr, \"Failed to initialize logger: %v\\n\", err)\n\t\treturn err\n\t}\n\tlog.Info().Str(\"config-file\", r.Config.ConfigFileUsed()).Msgf(\"Starting mockery\")\n\tctx := log.WithContext(context.Background())\n\n\tbuildTags := strings.Split(*r.Config.BuildTags, \" \")\n\n\tconfiguredPackages, err := r.Config.GetPackages(ctx)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"failed to get package from config: %w\", err)\n\t}\n\tif len(configuredPackages) == 0 {\n\t\tlog.Error().Msg(\"no packages specified in config\")\n\t\treturn fmt.Errorf(\"no packages specified in config\")\n\t}\n\tparser := pkg.NewParser(buildTags, r.Config)\n\n\t// Let's build a missing map here to keep track of seen interfaces.\n\t// (pkg -> list of interface names)\n\t// After seeing an interface it'll be deleted from the map, keeping only\n\t// missing interfaces or packages in there.\n\t//\n\t// NOTE: We do that here without relying on parser, because parses iterates\n\t// over existing go files and interfaces, while user could've had a typo in\n\t// interface or pacakge name, making it impossible for parser to find these\n\t// files/interfaces in the first place.\n\tlog.Debug().Msg(\"Making seen map...\")\n\tmissingMap := make(map[string]map[string]struct{}, len(configuredPackages))\n\tfor _, p := range configuredPackages {\n\t\tconfig, err := r.Config.GetPackageConfig(ctx, p)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tif _, ok := missingMap[p]; !ok {\n\t\t\tmissingMap[p] = make(map[string]struct{}, len(config.Interfaces))\n\t\t}\n\n\t\tfor ifaceName := range config.Interfaces {\n\t\t\tmissingMap[p][ifaceName] = struct{}{}\n\t\t}\n\t}\n\n\tlog.Info().Msg(\"Parsing configured packages...\")\n\tinterfaces, err := parser.ParsePackages(ctx, configuredPackages)\n\tif err != nil {\n\t\tlog.Error().Err(err).Msg(\"unable to parse packages\")\n\t\treturn err\n\t}\n\tlog.Info().Msg(\"Done parsing configured packages.\")\n\t// maps the following:\n\t// outputFilePath|fullyQualifiedInterfaceName|[]*pkg.Interface\n\t// The reason why we need an interior map of fully qualified interface name\n\t// to a slice of *pkg.Interface (which represents all information necessary\n\t// to create the output mock) is because mockery allows multiple mocks to\n\t// be created for each input interface.\n\tmockFileToInterfaces := map[string]*InterfaceCollection{}\n\n\tfor _, iface := range interfaces {\n\t\tifaceLog := log.\n\t\t\tWith().\n\t\t\tStr(logging.LogKeyInterface, iface.Name).\n\t\t\tStr(logging.LogKeyPackagePath, iface.Pkg.Types.Path()).\n\t\t\tLogger()\n\n\t\tif _, exist := missingMap[iface.Pkg.PkgPath]; exist {\n\t\t\tdelete(missingMap[iface.Pkg.PkgPath], iface.Name)\n\n\t\t\tif len(missingMap[iface.Pkg.PkgPath]) == 0 {\n\t\t\t\tdelete(missingMap, iface.Pkg.PkgPath)\n\t\t\t}\n\t\t}\n\n\t\tifaceCtx := ifaceLog.WithContext(ctx)\n\n\t\tpkgConfig, err := r.Config.GetPackageConfig(ctx, iface.Pkg.PkgPath)\n\t\tif err != nil {\n\t\t\treturn fmt.Errorf(\"getting package %s: %w\", iface.Pkg.PkgPath, err)\n\t\t}\n\t\tifaceLog.Debug().Str(\"root-mock-name\", *r.Config.Config.StructName).Str(\"pkg-mock-name\", *pkgConfig.Config.StructName).Msg(\"mock-name during first GetPackageConfig\")\n\n\t\t// Extract configuration from directive comments in the interface documentation\n\t\tdirectiveConfig, err := config.ExtractDirectiveConfig(ifaceCtx, iface.GenDecl)\n\t\tif err != nil {\n\t\t\treturn fmt.Errorf(\"extracting directive config for interface %s: %w\", iface.Name, err)\n\t\t}\n\n\t\tifaceConfig, err := pkgConfig.GetInterfaceConfig(ctx, iface.Name, directiveConfig)\n\t\tif err != nil {\n\t\t\treturn fmt.Errorf(\"getting interface config for %s: %w\", iface.Name, err)\n\t\t}\n\n\t\tshouldGenerate, err := pkgConfig.ShouldGenerateInterface(ifaceCtx, iface.Name, *ifaceConfig.Config, directiveConfig != nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tif !shouldGenerate {\n\t\t\tifaceLog.Debug().Msg(\"config doesn't specify to generate this interface, skipping\")\n\t\t\tcontinue\n\t\t}\n\n\t\tfor _, ifaceConfig := range ifaceConfig.Configs {\n\t\t\tif err := ifaceConfig.ParseTemplates(ifaceCtx, iface.FilePath, iface.Name, iface.Pkg); err != nil {\n\t\t\t\tlog.Err(err).Msg(\"Can't parse config templates for interface\")\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tfilePath := ifaceConfig.FilePath()\n\t\t\tifaceLog.Info().Str(\"collection\", filePath).Msg(\"adding interface to collection\")\n\n\t\t\t_, ok := mockFileToInterfaces[filePath]\n\t\t\tif !ok {\n\t\t\t\tmockFileToInterfaces[filePath] = NewInterfaceCollection(\n\t\t\t\t\tiface.Pkg.PkgPath,\n\t\t\t\t\tfilePath,\n\t\t\t\t\tiface.Pkg,\n\t\t\t\t\t*ifaceConfig.PkgName,\n\t\t\t\t\t*ifaceConfig.Template,\n\t\t\t\t\t*ifaceConfig.TemplateSchema,\n\t\t\t\t\tifaceConfig.InPackage,\n\t\t\t\t\t*ifaceConfig.RequireTemplateSchemaExists,\n\t\t\t\t)\n\t\t\t\tifaceLog.Debug().Str(\"file-path\", filePath).Msg(\"creating new interface collection\")\n\t\t\t}\n\t\t\tifaceWithTypes := internal.NewInterface(\n\t\t\t\tiface.Name,\n\t\t\t\tiface.TypeSpec,\n\t\t\t\tiface.GenDecl,\n\t\t\t\tiface.FilePath,\n\t\t\t\tiface.FileSyntax,\n\t\t\t\tiface.Pkg,\n\t\t\t\tifaceConfig)\n\t\t\tifaceLog.Debug().Str(\"ifaceWithTypes\", fmt.Sprintf(\"%+v\", ifaceWithTypes)).Msg(\"created iface with types\")\n\t\t\tif err := mockFileToInterfaces[filePath].Append(\n\t\t\t\tctx,\n\t\t\t\tifaceWithTypes,\n\t\t\t); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t}\n\n\tfor outFilePath, collection := range mockFileToInterfaces {\n\t\tfileLog := log.With().Str(\"file\", outFilePath).Logger()\n\t\tfileCtx := fileLog.WithContext(ctx)\n\n\t\tpackageConfig, err := r.Config.GetPackageConfig(fileCtx, collection.config.SrcPkgPath)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\n\t\tinterfacesInFileDir := filepath.ToSlash(filepath.Dir(collection.config.OutFilePath))\n\t\tgenerator, err := pkg.NewTemplateGenerator(\n\t\t\tfileCtx,\n\t\t\tcollection.srcPkg,\n\t\t\tinterfacesInFileDir,\n\t\t\tcollection.config.Template,\n\t\t\tcollection.config.TemplateSchema,\n\t\t\tcollection.config.RequireTemplateSchemaExists,\n\t\t\tremoteTemplateCache,\n\t\t\tpkg.Formatter(*r.Config.Formatter),\n\t\t\tpackageConfig.Config,\n\t\t\tcollection.config.OutPkgName,\n\t\t\tcollection.config.InPackage,\n\t\t)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tfileLog.Info().Msg(\"Executing template\")\n\t\ttemplateBytes, err := generator.Generate(fileCtx, collection.interfaces)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\n\t\toutFileDir := filepath.ToSlash(filepath.Dir(outFilePath))\n\t\tif outFileDir != \"\" {\n\t\t\tif err := os.MkdirAll(outFileDir, 0o755); err != nil {\n\t\t\t\tlog.Err(err).Msg(\"failed to mkdir parent directories of mock file\")\n\t\t\t\treturn stackerr.NewStackErr(err)\n\t\t\t}\n\t\t}\n\t\tfileLog.Info().Msg(\"Writing template to file\")\n\t\texists, err := file.Exists(outFilePath)\n\t\tif err != nil {\n\t\t\tfileLog.Err(err).Msg(\"can't determine if outfile exists\")\n\t\t\treturn fmt.Errorf(\"determining if outfile exists: %w\", err)\n\t\t}\n\t\tif exists && !*packageConfig.Config.ForceFileWrite {\n\t\t\tfileLog.Error().Bool(\"force-file-write\", *packageConfig.Config.ForceFileWrite).Msg(\"output file exists, can't write mocks\")\n\t\t\treturn fmt.Errorf(\"outfile exists\")\n\t\t}\n\n\t\tfile, err := os.Create(outFilePath)\n\t\tif err != nil {\n\t\t\treturn stackerr.NewStackErr(err)\n\t\t}\n\t\tdefer file.Close()\n\t\tif _, err = file.Write(templateBytes); err != nil {\n\t\t\treturn stackerr.NewStackErr(err)\n\t\t}\n\t}\n\n\t// The loop above could exit early, so sometimes warnings won't be shown\n\t// until other errors are fixed\n\tvar foundMissing bool\n\tfor packagePath := range missingMap {\n\t\tfor ifaceName := range missingMap[packagePath] {\n\t\t\tfoundMissing = true\n\t\t\tlog.Error().\n\t\t\t\tStr(logging.LogKeyInterface, ifaceName).\n\t\t\t\tStr(logging.LogKeyPackagePath, packagePath).\n\t\t\t\tStr(logging.LogKeyDocsURL, logging.DocsURL(\"/faq/#error-interface-not-found-in-source\")).\n\t\t\t\tMsg(\"interface not found in source. View the linked documentation for possible reasons why this might occur.\")\n\t\t}\n\t}\n\tif foundMissing {\n\t\tos.Exit(1)\n\t}\n\n\treturn nil\n}\n" }, { "path": "internal/cmd/mocks_testify_cmd_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage cmd\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// newMockargGetter creates a new instance of mockargGetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc newMockargGetter(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *mockargGetter {\n\tmock := &mockargGetter{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// mockargGetter is an autogenerated mock type for the argGetter type\ntype mockargGetter struct {\n\tmock.Mock\n}\n\ntype mockargGetter_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *mockargGetter) EXPECT() *mockargGetter_Expecter {\n\treturn &mockargGetter_Expecter{mock: &_m.Mock}\n}\n\n// GetString provides a mock function for the type mockargGetter\nfunc (_mock *mockargGetter) GetString(name string) (string, error) {\n\tret := _mock.Called(name)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for GetString\")\n\t}\n\n\tvar r0 string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok {\n\t\treturn returnFunc(name)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) string); ok {\n\t\tr0 = returnFunc(name)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(name)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// mockargGetter_GetString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetString'\ntype mockargGetter_GetString_Call struct {\n\t*mock.Call\n}\n\n// GetString is a helper method to define mock.On call\n// - name string\nfunc (_e *mockargGetter_Expecter) GetString(name interface{}) *mockargGetter_GetString_Call {\n\treturn &mockargGetter_GetString_Call{Call: _e.mock.On(\"GetString\", name)}\n}\n\nfunc (_c *mockargGetter_GetString_Call) Run(run func(name string)) *mockargGetter_GetString_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *mockargGetter_GetString_Call) Return(s string, err error) *mockargGetter_GetString_Call {\n\t_c.Call.Return(s, err)\n\treturn _c\n}\n\nfunc (_c *mockargGetter_GetString_Call) RunAndReturn(run func(name string) (string, error)) *mockargGetter_GetString_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/cmd/showconfig.go", "content": "package cmd\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\n\tkoanfYAML \"github.com/knadh/koanf/parsers/yaml\"\n\t\"github.com/knadh/koanf/providers/structs\"\n\t\"github.com/knadh/koanf/v2\"\n\t\"github.com/spf13/cobra\"\n\t\"github.com/vektra/mockery/v3/config\"\n\t\"github.com/vektra/mockery/v3/internal/logging\"\n)\n\nfunc NewShowConfigCmd() *cobra.Command {\n\treturn &cobra.Command{\n\t\tUse: \"showconfig\",\n\t\tShort: \"Show the yaml config\",\n\t\tLong: `Print out a yaml representation of the yaml config file. This does not show config from exterior sources like CLI, environment etc.`,\n\t\tRunE: func(cmd *cobra.Command, args []string) error {\n\t\t\tlog, err := logging.GetLogger(\"debug\")\n\t\t\tif err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\n\t\t\tctx := log.WithContext(context.Background())\n\t\t\tconf, _, err := config.NewRootConfig(ctx, cmd.Parent().PersistentFlags())\n\t\t\tif err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\n\t\t\tk := koanf.New(\"|\")\n\t\t\tif err := k.Load(structs.Provider(conf, \"koanf\"), nil); err != nil {\n\t\t\t\tlog.Err(err).Msg(\"failed to load config\")\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tb, _ := k.Marshal(koanfYAML.Parser())\n\t\t\tfmt.Println(string(b))\n\n\t\t\treturn nil\n\t\t},\n\t}\n}\n" }, { "path": "internal/cmd/version.go", "content": "package cmd\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/spf13/cobra\"\n\t\"github.com/vektra/mockery/v3/internal/logging\"\n)\n\nfunc NewVersionCmd() *cobra.Command {\n\treturn &cobra.Command{\n\t\tUse: \"version\",\n\t\tShort: \"Print the version of mockery\",\n\t\tRun: func(cmd *cobra.Command, args []string) {\n\t\t\tfmt.Println(logging.GetSemverInfo())\n\t\t},\n\t}\n}\n" }, { "path": "internal/config/config.go", "content": "package internal\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\n\t\"github.com/vektra/mockery/v3/internal/file\"\n)\n\nfunc FindConfig() (string, error) {\n\tcwd, err := os.Getwd()\n\tif err != nil {\n\t\treturn \"\", fmt.Errorf(\"getting current working directory: %w\", err)\n\t}\n\tconfigPath, _, err := file.FindInHierarchy(cwd, []string{\".mockery.yaml\", \".mockery.yml\"})\n\treturn configPath, err\n}\n" }, { "path": "internal/errors.go", "content": "package internal\n\nimport \"fmt\"\n\nvar (\n\tErrNoConfigFile = fmt.Errorf(\"no config file exists\")\n\tErrNoGoFilesFoundInRoot = fmt.Errorf(\"no go files found in root search path\")\n\tErrPkgNotFound = fmt.Errorf(\"package not found in config\")\n\tErrGoModNotFound = fmt.Errorf(\"no go.mod file found\")\n\tErrGoModInvalid = fmt.Errorf(\"go.mod file has no module line\")\n)\n" }, { "path": "internal/file/exists.go", "content": "package file\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"os\"\n)\n\nfunc Exists(name string) (bool, error) {\n\tinfo, err := os.Stat(name)\n\tif err == nil {\n\t\tif info.Mode().IsRegular() {\n\t\t\treturn true, nil\n\t\t}\n\t\treturn false, fmt.Errorf(\"%q is not a regular file\", name)\n\t}\n\tif errors.Is(err, os.ErrNotExist) {\n\t\treturn false, nil\n\t}\n\treturn false, err\n}\n" }, { "path": "internal/file/exists_test.go", "content": "package file\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestExistsDot(t *testing.T) {\n\texists, err := Exists(\".\")\n\tassert.Error(t, err)\n\tassert.False(t, exists)\n}\n\nfunc TestExistsFile(t *testing.T) {\n\texists, err := Exists(\"exists.go\")\n\tassert.NoError(t, err)\n\tassert.True(t, exists)\n}\n\nfunc TestExistsJunk(t *testing.T) {\n\texists, err := Exists(\"junk\")\n\tassert.NoError(t, err)\n\tassert.False(t, exists)\n}\n" }, { "path": "internal/file/find.go", "content": "package file\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"path\"\n\t\"path/filepath\"\n)\n\nfunc CleanPath(filePath string) (string, error) {\n\tfilePath, err := filepath.Abs(filePath)\n\tif err != nil {\n\t\treturn \"\", fmt.Errorf(\"making %q an absolute path: %w\", filePath, err)\n\t}\n\treturn filepath.ToSlash(filePath), nil\n}\n\n// FindInHierarchy looks for a file with any of the names in the hierarchy up to the root folder.\n// It returns the complete path of the file, the content and an error.\nfunc FindInHierarchy(folder string, names []string) (string, []byte, error) {\n\tfolder, err := CleanPath(folder)\n\tif err != nil {\n\t\treturn \"\", nil, err\n\t}\n\tfor {\n\t\tfor _, name := range names {\n\t\t\tfilePath := path.Join(folder, name)\n\t\t\tfile, err := os.Open(filePath)\n\t\t\tif err != nil {\n\t\t\t\tif errors.Is(err, os.ErrNotExist) {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\treturn \"\", nil, fmt.Errorf(\"checking if %q exists: %w\", filePath, err)\n\t\t\t}\n\t\t\tdefer file.Close()\n\t\t\tinfo, err := file.Stat()\n\t\t\tif err != nil {\n\t\t\t\treturn \"\", nil, fmt.Errorf(\"checking %q type: %w\", filePath, err)\n\t\t\t}\n\t\t\tif !info.Mode().IsRegular() {\n\t\t\t\treturn \"\", nil, fmt.Errorf(\"%q is not a regular file\", filePath)\n\t\t\t}\n\t\t\tcontent, err := io.ReadAll(file)\n\t\t\tif err != nil {\n\t\t\t\treturn \"\", nil, fmt.Errorf(\"reading %q: %w\", filePath, err)\n\t\t\t}\n\t\t\treturn filePath, content, nil\n\t\t}\n\t\tparent := path.Dir(folder)\n\t\tif folder == parent {\n\t\t\treturn \"\", nil, errors.New(\"file not found\")\n\t\t}\n\t\tfolder = parent\n\t}\n}\n" }, { "path": "internal/file/find_test.go", "content": "package file\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestGoMod(t *testing.T) {\n\tpath, content, err := FindInHierarchy(\".\", []string{\"go.mod\"})\n\trequire.NoError(t, err)\n\tassert.NotEmpty(t, path)\n\tassert.NotEmpty(t, content)\n}\n\nfunc TestNotFound(t *testing.T) {\n\t_, _, err := FindInHierarchy(\".\", []string{\"no.such.file\"})\n\trequire.Error(t, err)\n}\n" }, { "path": "internal/fixtures/12345678/http/http.go", "content": "package http\n\ntype MyStruct struct{}\n" }, { "path": "internal/fixtures/any_keyword.go", "content": "package test\n\ntype UsesAny interface {\n\tGetReader() any\n}\n" }, { "path": "internal/fixtures/argument_is_func_type.go", "content": "package test\n\ntype Fooer interface {\n\tFoo(f func(x string) string) error\n\tBar(f func([]int))\n\tBaz(path string) func(x string) string\n}\n" }, { "path": "internal/fixtures/argument_is_map_func.go", "content": "package test\n\ntype MapFunc interface {\n\tGet(m map[string]func(string) string) error\n}\n" }, { "path": "internal/fixtures/async.go", "content": "package test\n\ntype AsyncProducer interface {\n\tInput() chan<- bool\n\tOutput() <-chan bool\n\tWhatever() chan bool\n}\n" }, { "path": "internal/fixtures/auto_generated_skip/auto_generated.go", "content": "// Code generated by mockery; DO NOT EDIT.\n// This is not actually auto-generated, we're just testing that mockery\n// skips this file.\n\npackage autogeneratedskip\n\ntype Bar interface {\n\tGet() string\n}\n" }, { "path": "internal/fixtures/auto_generated_skip/foo.go", "content": "package autogeneratedskip\n\ntype Foo interface {\n\tGet() string\n}\n" }, { "path": "internal/fixtures/auto_generated_skip/foo_test.go", "content": "package autogeneratedskip\n\nimport (\n\t\"os\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestFooExists(t *testing.T) {\n\tmockFile := \"./mocks_testify_autogeneratedskip_test.go\"\n\tmockContents, err := os.ReadFile(mockFile)\n\trequire.NoError(t, err)\n\n\tassert.NotContains(t, string(mockContents), \"func NewMockBar\", \"mock for type Bar was generated when it shouldn't have been because it's in an auto-generated file.\")\n\tassert.Contains(t, string(mockContents), \"func NewMockFoo\")\n}\n" }, { "path": "internal/fixtures/auto_generated_skip/mocks_testify_autogeneratedskip_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage autogeneratedskip\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Get() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockFoo_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockFoo_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Get() *MockFoo_Get_Call {\n\treturn &MockFoo_Get_Call{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockFoo_Get_Call) Run(run func()) *MockFoo_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Get_Call) Return(s string) *MockFoo_Get_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Get_Call) RunAndReturn(run func() string) *MockFoo_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/buildtag/comment/custom2_iface.go", "content": "//go:build custom2\n// +build custom2\n\npackage comment\n\ntype IfaceWithCustomBuildTagInComment interface {\n\tSprintf(format string, a ...interface{}) string\n\tCustom2()\n}\n" }, { "path": "internal/fixtures/buildtag/comment/custom_iface.go", "content": "//go:build custom\n// +build custom\n\npackage comment\n\ntype IfaceWithCustomBuildTagInComment interface {\n\tSprintf(format string, a ...interface{}) string\n}\n" }, { "path": "internal/fixtures/buildtag/comment/darwin_iface.go", "content": "//go:build darwin\n// +build darwin\n\npackage comment\n\ntype IfaceWithBuildTagInComment interface {\n\tSprintf(format string, a ...interface{}) string\n}\n" }, { "path": "internal/fixtures/buildtag/comment/freebsd_iface.go", "content": "//go:build freebsd\n// +build freebsd\n\npackage comment\n\ntype IfaceWithBuildTagInComment interface {\n\tSprintf(format string, a ...interface{}) string\n}\n" }, { "path": "internal/fixtures/buildtag/comment/linux_iface.go", "content": "//go:build linux\n// +build linux\n\npackage comment\n\ntype IfaceWithBuildTagInComment interface {\n\tSprintf(format string, a ...interface{}) string\n}\n" }, { "path": "internal/fixtures/buildtag/comment/mocks_testify_comment_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage comment\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockIfaceWithBuildTagInComment creates a new instance of MockIfaceWithBuildTagInComment. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockIfaceWithBuildTagInComment(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockIfaceWithBuildTagInComment {\n\tmock := &MockIfaceWithBuildTagInComment{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockIfaceWithBuildTagInComment is an autogenerated mock type for the IfaceWithBuildTagInComment type\ntype MockIfaceWithBuildTagInComment struct {\n\tmock.Mock\n}\n\ntype MockIfaceWithBuildTagInComment_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockIfaceWithBuildTagInComment) EXPECT() *MockIfaceWithBuildTagInComment_Expecter {\n\treturn &MockIfaceWithBuildTagInComment_Expecter{mock: &_m.Mock}\n}\n\n// Sprintf provides a mock function for the type MockIfaceWithBuildTagInComment\nfunc (_mock *MockIfaceWithBuildTagInComment) Sprintf(format string, a ...interface{}) string {\n\tvar tmpRet mock.Arguments\n\tif len(a) > 0 {\n\t\ttmpRet = _mock.Called(format, a)\n\t} else {\n\t\ttmpRet = _mock.Called(format)\n\t}\n\tret := tmpRet\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Sprintf\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func(string, ...interface{}) string); ok {\n\t\tr0 = returnFunc(format, a...)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockIfaceWithBuildTagInComment_Sprintf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sprintf'\ntype MockIfaceWithBuildTagInComment_Sprintf_Call struct {\n\t*mock.Call\n}\n\n// Sprintf is a helper method to define mock.On call\n// - format string\n// - a ...interface{}\nfunc (_e *MockIfaceWithBuildTagInComment_Expecter) Sprintf(format interface{}, a ...interface{}) *MockIfaceWithBuildTagInComment_Sprintf_Call {\n\treturn &MockIfaceWithBuildTagInComment_Sprintf_Call{Call: _e.mock.On(\"Sprintf\",\n\t\tappend([]interface{}{format}, a...)...)}\n}\n\nfunc (_c *MockIfaceWithBuildTagInComment_Sprintf_Call) Run(run func(format string, a ...interface{})) *MockIfaceWithBuildTagInComment_Sprintf_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 []interface{}\n\t\tvar variadicArgs []interface{}\n\t\tif len(args) > 1 {\n\t\t\tvariadicArgs = args[1].([]interface{})\n\t\t}\n\t\targ1 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockIfaceWithBuildTagInComment_Sprintf_Call) Return(s string) *MockIfaceWithBuildTagInComment_Sprintf_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockIfaceWithBuildTagInComment_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{}) string) *MockIfaceWithBuildTagInComment_Sprintf_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/buildtag/comment/windows_iface.go", "content": "//go:build windows\n// +build windows\n\npackage comment\n\ntype IfaceWithBuildTagInComment interface {\n\tSprintf(format string, a ...interface{}) string\n}\n" }, { "path": "internal/fixtures/buildtag/filename/iface_darwin.go", "content": "package filename\n\ntype IfaceWithBuildTagInFilename interface {\n\tSprintf(format string, a ...interface{}) string\n}\n" }, { "path": "internal/fixtures/buildtag/filename/iface_freebsd.go", "content": "package filename\n\ntype IfaceWithBuildTagInFilename interface {\n\tSprintf(format string, a ...interface{}) string\n}\n" }, { "path": "internal/fixtures/buildtag/filename/iface_linux.go", "content": "package filename\n\ntype IfaceWithBuildTagInFilename interface {\n\tSprintf(format string, a ...interface{}) string\n}\n" }, { "path": "internal/fixtures/buildtag/filename/iface_windows.go", "content": "package filename\n\ntype IfaceWithBuildTagInFilename interface {\n\tSprintf(format string, a ...interface{}) string\n}\n" }, { "path": "internal/fixtures/constraint_ifaces/constraint_interfaces.go", "content": "package skipconstraintifaces\n\nimport \"golang.org/x/exp/constraints\"\n\ntype Skip1 constraints.Ordered\n\ntype Skip2 interface {\n\t~int\n}\n\ntype Skip3 interface {\n\tconstraints.Float\n}\n\ntype Skip4 interface {\n\tconstraints.Float | constraints.Integer\n}\n\ntype Skip5 Skip1\n\ntype Skip6 interface {\n\tSkip5\n}\n" }, { "path": "internal/fixtures/constraint_ifaces/constraint_interfaces_test.go", "content": "package skipconstraintifaces\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/require\"\n\t\"github.com/vektra/mockery/v3/internal/file\"\n)\n\nfunc TestSkipConstraintInterfaces(t *testing.T) {\n\texists, err := file.Exists(\"./mocks_testify_skipconstraintifaces_test\")\n\n\trequire.NoError(t, err)\n\trequire.False(t, exists)\n}\n" }, { "path": "internal/fixtures/constraints/constraints.go", "content": "package constraints\n\ntype Signed interface {\n\t~int\n}\n\ntype Integer interface {\n\t~int\n}\n\ntype String interface {\n\t~string\n}\n" }, { "path": "internal/fixtures/consul.go", "content": "package test\n\ntype ConsulLock interface {\n\tLock(<-chan struct{}) (<-chan struct{}, error)\n\tUnlock() error\n}\n" }, { "path": "internal/fixtures/custom_error.go", "content": "package test\n\ntype Err struct {\n\tmsg string\n\tcode uint64\n}\n\nfunc (e *Err) Error() string {\n\treturn e.msg\n}\n\nfunc (e *Err) Code() uint64 {\n\treturn e.code\n}\n\ntype KeyManager interface {\n\tGetKey(string, uint16) ([]byte, *Err)\n}\n" }, { "path": "internal/fixtures/directive_comments/directive_comments.go", "content": "package directive_comments\n\nimport \"net/http\"\n\n// Requester is an interface that defines a method for making HTTP requests.\n//\n//mockery:generate: true\ntype Requester interface {\n\tGet(path string) (string, error)\n}\n\ntype RequesterWithoutAnnotation interface {\n\tGet(path string) (string, error)\n}\n\n// MatryerRequester is an interface that should be mocked with matryer's template\n//\n//mockery:generate: true\n//mockery:template: matryer\ntype MatryerRequester interface {\n\tGet(path string) (string, error)\n}\n\n// Server is an interface that defines a method for handling HTTP requests.\n//\n//mockery:generate: true\n//mockery:structname: FunServer\ntype Server interface {\n\tHandleRequest(path string, handler http.Handler)\n}\n\n// ServerWithDifferentFile is an interface that defines a method for handling HTTP requests.\n//\n//mockery:generate: true\n//mockery:filename: server_with_different_file.go\ntype ServerWithDifferentFile interface {\n\tHandleRequest(path string, handler http.Handler)\n}\n\n//mockery:generate: false\ntype InterfaceWithGenerateFalse interface {\n\tDoSomething()\n}\n\n// Interfaces without `generate: true` directive should still be generated\n// if the interface would have otherwise been included and there are other\n// mockery configs present in the doc comment.\n//\n//mockery:structname: InterfaceWithoutGenerateFoo\ntype InterfaceWithoutGenerate interface {\n\tFoo()\n}\n" }, { "path": "internal/fixtures/directive_comments/directive_comments_test.go", "content": "package directive_comments\n\nimport (\n\t\"os\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestInterfaceAnnotations(t *testing.T) {\n\tmatryerMockBytes, err := os.ReadFile(\"mocks_matryer_directive_comments_test.go\")\n\trequire.NoError(t, err)\n\ttestifyMockBytes, err := os.ReadFile(\"mocks_testify_directive_comments_test.go\")\n\trequire.NoError(t, err)\n\tcustomFileBytes, err := os.ReadFile(\"server_with_different_file.go\")\n\trequire.NoError(t, err)\n\n\tmatryerMock := string(matryerMockBytes)\n\ttestifyMock := string(testifyMockBytes)\n\tcustomFile := string(customFileBytes)\n\n\tassert.NotContains(t, matryerMock, \"type MockRequester struct\")\n\tassert.Contains(t, testifyMock, \"type MockRequester struct\")\n\tassert.NotContains(t, customFile, \"type MockRequester struct\")\n\n\tassert.NotContains(t, matryerMock, \"type RequesterWithoutAnnotation struct\")\n\tassert.NotContains(t, testifyMock, \"type RequesterWithoutAnnotation struct\")\n\tassert.NotContains(t, customFile, \"type RequesterWithoutAnnotation struct\")\n\n\tassert.Contains(t, matryerMock, \"type TheMatryerRequester struct\")\n\tassert.NotContains(t, testifyMock, \"type TheMatryerRequester struct\")\n\tassert.NotContains(t, customFile, \"type TheMatryerRequester struct\")\n\n\tassert.NotContains(t, matryerMock, \"type FunServer struct\")\n\tassert.Contains(t, testifyMock, \"type FunServer struct\")\n\tassert.NotContains(t, customFile, \"type FunServer struct\")\n\n\tassert.NotContains(t, matryerMock, \"type FunServerWithDifferentFile struct\")\n\tassert.NotContains(t, testifyMock, \"type FunServerWithDifferentFile struct\")\n\tassert.Contains(t, customFile, \"type FunServerWithDifferentFile struct\")\n\tassert.NotContains(t, matryerMock, \"type AnotherFunServerWithDifferentFile struct\")\n\tassert.NotContains(t, testifyMock, \"type AnotherFunServerWithDifferentFile struct\")\n\tassert.Contains(t, customFile, \"type AnotherFunServerWithDifferentFile struct\")\n\n\tassert.NotContains(t, testifyMock, \"MockInterfaceWithGenerateFalse\")\n\tassert.Contains(t, testifyMock, \"InterfaceWithoutGenerateFoo\")\n}\n" }, { "path": "internal/fixtures/directive_comments/mocks_matryer_directive_comments_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: matryer\n\npackage directive_comments\n\nimport (\n\t\"sync\"\n)\n\n// Ensure that TheMatryerRequester does implement MatryerRequester.\n// If this is not the case, regenerate this file with mockery.\nvar _ MatryerRequester = &TheMatryerRequester{}\n\n// TheMatryerRequester is a mock implementation of MatryerRequester.\n//\n//\tfunc TestSomethingThatUsesMatryerRequester(t *testing.T) {\n//\n//\t\t// make and configure a mocked MatryerRequester\n//\t\tmockedMatryerRequester := &TheMatryerRequester{\n//\t\t\tGetFunc: func(path string) (string, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedMatryerRequester in code that requires MatryerRequester\n//\t\t// and then make assertions.\n//\n//\t}\ntype TheMatryerRequester struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) (string, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *TheMatryerRequester) Get(path string) (string, error) {\n\tif mock.GetFunc == nil {\n\t\tpanic(\"TheMatryerRequester.GetFunc: method is nil but MatryerRequester.Get was just called\")\n\t}\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedMatryerRequester.GetCalls())\nfunc (mock *TheMatryerRequester) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n" }, { "path": "internal/fixtures/directive_comments/mocks_testify_directive_comments_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage directive_comments\n\nimport (\n\t\"net/http\"\n\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockRequester creates a new instance of MockRequester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequester(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequester {\n\tmock := &MockRequester{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequester is an autogenerated mock type for the Requester type\ntype MockRequester struct {\n\tmock.Mock\n}\n\ntype MockRequester_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequester) EXPECT() *MockRequester_Expecter {\n\treturn &MockRequester_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequester\nfunc (_mock *MockRequester) Get(path string) (string, error) {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok {\n\t\treturn returnFunc(path)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) string); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(path)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockRequester_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequester_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\nfunc (_e *MockRequester_Expecter) Get(path interface{}) *MockRequester_Get_Call {\n\treturn &MockRequester_Get_Call{Call: _e.mock.On(\"Get\", path)}\n}\n\nfunc (_c *MockRequester_Get_Call) Run(run func(path string)) *MockRequester_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequester_Get_Call) Return(s string, err error) *MockRequester_Get_Call {\n\t_c.Call.Return(s, err)\n\treturn _c\n}\n\nfunc (_c *MockRequester_Get_Call) RunAndReturn(run func(path string) (string, error)) *MockRequester_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewFunServer creates a new instance of FunServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewFunServer(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *FunServer {\n\tmock := &FunServer{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// FunServer is an autogenerated mock type for the Server type\ntype FunServer struct {\n\tmock.Mock\n}\n\ntype FunServer_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *FunServer) EXPECT() *FunServer_Expecter {\n\treturn &FunServer_Expecter{mock: &_m.Mock}\n}\n\n// HandleRequest provides a mock function for the type FunServer\nfunc (_mock *FunServer) HandleRequest(path string, handler http.Handler) {\n\t_mock.Called(path, handler)\n\treturn\n}\n\n// FunServer_HandleRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HandleRequest'\ntype FunServer_HandleRequest_Call struct {\n\t*mock.Call\n}\n\n// HandleRequest is a helper method to define mock.On call\n// - path string\n// - handler http.Handler\nfunc (_e *FunServer_Expecter) HandleRequest(path interface{}, handler interface{}) *FunServer_HandleRequest_Call {\n\treturn &FunServer_HandleRequest_Call{Call: _e.mock.On(\"HandleRequest\", path, handler)}\n}\n\nfunc (_c *FunServer_HandleRequest_Call) Run(run func(path string, handler http.Handler)) *FunServer_HandleRequest_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 http.Handler\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(http.Handler)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *FunServer_HandleRequest_Call) Return() *FunServer_HandleRequest_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *FunServer_HandleRequest_Call) RunAndReturn(run func(path string, handler http.Handler)) *FunServer_HandleRequest_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewInterfaceWithoutGenerateFoo creates a new instance of InterfaceWithoutGenerateFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewInterfaceWithoutGenerateFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *InterfaceWithoutGenerateFoo {\n\tmock := &InterfaceWithoutGenerateFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// InterfaceWithoutGenerateFoo is an autogenerated mock type for the InterfaceWithoutGenerate type\ntype InterfaceWithoutGenerateFoo struct {\n\tmock.Mock\n}\n\ntype InterfaceWithoutGenerateFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *InterfaceWithoutGenerateFoo) EXPECT() *InterfaceWithoutGenerateFoo_Expecter {\n\treturn &InterfaceWithoutGenerateFoo_Expecter{mock: &_m.Mock}\n}\n\n// Foo provides a mock function for the type InterfaceWithoutGenerateFoo\nfunc (_mock *InterfaceWithoutGenerateFoo) Foo() {\n\t_mock.Called()\n\treturn\n}\n\n// InterfaceWithoutGenerateFoo_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype InterfaceWithoutGenerateFoo_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\nfunc (_e *InterfaceWithoutGenerateFoo_Expecter) Foo() *InterfaceWithoutGenerateFoo_Foo_Call {\n\treturn &InterfaceWithoutGenerateFoo_Foo_Call{Call: _e.mock.On(\"Foo\")}\n}\n\nfunc (_c *InterfaceWithoutGenerateFoo_Foo_Call) Run(run func()) *InterfaceWithoutGenerateFoo_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *InterfaceWithoutGenerateFoo_Foo_Call) Return() *InterfaceWithoutGenerateFoo_Foo_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *InterfaceWithoutGenerateFoo_Foo_Call) RunAndReturn(run func()) *InterfaceWithoutGenerateFoo_Foo_Call {\n\t_c.Run(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/directive_comments/server_with_different_file.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage directive_comments\n\nimport (\n\t\"net/http\"\n\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewFunServerWithDifferentFile creates a new instance of FunServerWithDifferentFile. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewFunServerWithDifferentFile(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *FunServerWithDifferentFile {\n\tmock := &FunServerWithDifferentFile{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// FunServerWithDifferentFile is an autogenerated mock type for the ServerWithDifferentFile type\ntype FunServerWithDifferentFile struct {\n\tmock.Mock\n}\n\ntype FunServerWithDifferentFile_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *FunServerWithDifferentFile) EXPECT() *FunServerWithDifferentFile_Expecter {\n\treturn &FunServerWithDifferentFile_Expecter{mock: &_m.Mock}\n}\n\n// HandleRequest provides a mock function for the type FunServerWithDifferentFile\nfunc (_mock *FunServerWithDifferentFile) HandleRequest(path string, handler http.Handler) {\n\t_mock.Called(path, handler)\n\treturn\n}\n\n// FunServerWithDifferentFile_HandleRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HandleRequest'\ntype FunServerWithDifferentFile_HandleRequest_Call struct {\n\t*mock.Call\n}\n\n// HandleRequest is a helper method to define mock.On call\n// - path string\n// - handler http.Handler\nfunc (_e *FunServerWithDifferentFile_Expecter) HandleRequest(path interface{}, handler interface{}) *FunServerWithDifferentFile_HandleRequest_Call {\n\treturn &FunServerWithDifferentFile_HandleRequest_Call{Call: _e.mock.On(\"HandleRequest\", path, handler)}\n}\n\nfunc (_c *FunServerWithDifferentFile_HandleRequest_Call) Run(run func(path string, handler http.Handler)) *FunServerWithDifferentFile_HandleRequest_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 http.Handler\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(http.Handler)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *FunServerWithDifferentFile_HandleRequest_Call) Return() *FunServerWithDifferentFile_HandleRequest_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *FunServerWithDifferentFile_HandleRequest_Call) RunAndReturn(run func(path string, handler http.Handler)) *FunServerWithDifferentFile_HandleRequest_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewAnotherFunServerWithDifferentFile creates a new instance of AnotherFunServerWithDifferentFile. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewAnotherFunServerWithDifferentFile(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *AnotherFunServerWithDifferentFile {\n\tmock := &AnotherFunServerWithDifferentFile{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// AnotherFunServerWithDifferentFile is an autogenerated mock type for the ServerWithDifferentFile type\ntype AnotherFunServerWithDifferentFile struct {\n\tmock.Mock\n}\n\ntype AnotherFunServerWithDifferentFile_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *AnotherFunServerWithDifferentFile) EXPECT() *AnotherFunServerWithDifferentFile_Expecter {\n\treturn &AnotherFunServerWithDifferentFile_Expecter{mock: &_m.Mock}\n}\n\n// HandleRequest provides a mock function for the type AnotherFunServerWithDifferentFile\nfunc (_mock *AnotherFunServerWithDifferentFile) HandleRequest(path string, handler http.Handler) {\n\t_mock.Called(path, handler)\n\treturn\n}\n\n// AnotherFunServerWithDifferentFile_HandleRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HandleRequest'\ntype AnotherFunServerWithDifferentFile_HandleRequest_Call struct {\n\t*mock.Call\n}\n\n// HandleRequest is a helper method to define mock.On call\n// - path string\n// - handler http.Handler\nfunc (_e *AnotherFunServerWithDifferentFile_Expecter) HandleRequest(path interface{}, handler interface{}) *AnotherFunServerWithDifferentFile_HandleRequest_Call {\n\treturn &AnotherFunServerWithDifferentFile_HandleRequest_Call{Call: _e.mock.On(\"HandleRequest\", path, handler)}\n}\n\nfunc (_c *AnotherFunServerWithDifferentFile_HandleRequest_Call) Run(run func(path string, handler http.Handler)) *AnotherFunServerWithDifferentFile_HandleRequest_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 http.Handler\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(http.Handler)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *AnotherFunServerWithDifferentFile_HandleRequest_Call) Return() *AnotherFunServerWithDifferentFile_HandleRequest_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *AnotherFunServerWithDifferentFile_HandleRequest_Call) RunAndReturn(run func(path string, handler http.Handler)) *AnotherFunServerWithDifferentFile_HandleRequest_Call {\n\t_c.Run(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/directive_comments_example/interface.go", "content": "package directivecommentsexample\n\n// Requester is an interface that defines a method for making HTTP requests.\n//\n//mockery:generate: true\ntype Requester interface {\n\tGet(path string) (string, error)\n}\n\ntype Interface1 interface {\n\tGet(path string) (string, error)\n}\n" }, { "path": "internal/fixtures/empty_interface.go", "content": "package test\n\ntype Blank interface {\n\tCreate(x interface{}) error\n}\n" }, { "path": "internal/fixtures/empty_return/interface.go", "content": "package empty_return\n\ntype EmptyReturn interface {\n\tNoArgs()\n\tWithArgs(a int, b string)\n}\n" }, { "path": "internal/fixtures/empty_return/interface_test.go", "content": "package empty_return\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc Test(t *testing.T) {\n\tm := NewMockEmptyReturn(t)\n\tvar target EmptyReturn = m\n\n\tt.Run(\"NoArgs\", func(t *testing.T) {\n\t\trun := false\n\n\t\tm.EXPECT().NoArgs().RunAndReturn(func() {\n\t\t\trun = true\n\t\t})\n\n\t\ttarget.NoArgs()\n\n\t\trequire.True(t, run)\n\t})\n\n\tt.Run(\"WithArgs\", func(t *testing.T) {\n\t\trun := false\n\n\t\tm.EXPECT().WithArgs(42, \"foo\").RunAndReturn(func(arg0 int, arg1 string) {\n\t\t\trun = true\n\t\t\trequire.Equal(t, 42, arg0)\n\t\t\trequire.Equal(t, \"foo\", arg1)\n\t\t})\n\n\t\ttarget.WithArgs(42, \"foo\")\n\n\t\trequire.True(t, run)\n\t})\n}\n\nfunc TestMatryerNoReturnStub(t *testing.T) {\n\tm := &StubMatyerEmptyReturn{}\n\t// If this is a stub, this should not panic.\n\tm.NoArgs()\n}\n" }, { "path": "internal/fixtures/empty_return/mocks_matryer_empty_return_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: matryer\n\npackage empty_return\n\nimport (\n\t\"sync\"\n)\n\n// Ensure that StubMatyerEmptyReturn does implement EmptyReturn.\n// If this is not the case, regenerate this file with mockery.\nvar _ EmptyReturn = &StubMatyerEmptyReturn{}\n\n// StubMatyerEmptyReturn is a mock implementation of EmptyReturn.\n//\n//\tfunc TestSomethingThatUsesEmptyReturn(t *testing.T) {\n//\n//\t\t// make and configure a mocked EmptyReturn\n//\t\tmockedEmptyReturn := &StubMatyerEmptyReturn{\n//\t\t\tNoArgsFunc: func() {\n//\t\t\t\tpanic(\"mock out the NoArgs method\")\n//\t\t\t},\n//\t\t\tWithArgsFunc: func(a int, b string) {\n//\t\t\t\tpanic(\"mock out the WithArgs method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedEmptyReturn in code that requires EmptyReturn\n//\t\t// and then make assertions.\n//\n//\t}\ntype StubMatyerEmptyReturn struct {\n\t// NoArgsFunc mocks the NoArgs method.\n\tNoArgsFunc func()\n\n\t// WithArgsFunc mocks the WithArgs method.\n\tWithArgsFunc func(a int, b string)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// NoArgs holds details about calls to the NoArgs method.\n\t\tNoArgs []struct {\n\t\t}\n\t\t// WithArgs holds details about calls to the WithArgs method.\n\t\tWithArgs []struct {\n\t\t\t// A is the a argument value.\n\t\t\tA int\n\t\t\t// B is the b argument value.\n\t\t\tB string\n\t\t}\n\t}\n\tlockNoArgs sync.RWMutex\n\tlockWithArgs sync.RWMutex\n}\n\n// NoArgs calls NoArgsFunc.\nfunc (mock *StubMatyerEmptyReturn) NoArgs() {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockNoArgs.Lock()\n\tmock.calls.NoArgs = append(mock.calls.NoArgs, callInfo)\n\tmock.lockNoArgs.Unlock()\n\tif mock.NoArgsFunc == nil {\n\t\treturn\n\t}\n\tmock.NoArgsFunc()\n}\n\n// NoArgsCalls gets all the calls that were made to NoArgs.\n// Check the length with:\n//\n//\tlen(mockedEmptyReturn.NoArgsCalls())\nfunc (mock *StubMatyerEmptyReturn) NoArgsCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockNoArgs.RLock()\n\tcalls = mock.calls.NoArgs\n\tmock.lockNoArgs.RUnlock()\n\treturn calls\n}\n\n// ResetNoArgsCalls reset all the calls that were made to NoArgs.\nfunc (mock *StubMatyerEmptyReturn) ResetNoArgsCalls() {\n\tmock.lockNoArgs.Lock()\n\tmock.calls.NoArgs = nil\n\tmock.lockNoArgs.Unlock()\n}\n\n// WithArgs calls WithArgsFunc.\nfunc (mock *StubMatyerEmptyReturn) WithArgs(a int, b string) {\n\tcallInfo := struct {\n\t\tA int\n\t\tB string\n\t}{\n\t\tA: a,\n\t\tB: b,\n\t}\n\tmock.lockWithArgs.Lock()\n\tmock.calls.WithArgs = append(mock.calls.WithArgs, callInfo)\n\tmock.lockWithArgs.Unlock()\n\tif mock.WithArgsFunc == nil {\n\t\treturn\n\t}\n\tmock.WithArgsFunc(a, b)\n}\n\n// WithArgsCalls gets all the calls that were made to WithArgs.\n// Check the length with:\n//\n//\tlen(mockedEmptyReturn.WithArgsCalls())\nfunc (mock *StubMatyerEmptyReturn) WithArgsCalls() []struct {\n\tA int\n\tB string\n} {\n\tvar calls []struct {\n\t\tA int\n\t\tB string\n\t}\n\tmock.lockWithArgs.RLock()\n\tcalls = mock.calls.WithArgs\n\tmock.lockWithArgs.RUnlock()\n\treturn calls\n}\n\n// ResetWithArgsCalls reset all the calls that were made to WithArgs.\nfunc (mock *StubMatyerEmptyReturn) ResetWithArgsCalls() {\n\tmock.lockWithArgs.Lock()\n\tmock.calls.WithArgs = nil\n\tmock.lockWithArgs.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *StubMatyerEmptyReturn) ResetCalls() {\n\tmock.lockNoArgs.Lock()\n\tmock.calls.NoArgs = nil\n\tmock.lockNoArgs.Unlock()\n\n\tmock.lockWithArgs.Lock()\n\tmock.calls.WithArgs = nil\n\tmock.lockWithArgs.Unlock()\n}\n" }, { "path": "internal/fixtures/empty_return/mocks_testify_empty_return_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage empty_return\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockEmptyReturn creates a new instance of MockEmptyReturn. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockEmptyReturn(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockEmptyReturn {\n\tmock := &MockEmptyReturn{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockEmptyReturn is an autogenerated mock type for the EmptyReturn type\ntype MockEmptyReturn struct {\n\tmock.Mock\n}\n\ntype MockEmptyReturn_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockEmptyReturn) EXPECT() *MockEmptyReturn_Expecter {\n\treturn &MockEmptyReturn_Expecter{mock: &_m.Mock}\n}\n\n// NoArgs provides a mock function for the type MockEmptyReturn\nfunc (_mock *MockEmptyReturn) NoArgs() {\n\t_mock.Called()\n\treturn\n}\n\n// MockEmptyReturn_NoArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoArgs'\ntype MockEmptyReturn_NoArgs_Call struct {\n\t*mock.Call\n}\n\n// NoArgs is a helper method to define mock.On call\nfunc (_e *MockEmptyReturn_Expecter) NoArgs() *MockEmptyReturn_NoArgs_Call {\n\treturn &MockEmptyReturn_NoArgs_Call{Call: _e.mock.On(\"NoArgs\")}\n}\n\nfunc (_c *MockEmptyReturn_NoArgs_Call) Run(run func()) *MockEmptyReturn_NoArgs_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockEmptyReturn_NoArgs_Call) Return() *MockEmptyReturn_NoArgs_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockEmptyReturn_NoArgs_Call) RunAndReturn(run func()) *MockEmptyReturn_NoArgs_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// WithArgs provides a mock function for the type MockEmptyReturn\nfunc (_mock *MockEmptyReturn) WithArgs(a int, b string) {\n\t_mock.Called(a, b)\n\treturn\n}\n\n// MockEmptyReturn_WithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithArgs'\ntype MockEmptyReturn_WithArgs_Call struct {\n\t*mock.Call\n}\n\n// WithArgs is a helper method to define mock.On call\n// - a int\n// - b string\nfunc (_e *MockEmptyReturn_Expecter) WithArgs(a interface{}, b interface{}) *MockEmptyReturn_WithArgs_Call {\n\treturn &MockEmptyReturn_WithArgs_Call{Call: _e.mock.On(\"WithArgs\", a, b)}\n}\n\nfunc (_c *MockEmptyReturn_WithArgs_Call) Run(run func(a int, b string)) *MockEmptyReturn_WithArgs_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int)\n\t\t}\n\t\tvar arg1 string\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockEmptyReturn_WithArgs_Call) Return() *MockEmptyReturn_WithArgs_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockEmptyReturn_WithArgs_Call) RunAndReturn(run func(a int, b string)) *MockEmptyReturn_WithArgs_Call {\n\t_c.Run(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/example_project/bar/foo/client.go", "content": "package foo\n\ntype Client interface {\n\tSearch(query string) ([]string, error)\n}\n" }, { "path": "internal/fixtures/example_project/baz/foo.go", "content": "package baz\n\nimport (\n\tifoo \"github.com/vektra/mockery/v3/internal/fixtures/example_project/baz/internal/foo\"\n)\n\ntype Baz = ifoo.InternalBaz\n\ntype Foo interface {\n\tDoFoo() string\n\tGetBaz() (*Baz, error)\n}\n" }, { "path": "internal/fixtures/example_project/baz/internal/foo/foo.go", "content": "package foo\n\ntype InternalBaz struct {\n\tOne string\n\tTwo int\n}\n" }, { "path": "internal/fixtures/example_project/context/context.go", "content": "package context\n\nimport (\n\t\"context\"\n)\n\ntype CollideWithStdLib interface {\n\tNewClient(ctx context.Context)\n}\n" }, { "path": "internal/fixtures/example_project/foo/foo.go", "content": "package foo\n\ntype Baz struct {\n\tOne string\n\tTwo int\n}\n\ntype Foo interface {\n\tDoFoo() string\n\tGetBaz() (*Baz, error)\n}\n" }, { "path": "internal/fixtures/example_project/foo/pkg_name_same_as_import.go", "content": "package foo\n\nimport \"github.com/vektra/mockery/v3/internal/fixtures/example_project/bar/foo\"\n\ntype PackageNameSameAsImport interface {\n\tNewClient() foo.Client\n}\n" }, { "path": "internal/fixtures/example_project/mocks_testify_example_project_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage example_project\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/example_project/foo\"\n)\n\n// NewMockRoot creates a new instance of MockRoot. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRoot(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRoot {\n\tmock := &MockRoot{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRoot is an autogenerated mock type for the Root type\ntype MockRoot struct {\n\tmock.Mock\n}\n\ntype MockRoot_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRoot) EXPECT() *MockRoot_Expecter {\n\treturn &MockRoot_Expecter{mock: &_m.Mock}\n}\n\n// ReturnsFoo provides a mock function for the type MockRoot\nfunc (_mock *MockRoot) ReturnsFoo() (foo.Foo, error) {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for ReturnsFoo\")\n\t}\n\n\tvar r0 foo.Foo\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func() (foo.Foo, error)); ok {\n\t\treturn returnFunc()\n\t}\n\tif returnFunc, ok := ret.Get(0).(func() foo.Foo); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(foo.Foo)\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func() error); ok {\n\t\tr1 = returnFunc()\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockRoot_ReturnsFoo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnsFoo'\ntype MockRoot_ReturnsFoo_Call struct {\n\t*mock.Call\n}\n\n// ReturnsFoo is a helper method to define mock.On call\nfunc (_e *MockRoot_Expecter) ReturnsFoo() *MockRoot_ReturnsFoo_Call {\n\treturn &MockRoot_ReturnsFoo_Call{Call: _e.mock.On(\"ReturnsFoo\")}\n}\n\nfunc (_c *MockRoot_ReturnsFoo_Call) Run(run func()) *MockRoot_ReturnsFoo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRoot_ReturnsFoo_Call) Return(foo1 foo.Foo, err error) *MockRoot_ReturnsFoo_Call {\n\t_c.Call.Return(foo1, err)\n\treturn _c\n}\n\nfunc (_c *MockRoot_ReturnsFoo_Call) RunAndReturn(run func() (foo.Foo, error)) *MockRoot_ReturnsFoo_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// TakesBaz provides a mock function for the type MockRoot\nfunc (_mock *MockRoot) TakesBaz(baz *foo.Baz) {\n\t_mock.Called(baz)\n\treturn\n}\n\n// MockRoot_TakesBaz_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TakesBaz'\ntype MockRoot_TakesBaz_Call struct {\n\t*mock.Call\n}\n\n// TakesBaz is a helper method to define mock.On call\n// - baz *foo.Baz\nfunc (_e *MockRoot_Expecter) TakesBaz(baz interface{}) *MockRoot_TakesBaz_Call {\n\treturn &MockRoot_TakesBaz_Call{Call: _e.mock.On(\"TakesBaz\", baz)}\n}\n\nfunc (_c *MockRoot_TakesBaz_Call) Run(run func(baz *foo.Baz)) *MockRoot_TakesBaz_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 *foo.Baz\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(*foo.Baz)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRoot_TakesBaz_Call) Return() *MockRoot_TakesBaz_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockRoot_TakesBaz_Call) RunAndReturn(run func(baz *foo.Baz)) *MockRoot_TakesBaz_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockStringer creates a new instance of MockStringer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockStringer(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockStringer {\n\tmock := &MockStringer{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockStringer is an autogenerated mock type for the Stringer type\ntype MockStringer struct {\n\tmock.Mock\n}\n\ntype MockStringer_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockStringer) EXPECT() *MockStringer_Expecter {\n\treturn &MockStringer_Expecter{mock: &_m.Mock}\n}\n\n// String provides a mock function for the type MockStringer\nfunc (_mock *MockStringer) String() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for String\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockStringer_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'\ntype MockStringer_String_Call struct {\n\t*mock.Call\n}\n\n// String is a helper method to define mock.On call\nfunc (_e *MockStringer_Expecter) String() *MockStringer_String_Call {\n\treturn &MockStringer_String_Call{Call: _e.mock.On(\"String\")}\n}\n\nfunc (_c *MockStringer_String_Call) Run(run func()) *MockStringer_String_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockStringer_String_Call) Return(s string) *MockStringer_String_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockStringer_String_Call) RunAndReturn(run func() string) *MockStringer_String_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/example_project/pkg_with_submodules/go.mod", "content": "module github.com/vektra/mockery/v3/pkg/fixtures/example_project/pkg_with_submodules\n\ngo 1.19\n" }, { "path": "internal/fixtures/example_project/pkg_with_submodules/string.go", "content": "package pkg_with_submodules\n\ntype Stringer interface {\n\tString() string\n}\n" }, { "path": "internal/fixtures/example_project/pkg_with_submodules/submodule/go.mod", "content": "module github.com/vektra/mockery/v3/pkg/fixtures/example_project/submodule\n\ngo 1.21.0\n" }, { "path": "internal/fixtures/example_project/pkg_with_submodules/submodule/string.go", "content": "package submodule\n\ntype Stringer interface {\n\tString() string\n}\n" }, { "path": "internal/fixtures/example_project/pkg_with_submodules/subpkg/string.go", "content": "package subpkg\n\ntype Stringer interface {\n\tString() string\n}\n" }, { "path": "internal/fixtures/example_project/pkg_with_submodules/subpkg/submodule/go.mod", "content": "module github.com/vektra/mockery/v3/pkg/fixtures/example_project/pkg_with_submodules/subpkg/submodule\n\ngo 1.19\n" }, { "path": "internal/fixtures/example_project/pkg_with_submodules/subpkg/submodule/string.go", "content": "package submodule\n\ntype Stringer interface {\n\tString() string\n}\n" }, { "path": "internal/fixtures/example_project/pkg_with_subpkgs/foo.go", "content": "package pkg_with_subpkgs\n" }, { "path": "internal/fixtures/example_project/pkg_with_subpkgs/subpkg1/foo.go", "content": "package subpkg1\n" }, { "path": "internal/fixtures/example_project/pkg_with_subpkgs/subpkg2/foo.go", "content": "package subpkg2\n" }, { "path": "internal/fixtures/example_project/pkg_with_subpkgs/subpkg2/subpkg3/foo.go", "content": "package subpkg3\n\ntype Getter interface {\n\tGet(string) string\n}\n" }, { "path": "internal/fixtures/example_project/replace_type/README.md", "content": "## Fix replace-type for different packages from the same source\n\n[Issue 710](https://github.com/vektra/mockery/pull/710)\n\nThis package is used to test the case where multiple types come from the same package (`replace_type/rti/internal`),\nbut results in types in different packages (`replace_type/rt1` and `replace_type/rt2`).\n\nTests `TestReplaceTypePackageMultiplePrologue` and `TestReplaceTypePackageMultiple` use it to check if this outputs\nthe correct import and type names." }, { "path": "internal/fixtures/example_project/replace_type/mocks_testify_replace_type_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage replace_type\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt1\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt2\"\n)\n\n// NewMockRType creates a new instance of MockRType. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRType(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRType {\n\tmock := &MockRType{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRType is an autogenerated mock type for the RType type\ntype MockRType struct {\n\tmock.Mock\n}\n\ntype MockRType_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRType) EXPECT() *MockRType_Expecter {\n\treturn &MockRType_Expecter{mock: &_m.Mock}\n}\n\n// Replace1 provides a mock function for the type MockRType\nfunc (_mock *MockRType) Replace1(f rt1.RType1) {\n\t_mock.Called(f)\n\treturn\n}\n\n// MockRType_Replace1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Replace1'\ntype MockRType_Replace1_Call struct {\n\t*mock.Call\n}\n\n// Replace1 is a helper method to define mock.On call\n// - f rt1.RType1\nfunc (_e *MockRType_Expecter) Replace1(f interface{}) *MockRType_Replace1_Call {\n\treturn &MockRType_Replace1_Call{Call: _e.mock.On(\"Replace1\", f)}\n}\n\nfunc (_c *MockRType_Replace1_Call) Run(run func(f rt1.RType1)) *MockRType_Replace1_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 rt1.RType1\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(rt1.RType1)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRType_Replace1_Call) Return() *MockRType_Replace1_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockRType_Replace1_Call) RunAndReturn(run func(f rt1.RType1)) *MockRType_Replace1_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// Replace2 provides a mock function for the type MockRType\nfunc (_mock *MockRType) Replace2(f rt2.RType2) {\n\t_mock.Called(f)\n\treturn\n}\n\n// MockRType_Replace2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Replace2'\ntype MockRType_Replace2_Call struct {\n\t*mock.Call\n}\n\n// Replace2 is a helper method to define mock.On call\n// - f rt2.RType2\nfunc (_e *MockRType_Expecter) Replace2(f interface{}) *MockRType_Replace2_Call {\n\treturn &MockRType_Replace2_Call{Call: _e.mock.On(\"Replace2\", f)}\n}\n\nfunc (_c *MockRType_Replace2_Call) Run(run func(f rt2.RType2)) *MockRType_Replace2_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 rt2.RType2\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(rt2.RType2)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRType_Replace2_Call) Return() *MockRType_Replace2_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockRType_Replace2_Call) RunAndReturn(run func(f rt2.RType2)) *MockRType_Replace2_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewRTypeReplaced1 creates a new instance of RTypeReplaced1. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewRTypeReplaced1(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *RTypeReplaced1 {\n\tmock := &RTypeReplaced1{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// RTypeReplaced1 is an autogenerated mock type for the RType type\ntype RTypeReplaced1 struct {\n\tmock.Mock\n}\n\ntype RTypeReplaced1_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *RTypeReplaced1) EXPECT() *RTypeReplaced1_Expecter {\n\treturn &RTypeReplaced1_Expecter{mock: &_m.Mock}\n}\n\n// Replace1 provides a mock function for the type RTypeReplaced1\nfunc (_mock *RTypeReplaced1) Replace1(f rt2.RType2) {\n\t_mock.Called(f)\n\treturn\n}\n\n// RTypeReplaced1_Replace1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Replace1'\ntype RTypeReplaced1_Replace1_Call struct {\n\t*mock.Call\n}\n\n// Replace1 is a helper method to define mock.On call\n// - f rt2.RType2\nfunc (_e *RTypeReplaced1_Expecter) Replace1(f interface{}) *RTypeReplaced1_Replace1_Call {\n\treturn &RTypeReplaced1_Replace1_Call{Call: _e.mock.On(\"Replace1\", f)}\n}\n\nfunc (_c *RTypeReplaced1_Replace1_Call) Run(run func(f rt2.RType2)) *RTypeReplaced1_Replace1_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 rt2.RType2\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(rt2.RType2)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *RTypeReplaced1_Replace1_Call) Return() *RTypeReplaced1_Replace1_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *RTypeReplaced1_Replace1_Call) RunAndReturn(run func(f rt2.RType2)) *RTypeReplaced1_Replace1_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// Replace2 provides a mock function for the type RTypeReplaced1\nfunc (_mock *RTypeReplaced1) Replace2(f rt2.RType2) {\n\t_mock.Called(f)\n\treturn\n}\n\n// RTypeReplaced1_Replace2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Replace2'\ntype RTypeReplaced1_Replace2_Call struct {\n\t*mock.Call\n}\n\n// Replace2 is a helper method to define mock.On call\n// - f rt2.RType2\nfunc (_e *RTypeReplaced1_Expecter) Replace2(f interface{}) *RTypeReplaced1_Replace2_Call {\n\treturn &RTypeReplaced1_Replace2_Call{Call: _e.mock.On(\"Replace2\", f)}\n}\n\nfunc (_c *RTypeReplaced1_Replace2_Call) Run(run func(f rt2.RType2)) *RTypeReplaced1_Replace2_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 rt2.RType2\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(rt2.RType2)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *RTypeReplaced1_Replace2_Call) Return() *RTypeReplaced1_Replace2_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *RTypeReplaced1_Replace2_Call) RunAndReturn(run func(f rt2.RType2)) *RTypeReplaced1_Replace2_Call {\n\t_c.Run(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/example_project/replace_type/rt.go", "content": "package replace_type\n\nimport (\n\t\"github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt1\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt2\"\n)\n\ntype RType interface {\n\tReplace1(f rt1.RType1)\n\tReplace2(f rt2.RType2)\n}\n" }, { "path": "internal/fixtures/example_project/replace_type/rt_test.go", "content": "package replace_type\n\nimport (\n\t\"os\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestReplaceType(t *testing.T) {\n\tmockFile := \"./mocks_testify_replace_type_test.go\"\n\tb, err := os.ReadFile(mockFile)\n\trequire.NoError(t, err)\n\t// .mockery.yml replaced github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt1\n\t// with github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/rt2\n\tassert.True(t, strings.Contains(string(b), \"*RTypeReplaced1) Replace1(f rt2.RType2) {\"))\n\t// This should contain no replaced type.\n\tassert.True(t, strings.Contains(string(b), \"*MockRType) Replace1(f rt1.RType1) {\"))\n}\n" }, { "path": "internal/fixtures/example_project/replace_type/rti/internal/rti.go", "content": "package internal\n\ntype RTInternal1 struct {\n\tA int\n}\n\ntype RTInternal2 struct {\n\tB string\n}\n" }, { "path": "internal/fixtures/example_project/replace_type/rti/rt1/rt1.go", "content": "package rt1\n\nimport \"github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/internal\"\n\ntype RType1 = internal.RTInternal1\n" }, { "path": "internal/fixtures/example_project/replace_type/rti/rt2/rt2.go", "content": "package rt2\n\nimport \"github.com/vektra/mockery/v3/internal/fixtures/example_project/replace_type/rti/internal\"\n\ntype RType2 = internal.RTInternal2\n" }, { "path": "internal/fixtures/example_project/root.go", "content": "package example_project\n\nimport \"github.com/vektra/mockery/v3/internal/fixtures/example_project/foo\"\n\ntype Root interface {\n\tTakesBaz(*foo.Baz)\n\tReturnsFoo() (foo.Foo, error)\n}\n" }, { "path": "internal/fixtures/example_project/string.go", "content": "package example_project\n\ntype Stringer interface {\n\tString() string\n}\n" }, { "path": "internal/fixtures/example_project/string_test.go", "content": "package example_project\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc Foo(s Stringer) string {\n\treturn s.String()\n}\n\nfunc TestString(t *testing.T) {\n\tmockStringer := NewMockStringer(t)\n\tmockStringer.EXPECT().String().Return(\"mockery\")\n\tassert.Equal(t, \"mockery\", Foo(mockStringer))\n}\n" }, { "path": "internal/fixtures/expecter.go", "content": "package test\n\ntype Expecter interface {\n\tNoArg() string\n\tNoReturn(str string)\n\tManyArgsReturns(str string, i int) (strs []string, err error)\n\tVariadic(ints ...int) error\n\tVariadicMany(i int, a string, intfs ...interface{}) error\n}\n\ntype VariadicNoReturnInterface interface {\n\tVariadicNoReturn(j int, is ...interface{})\n}\n" }, { "path": "internal/fixtures/expecter_test.go", "content": "package test\n\nimport (\n\t\"errors\"\n\t\"reflect\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/mock\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nvar (\n\tdefaultString = \"some input string\"\n\tdefaultInt = 1\n\tdefaultError = errors.New(\"some error\")\n)\n\n// Test that the generated code for ExpecterTest interface is usable\nfunc TestExpecter(t *testing.T) {\n\texpMock := MockExpecter{}\n\n\tt.Run(\"NoArg\", func(t *testing.T) {\n\t\tvar runCalled bool\n\t\texpMock.EXPECT().NoArg().Run(func() {\n\t\t\trunCalled = true\n\t\t}).Return(defaultString).Once()\n\n\t\t// Good call\n\t\tstr := expMock.NoArg()\n\t\trequire.Equal(t, defaultString, str)\n\t\trequire.True(t, runCalled)\n\n\t\t// Call again panic\n\t\tassert.Panics(t, func() {\n\t\t\texpMock.NoArg()\n\t\t})\n\t\texpMock.AssertExpectations(t)\n\t})\n\n\tt.Run(\"NoReturn\", func(t *testing.T) {\n\t\tvar runCalled bool\n\t\texpMock.EXPECT().NoReturn(mock.Anything).Run(func(s string) {\n\t\t\trequire.Equal(t, defaultString, s)\n\t\t\trunCalled = true\n\t\t}).Return().Once()\n\n\t\t// Good call\n\t\texpMock.NoReturn(defaultString)\n\t\trequire.True(t, runCalled)\n\n\t\t// Call again panic\n\t\trequire.Panics(t, func() {\n\t\t\texpMock.NoReturn(defaultString)\n\t\t})\n\t\texpMock.AssertExpectations(t)\n\t})\n\n\tt.Run(\"ManyArgsReturns\", func(t *testing.T) {\n\t\tvar runCalled bool\n\t\texpMock.EXPECT().ManyArgsReturns(mock.Anything, defaultInt).Run(func(s string, i int) {\n\t\t\trequire.Equal(t, defaultString, s)\n\t\t\trequire.Equal(t, defaultInt, i)\n\t\t\trunCalled = true\n\t\t}).Return([]string{defaultString, defaultString}, defaultError).Once()\n\n\t\t// Call with wrong arg\n\t\trequire.Panics(t, func() {\n\t\t\t_, _ = expMock.ManyArgsReturns(defaultString, 0)\n\t\t})\n\n\t\t// Good call\n\t\tstrs, err := expMock.ManyArgsReturns(defaultString, defaultInt)\n\t\trequire.Equal(t, []string{defaultString, defaultString}, strs)\n\t\trequire.Equal(t, defaultError, err)\n\t\trequire.True(t, runCalled)\n\n\t\t// Call again panic\n\t\trequire.Panics(t, func() {\n\t\t\t_, _ = expMock.ManyArgsReturns(defaultString, defaultInt)\n\t\t})\n\t\texpMock.AssertExpectations(t)\n\t})\n\n\tt.Run(\"Variadic\", func(t *testing.T) {\n\t\trunCalled := 0\n\n\t\texpMock.EXPECT().Variadic(1).Run(func(ints ...int) {\n\t\t\trequire.Equal(t, []int{1}, ints)\n\t\t\trunCalled++\n\t\t}).Return(defaultError).Once()\n\n\t\texpMock.EXPECT().Variadic(1, 2, 3).Run(func(ints ...int) {\n\t\t\trequire.Equal(t, []int{1, 2, 3}, ints)\n\t\t\trunCalled++\n\t\t}).Return(nil).Once()\n\n\t\texpMock.EXPECT().Variadic(1, mock.Anything, 3, mock.Anything).Run(func(ints ...int) {\n\t\t\trequire.Equal(t, []int{1, 2, 3, 4}, ints)\n\t\t\trunCalled++\n\t\t}).Return(nil).Once()\n\n\t\texpMock.EXPECT().Variadic([]interface{}{2, 3, mock.Anything}...).Run(func(ints ...int) {\n\t\t\trequire.Equal(t, []int{2, 3, 4}, ints)\n\t\t\trunCalled++\n\t\t}).Return(nil).Once()\n\n\t\targs := []int{1, 2, 3, 4, 5}\n\t\texpMock.EXPECT().Variadic(intfSlice(args)...).Run(func(ints ...int) {\n\t\t\trequire.Equal(t, args, ints)\n\t\t\trunCalled++\n\t\t}).Return(nil).Once()\n\n\t\trequire.Error(t, expMock.Variadic(1))\n\t\trequire.NoError(t, expMock.Variadic(1, 2, 3))\n\t\trequire.NoError(t, expMock.Variadic(1, 2, 3, 4))\n\t\trequire.NoError(t, expMock.Variadic(2, 3, 4))\n\t\trequire.NoError(t, expMock.Variadic(args...))\n\t\trequire.Equal(t, 5, runCalled)\n\t\texpMock.AssertExpectations(t)\n\t})\n\n\tt.Run(\"VariadicOtherArgs\", func(t *testing.T) {\n\t\trunCalled := 0\n\n\t\texpMock.EXPECT().VariadicMany(defaultInt, defaultString).Return(defaultError).\n\t\t\tRun(func(i int, a string, intfs ...interface{}) {\n\t\t\t\trequire.Equal(t, defaultInt, i)\n\t\t\t\trequire.Equal(t, defaultString, a)\n\t\t\t\trequire.Empty(t, intfs)\n\t\t\t\trunCalled++\n\t\t\t}).Once()\n\t\trequire.Error(t, expMock.VariadicMany(defaultInt, defaultString))\n\n\t\texpMock.EXPECT().VariadicMany(defaultInt, defaultString, 1).Return(defaultError).\n\t\t\tRun(func(i int, a string, intfs ...interface{}) {\n\t\t\t\trequire.Equal(t, defaultInt, i)\n\t\t\t\trequire.Equal(t, defaultString, a)\n\t\t\t\trequire.Equal(t, []interface{}{1}, intfs)\n\t\t\t\trunCalled++\n\t\t\t}).Once()\n\t\trequire.Error(t, expMock.VariadicMany(defaultInt, defaultString, 1))\n\n\t\texpMock.EXPECT().VariadicMany(mock.Anything, mock.Anything, 1, nil, mock.AnythingOfType(\"string\")).Return(nil).\n\t\t\tRun(func(i int, a string, intfs ...interface{}) {\n\t\t\t\trequire.Equal(t, defaultInt, i)\n\t\t\t\trequire.Equal(t, defaultString, a)\n\t\t\t\trequire.Equal(t, []interface{}{1, nil, \"blah\"}, intfs)\n\t\t\t\trunCalled++\n\t\t\t}).Once()\n\t\trequire.Panics(t, func() {\n\t\t\tassert.NoError(t, expMock.VariadicMany(defaultInt, defaultString, 1, nil, 123))\n\t\t})\n\t\trequire.NoError(t, expMock.VariadicMany(defaultInt, defaultString, 1, nil, \"blah\"))\n\n\t\texpMock.EXPECT().VariadicMany(mock.Anything, mock.Anything, 1, nil, \"blah\").Run(func(i int, a string, intfs ...interface{}) {\n\t\t\trequire.Equal(t, defaultInt, i)\n\t\t\trequire.Equal(t, defaultString, a)\n\t\t\trequire.Equal(t, []interface{}{1, nil, \"blah\"}, intfs)\n\t\t\trunCalled++\n\t\t}).Return(defaultError).Once()\n\t\trequire.Panics(t, func() {\n\t\t\tassert.NoError(t, expMock.VariadicMany(defaultInt, defaultString, 1, nil, \"other string\"))\n\t\t})\n\t\terr := expMock.VariadicMany(defaultInt, defaultString, 1, nil, \"blah\")\n\t\trequire.Equal(t, defaultError, err)\n\n\t\targs := []interface{}{1, 2, 3, 4, 5}\n\t\texpMock.EXPECT().VariadicMany(defaultInt, defaultString, args...).Run(func(i int, a string, intfs ...interface{}) {\n\t\t\trequire.Equal(t, defaultInt, i)\n\t\t\trequire.Equal(t, defaultString, a)\n\t\t\trequire.Equal(t, []interface{}{1, 2, 3, 4, 5}, intfs)\n\t\t\trunCalled++\n\t\t}).Return(nil).Once()\n\t\trequire.NoError(t, expMock.VariadicMany(defaultInt, defaultString, args...))\n\n\t\trequire.Equal(t, 5, runCalled)\n\t\texpMock.AssertExpectations(t)\n\t})\n}\n\nfunc intfSlice(slice interface{}) []interface{} {\n\tval := reflect.ValueOf(slice)\n\tswitch val.Kind() {\n\tcase reflect.Slice, reflect.Array, reflect.String:\n\t\tout := make([]interface{}, val.Len())\n\t\tfor i := 0; i < val.Len(); i++ {\n\t\t\tout[i] = val.Index(i).Interface()\n\t\t}\n\t\treturn out\n\tdefault:\n\t\tpanic(\"inftSlice only accepts slices or arrays\")\n\t}\n}\n" }, { "path": "internal/fixtures/func_args_collision.go", "content": "package test\n\ntype FuncArgsCollision interface {\n\tFoo(ret interface{}) error\n}\n" }, { "path": "internal/fixtures/function.go", "content": "package test\n\nimport (\n\t\"context\"\n)\n\ntype SendFunc func(ctx context.Context, data string) (int, error)\n" }, { "path": "internal/fixtures/generic.go", "content": "package test\n\nimport (\n\t\"io\"\n\n\t\"github.com/vektra/mockery/v3/internal/fixtures/constraints\"\n)\n\ntype RequesterGenerics[\n\tTAny any,\n\tTComparable comparable,\n\tTSigned constraints.Signed, // external constraint\n\tTIntf GetInt, // internal interface\n\tTExternalIntf io.Writer, // external interface\n\tTGenIntf GetGeneric[TSigned], // generic interface\n\tTInlineType interface{ ~int | ~uint }, // inlined interface constraints\n\tTInlineTypeGeneric interface {\n\t\t~int | GenericType[int, GetInt]\n\t\tcomparable\n\t}, // inlined type constraints\n] interface {\n\tGenericArguments(TAny, TComparable) (TSigned, TIntf)\n\tGenericStructs(GenericType[TAny, TIntf]) GenericType[TSigned, TIntf]\n\tGenericAnonymousStructs(struct{ Type1 TExternalIntf }) struct {\n\t\tType2 GenericType[string, EmbeddedGet[int]]\n\t}\n}\n\ntype GenericType[T any, S GetInt] struct {\n\tAny T\n\tSome []S\n}\n\ntype GetInt interface{ Get() int }\n\ntype GetGeneric[T constraints.Integer] interface{ Get() T }\n\ntype EmbeddedGet[T constraints.Signed] interface{ GetGeneric[T] }\n\ntype ReplaceGeneric[\n\tTImport any,\n\tTConstraint constraints.Signed,\n\tTKeep any,\n] interface {\n\tA(t1 TImport) TKeep\n\tB() TImport\n\tC() TConstraint\n}\n\ntype ReplaceGenericSelf[T any] interface {\n\tA() T\n}\n" }, { "path": "internal/fixtures/http/http.go", "content": "package http\n\ntype MyStruct struct{}\n" }, { "path": "internal/fixtures/iface_new_type/iface_new_type_test.go", "content": "package iface_new_type\n\nimport (\n\t\"testing\"\n)\n\nfunc TestUsage(t *testing.T) {\n\tinterface1 := NewMockInterface1(t)\n\tinterface1.EXPECT().Method1().Return()\n\tinterface1.Method1()\n}\n" }, { "path": "internal/fixtures/iface_new_type/interface.go", "content": "package iface_new_type\n\nimport \"github.com/vektra/mockery/v3/internal/fixtures/iface_new_type/subpkg\"\n\ntype Interface1 interface {\n\tMethod1()\n}\n\ntype (\n\tInterface2 Interface1\n\tInterface3 subpkg.SubPkgInterface\n)\n" }, { "path": "internal/fixtures/iface_new_type/mocks_testify_iface_new_type_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage iface_new_type\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockInterface1 creates a new instance of MockInterface1. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockInterface1(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockInterface1 {\n\tmock := &MockInterface1{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockInterface1 is an autogenerated mock type for the Interface1 type\ntype MockInterface1 struct {\n\tmock.Mock\n}\n\ntype MockInterface1_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockInterface1) EXPECT() *MockInterface1_Expecter {\n\treturn &MockInterface1_Expecter{mock: &_m.Mock}\n}\n\n// Method1 provides a mock function for the type MockInterface1\nfunc (_mock *MockInterface1) Method1() {\n\t_mock.Called()\n\treturn\n}\n\n// MockInterface1_Method1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Method1'\ntype MockInterface1_Method1_Call struct {\n\t*mock.Call\n}\n\n// Method1 is a helper method to define mock.On call\nfunc (_e *MockInterface1_Expecter) Method1() *MockInterface1_Method1_Call {\n\treturn &MockInterface1_Method1_Call{Call: _e.mock.On(\"Method1\")}\n}\n\nfunc (_c *MockInterface1_Method1_Call) Run(run func()) *MockInterface1_Method1_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockInterface1_Method1_Call) Return() *MockInterface1_Method1_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockInterface1_Method1_Call) RunAndReturn(run func()) *MockInterface1_Method1_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockInterface2 creates a new instance of MockInterface2. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockInterface2(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockInterface2 {\n\tmock := &MockInterface2{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockInterface2 is an autogenerated mock type for the Interface2 type\ntype MockInterface2 struct {\n\tmock.Mock\n}\n\ntype MockInterface2_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockInterface2) EXPECT() *MockInterface2_Expecter {\n\treturn &MockInterface2_Expecter{mock: &_m.Mock}\n}\n\n// Method1 provides a mock function for the type MockInterface2\nfunc (_mock *MockInterface2) Method1() {\n\t_mock.Called()\n\treturn\n}\n\n// MockInterface2_Method1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Method1'\ntype MockInterface2_Method1_Call struct {\n\t*mock.Call\n}\n\n// Method1 is a helper method to define mock.On call\nfunc (_e *MockInterface2_Expecter) Method1() *MockInterface2_Method1_Call {\n\treturn &MockInterface2_Method1_Call{Call: _e.mock.On(\"Method1\")}\n}\n\nfunc (_c *MockInterface2_Method1_Call) Run(run func()) *MockInterface2_Method1_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockInterface2_Method1_Call) Return() *MockInterface2_Method1_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockInterface2_Method1_Call) RunAndReturn(run func()) *MockInterface2_Method1_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockInterface3 creates a new instance of MockInterface3. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockInterface3(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockInterface3 {\n\tmock := &MockInterface3{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockInterface3 is an autogenerated mock type for the Interface3 type\ntype MockInterface3 struct {\n\tmock.Mock\n}\n\ntype MockInterface3_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockInterface3) EXPECT() *MockInterface3_Expecter {\n\treturn &MockInterface3_Expecter{mock: &_m.Mock}\n}\n\n// Method1 provides a mock function for the type MockInterface3\nfunc (_mock *MockInterface3) Method1() {\n\t_mock.Called()\n\treturn\n}\n\n// MockInterface3_Method1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Method1'\ntype MockInterface3_Method1_Call struct {\n\t*mock.Call\n}\n\n// Method1 is a helper method to define mock.On call\nfunc (_e *MockInterface3_Expecter) Method1() *MockInterface3_Method1_Call {\n\treturn &MockInterface3_Method1_Call{Call: _e.mock.On(\"Method1\")}\n}\n\nfunc (_c *MockInterface3_Method1_Call) Run(run func()) *MockInterface3_Method1_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockInterface3_Method1_Call) Return() *MockInterface3_Method1_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockInterface3_Method1_Call) RunAndReturn(run func()) *MockInterface3_Method1_Call {\n\t_c.Run(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/iface_new_type/subpkg/interface.go", "content": "package subpkg\n\ntype SubPkgInterface interface {\n\tMethod1()\n}\n" }, { "path": "internal/fixtures/iface_typed_param/getter_iface_typed_param.go", "content": "package iface_typed_param\n\nimport \"io\"\n\ntype GetterIfaceTypedParam[T io.Reader] interface {\n\tGet() T\n}\n" }, { "path": "internal/fixtures/iface_typed_param/main_test.go", "content": "package iface_typed_param\n\nimport (\n\t\"bufio\"\n\t\"net/http\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestIfaceWithIfaceTypedParamReturnValues(t *testing.T) {\n\tt.Parallel()\n\n\ttests := []struct {\n\t\tname string\n\t\treturnVal *bufio.Reader\n\t}{\n\t\t{\"nil return val\", nil},\n\t\t{\"returning val\", bufio.NewReader(http.NoBody)},\n\t}\n\tfor _, test := range tests {\n\t\tt.Run(test.name, func(st *testing.T) {\n\t\t\tm := NewMockGetterIfaceTypedParam[*bufio.Reader](st)\n\t\t\tm.EXPECT().Get().Return(test.returnVal)\n\n\t\t\tassert.Equal(st, test.returnVal, m.Get())\n\t\t})\n\t}\n}\n" }, { "path": "internal/fixtures/iface_typed_param/mocks_testify_iface_typed_param_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage iface_typed_param\n\nimport (\n\t\"io\"\n\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockGetterIfaceTypedParam creates a new instance of MockGetterIfaceTypedParam. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockGetterIfaceTypedParam[T io.Reader](t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockGetterIfaceTypedParam[T] {\n\tmock := &MockGetterIfaceTypedParam[T]{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockGetterIfaceTypedParam is an autogenerated mock type for the GetterIfaceTypedParam type\ntype MockGetterIfaceTypedParam[T io.Reader] struct {\n\tmock.Mock\n}\n\ntype MockGetterIfaceTypedParam_Expecter[T io.Reader] struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockGetterIfaceTypedParam[T]) EXPECT() *MockGetterIfaceTypedParam_Expecter[T] {\n\treturn &MockGetterIfaceTypedParam_Expecter[T]{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockGetterIfaceTypedParam\nfunc (_mock *MockGetterIfaceTypedParam[T]) Get() T {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 T\n\tif returnFunc, ok := ret.Get(0).(func() T); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(T)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockGetterIfaceTypedParam_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockGetterIfaceTypedParam_Get_Call[T io.Reader] struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockGetterIfaceTypedParam_Expecter[T]) Get() *MockGetterIfaceTypedParam_Get_Call[T] {\n\treturn &MockGetterIfaceTypedParam_Get_Call[T]{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockGetterIfaceTypedParam_Get_Call[T]) Run(run func()) *MockGetterIfaceTypedParam_Get_Call[T] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockGetterIfaceTypedParam_Get_Call[T]) Return(v T) *MockGetterIfaceTypedParam_Get_Call[T] {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockGetterIfaceTypedParam_Get_Call[T]) RunAndReturn(run func() T) *MockGetterIfaceTypedParam_Get_Call[T] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/iface_typed_param_lowercase/getter_iface_typed_param.go", "content": "package iface_typed_param_lowercase\n\ntype GetterIfaceTypedParam[a comparable] interface {\n\tGet(a) a\n}\n" }, { "path": "internal/fixtures/iface_typed_param_lowercase/main_test.go", "content": "package iface_typed_param_lowercase\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestIfaceWithIfaceTypedParamLowerCaseReturnValues(t *testing.T) {\n\tt.Parallel()\n\n\ttests := []struct {\n\t\tname string\n\t\targ *int\n\t\treturnVal *int\n\t}{\n\t\t{\"nil return val\", nil, nil},\n\t\t{\"returning val\", toPtr(2), toPtr(2)},\n\t}\n\tfor _, test := range tests {\n\t\tt.Run(test.name, func(st *testing.T) {\n\t\t\tm := NewMockGetterIfaceTypedParam[*int](st)\n\t\t\tm.EXPECT().Get(test.arg).Return(test.returnVal)\n\n\t\t\tassert.Equal(st, test.returnVal, m.Get(test.arg))\n\t\t})\n\t}\n}\n\nfunc toPtr(i int) *int {\n\treturn &i\n}\n" }, { "path": "internal/fixtures/iface_typed_param_lowercase/mocks_testify_iface_typed_param_lowercase_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage iface_typed_param_lowercase\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockGetterIfaceTypedParam creates a new instance of MockGetterIfaceTypedParam. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockGetterIfaceTypedParam[a comparable](t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockGetterIfaceTypedParam[a] {\n\tmock := &MockGetterIfaceTypedParam[a]{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockGetterIfaceTypedParam is an autogenerated mock type for the GetterIfaceTypedParam type\ntype MockGetterIfaceTypedParam[a comparable] struct {\n\tmock.Mock\n}\n\ntype MockGetterIfaceTypedParam_Expecter[a comparable] struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockGetterIfaceTypedParam[a]) EXPECT() *MockGetterIfaceTypedParam_Expecter[a] {\n\treturn &MockGetterIfaceTypedParam_Expecter[a]{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockGetterIfaceTypedParam\nfunc (_mock *MockGetterIfaceTypedParam[a]) Get(v a) a {\n\tret := _mock.Called(v)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 a\n\tif returnFunc, ok := ret.Get(0).(func(a) a); ok {\n\t\tr0 = returnFunc(v)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(a)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockGetterIfaceTypedParam_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockGetterIfaceTypedParam_Get_Call[a comparable] struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - v a\nfunc (_e *MockGetterIfaceTypedParam_Expecter[a]) Get(v interface{}) *MockGetterIfaceTypedParam_Get_Call[a] {\n\treturn &MockGetterIfaceTypedParam_Get_Call[a]{Call: _e.mock.On(\"Get\", v)}\n}\n\nfunc (_c *MockGetterIfaceTypedParam_Get_Call[a]) Run(run func(v a)) *MockGetterIfaceTypedParam_Get_Call[a] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 a\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(a)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockGetterIfaceTypedParam_Get_Call[a]) Return(v1 a) *MockGetterIfaceTypedParam_Get_Call[a] {\n\t_c.Call.Return(v1)\n\treturn _c\n}\n\nfunc (_c *MockGetterIfaceTypedParam_Get_Call[a]) RunAndReturn(run func(v a) a) *MockGetterIfaceTypedParam_Get_Call[a] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/imports_from_nested_interface.go", "content": "package test\n\nimport (\n\t\"github.com/vektra/mockery/v3/internal/fixtures/http\"\n)\n\ntype HasConflictingNestedImports interface {\n\tRequesterNS\n\tZ() http.MyStruct\n}\n" }, { "path": "internal/fixtures/imports_same_as_package.go", "content": "package test\n\nimport (\n\ttest \"github.com/vektra/mockery/v3/internal/fixtures/redefined_type_b\"\n)\n\ntype C int\n\ntype ImportsSameAsPackage interface {\n\tA() test.B\n\tB() KeyManager\n\tC(C)\n}\n" }, { "path": "internal/fixtures/include_auto_generated/interface.go", "content": "// Code generated by random code generator; DO NOT EDIT.\n\npackage includeautogenerated\n\ntype Foo interface {\n\tBar() string\n}\n" }, { "path": "internal/fixtures/include_auto_generated/interface_test.go", "content": "package includeautogenerated\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestIncludeAutoGenerated(t *testing.T) {\n\tm := NewMockFoo(t)\n\tm.EXPECT().Bar().Return(\"foo\")\n\tassert.Equal(t, \"foo\", m.Bar())\n}\n" }, { "path": "internal/fixtures/include_auto_generated/mocks_testify_includeautogenerated_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage includeautogenerated\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Bar() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Bar\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockFoo_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype MockFoo_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Bar() *MockFoo_Bar_Call {\n\treturn &MockFoo_Bar_Call{Call: _e.mock.On(\"Bar\")}\n}\n\nfunc (_c *MockFoo_Bar_Call) Run(run func()) *MockFoo_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) Return(s string) *MockFoo_Bar_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) RunAndReturn(run func() string) *MockFoo_Bar_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/index_list_expr/index_list_expression.go", "content": "package index_list_expr\n\ntype GenericMultipleTypes[T1 any, T2 any, T3 any] interface {\n\tFunc(arg1 *T1, arg2 T2) T3\n}\n\ntype IndexListExpr GenericMultipleTypes[int, string, bool]\n" }, { "path": "internal/fixtures/index_list_expr/index_list_expression_test.go", "content": "package index_list_expr\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestUsage(t *testing.T) {\n\tgmt := NewMockGenericMultipleTypes[string, int, bool](t)\n\ttestString := \"foo\"\n\tgmt.EXPECT().Func(&testString, 1).Return(false)\n\trequire.Equal(t, false, gmt.Func(&testString, 1))\n\n\tile := NewMockIndexListExpr(t)\n\ttestInt := 1\n\tile.EXPECT().Func(&testInt, \"foo\").Return(true)\n\trequire.Equal(t, true, ile.Func(&testInt, \"foo\"))\n}\n" }, { "path": "internal/fixtures/index_list_expr/mocks_testify_index_list_expr_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage index_list_expr\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockGenericMultipleTypes creates a new instance of MockGenericMultipleTypes. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockGenericMultipleTypes[T1 any, T2 any, T3 any](t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockGenericMultipleTypes[T1, T2, T3] {\n\tmock := &MockGenericMultipleTypes[T1, T2, T3]{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockGenericMultipleTypes is an autogenerated mock type for the GenericMultipleTypes type\ntype MockGenericMultipleTypes[T1 any, T2 any, T3 any] struct {\n\tmock.Mock\n}\n\ntype MockGenericMultipleTypes_Expecter[T1 any, T2 any, T3 any] struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockGenericMultipleTypes[T1, T2, T3]) EXPECT() *MockGenericMultipleTypes_Expecter[T1, T2, T3] {\n\treturn &MockGenericMultipleTypes_Expecter[T1, T2, T3]{mock: &_m.Mock}\n}\n\n// Func provides a mock function for the type MockGenericMultipleTypes\nfunc (_mock *MockGenericMultipleTypes[T1, T2, T3]) Func(arg1 *T1, arg2 T2) T3 {\n\tret := _mock.Called(arg1, arg2)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Func\")\n\t}\n\n\tvar r0 T3\n\tif returnFunc, ok := ret.Get(0).(func(*T1, T2) T3); ok {\n\t\tr0 = returnFunc(arg1, arg2)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(T3)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockGenericMultipleTypes_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func'\ntype MockGenericMultipleTypes_Func_Call[T1 any, T2 any, T3 any] struct {\n\t*mock.Call\n}\n\n// Func is a helper method to define mock.On call\n// - arg1 *T1\n// - arg2 T2\nfunc (_e *MockGenericMultipleTypes_Expecter[T1, T2, T3]) Func(arg1 interface{}, arg2 interface{}) *MockGenericMultipleTypes_Func_Call[T1, T2, T3] {\n\treturn &MockGenericMultipleTypes_Func_Call[T1, T2, T3]{Call: _e.mock.On(\"Func\", arg1, arg2)}\n}\n\nfunc (_c *MockGenericMultipleTypes_Func_Call[T1, T2, T3]) Run(run func(arg1 *T1, arg2 T2)) *MockGenericMultipleTypes_Func_Call[T1, T2, T3] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 *T1\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(*T1)\n\t\t}\n\t\tvar arg1 T2\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(T2)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockGenericMultipleTypes_Func_Call[T1, T2, T3]) Return(v T3) *MockGenericMultipleTypes_Func_Call[T1, T2, T3] {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockGenericMultipleTypes_Func_Call[T1, T2, T3]) RunAndReturn(run func(arg1 *T1, arg2 T2) T3) *MockGenericMultipleTypes_Func_Call[T1, T2, T3] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockIndexListExpr creates a new instance of MockIndexListExpr. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockIndexListExpr(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockIndexListExpr {\n\tmock := &MockIndexListExpr{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockIndexListExpr is an autogenerated mock type for the IndexListExpr type\ntype MockIndexListExpr struct {\n\tmock.Mock\n}\n\ntype MockIndexListExpr_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockIndexListExpr) EXPECT() *MockIndexListExpr_Expecter {\n\treturn &MockIndexListExpr_Expecter{mock: &_m.Mock}\n}\n\n// Func provides a mock function for the type MockIndexListExpr\nfunc (_mock *MockIndexListExpr) Func(arg1 *int, arg2 string) bool {\n\tret := _mock.Called(arg1, arg2)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Func\")\n\t}\n\n\tvar r0 bool\n\tif returnFunc, ok := ret.Get(0).(func(*int, string) bool); ok {\n\t\tr0 = returnFunc(arg1, arg2)\n\t} else {\n\t\tr0 = ret.Get(0).(bool)\n\t}\n\treturn r0\n}\n\n// MockIndexListExpr_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func'\ntype MockIndexListExpr_Func_Call struct {\n\t*mock.Call\n}\n\n// Func is a helper method to define mock.On call\n// - arg1 *int\n// - arg2 string\nfunc (_e *MockIndexListExpr_Expecter) Func(arg1 interface{}, arg2 interface{}) *MockIndexListExpr_Func_Call {\n\treturn &MockIndexListExpr_Func_Call{Call: _e.mock.On(\"Func\", arg1, arg2)}\n}\n\nfunc (_c *MockIndexListExpr_Func_Call) Run(run func(arg1 *int, arg2 string)) *MockIndexListExpr_Func_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 *int\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(*int)\n\t\t}\n\t\tvar arg1 string\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockIndexListExpr_Func_Call) Return(b bool) *MockIndexListExpr_Func_Call {\n\t_c.Call.Return(b)\n\treturn _c\n}\n\nfunc (_c *MockIndexListExpr_Func_Call) RunAndReturn(run func(arg1 *int, arg2 string) bool) *MockIndexListExpr_Func_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/inpackage/interface.go", "content": "package inpackage\n\ntype InternalStringType string\n\ntype Foo interface {\n\tBar() InternalStringType\n}\n" }, { "path": "internal/fixtures/inpackage/interface_test.go", "content": "package inpackage\n\nimport (\n\t\"os\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestInPackageOverride(t *testing.T) {\n\tmockFile := \"./subpkg/mocks_testify_inpackage_test.go\"\n\tcontents, err := os.ReadFile(mockFile)\n\trequire.NoError(t, err)\n\n\t// The `inpackage` parameter overrides the auto-detection logic\n\t// for whether or not a mock is in the original package. Thus, the types\n\t// from the original package should be unqualified. Technically, the\n\t// generated mock file in this case will be invalid code because\n\t// it uses the unqualified InternalStringType from outside of the `inpackage` package.\n\t// We're just testing that the override logic is working correctly.\n\tassert.True(t, strings.Contains(string(contents), \"Bar() InternalStringType\"))\n}\n" }, { "path": "internal/fixtures/inpackage/subpkg/mocks_testify_inpackage_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\n//go:build nobuild\n\npackage inpackage\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Bar() InternalStringType {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Bar\")\n\t}\n\n\tvar r0 InternalStringType\n\tif returnFunc, ok := ret.Get(0).(func() InternalStringType); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(InternalStringType)\n\t}\n\treturn r0\n}\n\n// MockFoo_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype MockFoo_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Bar() *MockFoo_Bar_Call {\n\treturn &MockFoo_Bar_Call{Call: _e.mock.On(\"Bar\")}\n}\n\nfunc (_c *MockFoo_Bar_Call) Run(run func()) *MockFoo_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) Return(internalStringType InternalStringType) *MockFoo_Bar_Call {\n\t_c.Call.Return(internalStringType)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) RunAndReturn(run func() InternalStringType) *MockFoo_Bar_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/instantiated_generic_interface.go", "content": "package test\n\ntype GenericInterface[M any] interface {\n\tFunc(arg *M) int\n}\n\ntype InstantiatedGenericInterface GenericInterface[float32]\n" }, { "path": "internal/fixtures/instantiated_generic_struct.go", "content": "package test\n\n// Tests that mockery does not try to generate mocks for a struct type.\ntype InstantiatedStruct GenericStruct[int]\n\ntype GenericStruct[T any] struct {\n\tAttribute []T\n}\n" }, { "path": "internal/fixtures/interface_dir_relative/interface.go", "content": "package interfacedirrelative\n\ntype Foo interface {\n\tBar() string\n}\n" }, { "path": "internal/fixtures/interface_dir_relative/interface_test.go", "content": "package interfacedirrelative\n\nimport (\n\t\"testing\"\n\n\tmocks \"github.com/vektra/mockery/v3/internal/fixtures/interface_dir_relative/internal/fixtures/interface_dir_relative\"\n)\n\nfunc TestFoo(t *testing.T) {\n\tm := mocks.NewMockFoo(t)\n\tm.EXPECT().Bar().Return(\"foo\")\n\tif m.Bar() != \"foo\" {\n\t\tt.Errorf(\"expected foo but got %s\", m.Bar())\n\t}\n}\n" }, { "path": "internal/fixtures/interface_dir_relative/internal/fixtures/interface_dir_relative/mocks.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage interfacedirrelative\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Bar() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Bar\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockFoo_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype MockFoo_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Bar() *MockFoo_Bar_Call {\n\treturn &MockFoo_Bar_Call{Call: _e.mock.On(\"Bar\")}\n}\n\nfunc (_c *MockFoo_Bar_Call) Run(run func()) *MockFoo_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) Return(s string) *MockFoo_Bar_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) RunAndReturn(run func() string) *MockFoo_Bar_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/interface_dir_relative/mocks/fixtures/interface_dir_relative/mocks.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage interfacedirrelative\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Bar() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Bar\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockFoo_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype MockFoo_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Bar() *MockFoo_Bar_Call {\n\treturn &MockFoo_Bar_Call{Call: _e.mock.On(\"Bar\")}\n}\n\nfunc (_c *MockFoo_Bar_Call) Run(run func()) *MockFoo_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) Return(s string) *MockFoo_Bar_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) RunAndReturn(run func() string) *MockFoo_Bar_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/io_import.go", "content": "package test\n\nimport \"io\"\n\ntype MyReader interface {\n\tio.Reader\n}\n" }, { "path": "internal/fixtures/issue_766.go", "content": "package test\n\ntype Issue766 interface {\n\tFetchData(\n\t\tfetchFunc func(x ...int) ([]int, error),\n\t) ([]int, error)\n}\n" }, { "path": "internal/fixtures/issue_766_test.go", "content": "package test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/mock\"\n)\n\n// Asserts it implements the interface\nvar _ Issue766 = new(MockIssue766)\n\nfunc TestIssue766(t *testing.T) {\n\tfetchFunc := func(i ...int) ([]int, error) {\n\t\tret := make([]int, 0, len(i))\n\t\tfor idx := 0; idx < len(i); idx++ {\n\t\t\tret[idx] = i[idx] + 1\n\t\t}\n\t\treturn ret, nil\n\t}\n\n\texpected := []int{1, 2, 3}\n\tmockFetchData := NewMockIssue766(t)\n\tmockFetchData.\n\t\tEXPECT().\n\t\tFetchData(mock.AnythingOfType(\"func(...int) ([]int, error)\")).\n\t\tReturn([]int{1, 2, 3}, nil)\n\n\tactual, err := mockFetchData.FetchData(fetchFunc)\n\tassert.NoError(t, err)\n\tassert.Equal(t, expected, actual)\n}\n" }, { "path": "internal/fixtures/map_to_interface.go", "content": "package test\n\ntype MapToInterface interface {\n\tFoo(arg1 ...map[string]interface{})\n}\n" }, { "path": "internal/fixtures/method_args/same_name_arg_and_type/entity.go", "content": "package same_name_arg_and_type\n\ntype (\n\tinterfaceA interface {\n\t\t// SomeMethod - contains args with the same names of the type and arg\n\t\tDoB(interfaceB interfaceB) interfaceB\n\t\tDoB0(interfaceB interfaceB0) interfaceB0\n\t\tDoB0v2(interfaceB0 interfaceB0) interfaceB0\n\t}\n\n\tinterfaceB interface {\n\t\tGetData() int\n\t}\n\n\tinterfaceB0 interface {\n\t\tDoB0(interfaceB0 interfaceB0) interfaceB0\n\t}\n)\n" }, { "path": "internal/fixtures/method_args/same_name_arg_and_type/entity_test.go", "content": "package same_name_arg_and_type\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/mock\"\n)\n\ntype testStruct struct {\n\tinterfaceA interfaceA\n}\n\nfunc (s *testStruct) ExecDoB() interfaceB {\n\tvar in interfaceB = nil\n\treturn s.interfaceA.DoB(in)\n}\n\nfunc (s *testStruct) ExecDoB0() interfaceB0 {\n\tvar in interfaceB0 = nil\n\treturn s.interfaceA.DoB0(in)\n}\n\nfunc (s *testStruct) ExecDoB0v2() interfaceB0 {\n\tvar in interfaceB0 = nil\n\treturn s.interfaceA.DoB0v2(in)\n}\n\nfunc Test(t *testing.T) {\n\tt.Run(\"ExecDoB\", func(t *testing.T) {\n\t\tmockInterfaceB := newMockinterfaceB(t)\n\t\tmockInterfaceA := newMockinterfaceA(t)\n\t\tmockInterfaceA.On(\"DoB\", mock.Anything).Return(mockInterfaceB)\n\n\t\ts := testStruct{\n\t\t\tinterfaceA: mockInterfaceA,\n\t\t}\n\t\tres := s.ExecDoB()\n\t\tassert.Equal(t, mockInterfaceB, res)\n\t})\n\tt.Run(\"ExecDoB0\", func(t *testing.T) {\n\t\tmockInterfaceB0 := newMockinterfaceB0(t)\n\t\tmockInterfaceA := newMockinterfaceA(t)\n\t\tmockInterfaceA.On(\"DoB0\", mock.Anything).Return(mockInterfaceB0)\n\n\t\ts := testStruct{\n\t\t\tinterfaceA: mockInterfaceA,\n\t\t}\n\t\tres := s.ExecDoB0()\n\t\tassert.Equal(t, mockInterfaceB0, res)\n\t})\n\tt.Run(\"ExecDoB0v2\", func(t *testing.T) {\n\t\tmockInterfaceB0 := newMockinterfaceB0(t)\n\t\tmockInterfaceA := newMockinterfaceA(t)\n\t\tmockInterfaceA.On(\"DoB0v2\", mock.Anything).Return(mockInterfaceB0)\n\n\t\ts := testStruct{\n\t\t\tinterfaceA: mockInterfaceA,\n\t\t}\n\t\tres := s.ExecDoB0v2()\n\t\tassert.Equal(t, mockInterfaceB0, res)\n\t})\n}\n" }, { "path": "internal/fixtures/method_args/same_name_arg_and_type/mocks_testify_same_name_arg_and_type_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage same_name_arg_and_type\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// newMockinterfaceA creates a new instance of mockinterfaceA. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc newMockinterfaceA(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *mockinterfaceA {\n\tmock := &mockinterfaceA{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// mockinterfaceA is an autogenerated mock type for the interfaceA type\ntype mockinterfaceA struct {\n\tmock.Mock\n}\n\ntype mockinterfaceA_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *mockinterfaceA) EXPECT() *mockinterfaceA_Expecter {\n\treturn &mockinterfaceA_Expecter{mock: &_m.Mock}\n}\n\n// DoB provides a mock function for the type mockinterfaceA\nfunc (_mock *mockinterfaceA) DoB(interfaceB1 interfaceB) interfaceB {\n\tret := _mock.Called(interfaceB1)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for DoB\")\n\t}\n\n\tvar r0 interfaceB\n\tif returnFunc, ok := ret.Get(0).(func(interfaceB) interfaceB); ok {\n\t\tr0 = returnFunc(interfaceB1)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(interfaceB)\n\t\t}\n\t}\n\treturn r0\n}\n\n// mockinterfaceA_DoB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoB'\ntype mockinterfaceA_DoB_Call struct {\n\t*mock.Call\n}\n\n// DoB is a helper method to define mock.On call\n// - interfaceB1 interfaceB\nfunc (_e *mockinterfaceA_Expecter) DoB(interfaceB1 interface{}) *mockinterfaceA_DoB_Call {\n\treturn &mockinterfaceA_DoB_Call{Call: _e.mock.On(\"DoB\", interfaceB1)}\n}\n\nfunc (_c *mockinterfaceA_DoB_Call) Run(run func(interfaceB1 interfaceB)) *mockinterfaceA_DoB_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 interfaceB\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(interfaceB)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *mockinterfaceA_DoB_Call) Return(interfaceBMoqParam interfaceB) *mockinterfaceA_DoB_Call {\n\t_c.Call.Return(interfaceBMoqParam)\n\treturn _c\n}\n\nfunc (_c *mockinterfaceA_DoB_Call) RunAndReturn(run func(interfaceB1 interfaceB) interfaceB) *mockinterfaceA_DoB_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// DoB0 provides a mock function for the type mockinterfaceA\nfunc (_mock *mockinterfaceA) DoB0(interfaceB interfaceB0) interfaceB0 {\n\tret := _mock.Called(interfaceB)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for DoB0\")\n\t}\n\n\tvar r0 interfaceB0\n\tif returnFunc, ok := ret.Get(0).(func(interfaceB0) interfaceB0); ok {\n\t\tr0 = returnFunc(interfaceB)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(interfaceB0)\n\t\t}\n\t}\n\treturn r0\n}\n\n// mockinterfaceA_DoB0_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoB0'\ntype mockinterfaceA_DoB0_Call struct {\n\t*mock.Call\n}\n\n// DoB0 is a helper method to define mock.On call\n// - interfaceB interfaceB0\nfunc (_e *mockinterfaceA_Expecter) DoB0(interfaceB interface{}) *mockinterfaceA_DoB0_Call {\n\treturn &mockinterfaceA_DoB0_Call{Call: _e.mock.On(\"DoB0\", interfaceB)}\n}\n\nfunc (_c *mockinterfaceA_DoB0_Call) Run(run func(interfaceB interfaceB0)) *mockinterfaceA_DoB0_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 interfaceB0\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(interfaceB0)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *mockinterfaceA_DoB0_Call) Return(interfaceB0MoqParam interfaceB0) *mockinterfaceA_DoB0_Call {\n\t_c.Call.Return(interfaceB0MoqParam)\n\treturn _c\n}\n\nfunc (_c *mockinterfaceA_DoB0_Call) RunAndReturn(run func(interfaceB interfaceB0) interfaceB0) *mockinterfaceA_DoB0_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// DoB0v2 provides a mock function for the type mockinterfaceA\nfunc (_mock *mockinterfaceA) DoB0v2(interfaceB01 interfaceB0) interfaceB0 {\n\tret := _mock.Called(interfaceB01)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for DoB0v2\")\n\t}\n\n\tvar r0 interfaceB0\n\tif returnFunc, ok := ret.Get(0).(func(interfaceB0) interfaceB0); ok {\n\t\tr0 = returnFunc(interfaceB01)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(interfaceB0)\n\t\t}\n\t}\n\treturn r0\n}\n\n// mockinterfaceA_DoB0v2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoB0v2'\ntype mockinterfaceA_DoB0v2_Call struct {\n\t*mock.Call\n}\n\n// DoB0v2 is a helper method to define mock.On call\n// - interfaceB01 interfaceB0\nfunc (_e *mockinterfaceA_Expecter) DoB0v2(interfaceB01 interface{}) *mockinterfaceA_DoB0v2_Call {\n\treturn &mockinterfaceA_DoB0v2_Call{Call: _e.mock.On(\"DoB0v2\", interfaceB01)}\n}\n\nfunc (_c *mockinterfaceA_DoB0v2_Call) Run(run func(interfaceB01 interfaceB0)) *mockinterfaceA_DoB0v2_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 interfaceB0\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(interfaceB0)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *mockinterfaceA_DoB0v2_Call) Return(interfaceB0MoqParam interfaceB0) *mockinterfaceA_DoB0v2_Call {\n\t_c.Call.Return(interfaceB0MoqParam)\n\treturn _c\n}\n\nfunc (_c *mockinterfaceA_DoB0v2_Call) RunAndReturn(run func(interfaceB01 interfaceB0) interfaceB0) *mockinterfaceA_DoB0v2_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// newMockinterfaceB creates a new instance of mockinterfaceB. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc newMockinterfaceB(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *mockinterfaceB {\n\tmock := &mockinterfaceB{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// mockinterfaceB is an autogenerated mock type for the interfaceB type\ntype mockinterfaceB struct {\n\tmock.Mock\n}\n\ntype mockinterfaceB_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *mockinterfaceB) EXPECT() *mockinterfaceB_Expecter {\n\treturn &mockinterfaceB_Expecter{mock: &_m.Mock}\n}\n\n// GetData provides a mock function for the type mockinterfaceB\nfunc (_mock *mockinterfaceB) GetData() int {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for GetData\")\n\t}\n\n\tvar r0 int\n\tif returnFunc, ok := ret.Get(0).(func() int); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\treturn r0\n}\n\n// mockinterfaceB_GetData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetData'\ntype mockinterfaceB_GetData_Call struct {\n\t*mock.Call\n}\n\n// GetData is a helper method to define mock.On call\nfunc (_e *mockinterfaceB_Expecter) GetData() *mockinterfaceB_GetData_Call {\n\treturn &mockinterfaceB_GetData_Call{Call: _e.mock.On(\"GetData\")}\n}\n\nfunc (_c *mockinterfaceB_GetData_Call) Run(run func()) *mockinterfaceB_GetData_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *mockinterfaceB_GetData_Call) Return(n int) *mockinterfaceB_GetData_Call {\n\t_c.Call.Return(n)\n\treturn _c\n}\n\nfunc (_c *mockinterfaceB_GetData_Call) RunAndReturn(run func() int) *mockinterfaceB_GetData_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// newMockinterfaceB0 creates a new instance of mockinterfaceB0. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc newMockinterfaceB0(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *mockinterfaceB0 {\n\tmock := &mockinterfaceB0{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// mockinterfaceB0 is an autogenerated mock type for the interfaceB0 type\ntype mockinterfaceB0 struct {\n\tmock.Mock\n}\n\ntype mockinterfaceB0_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *mockinterfaceB0) EXPECT() *mockinterfaceB0_Expecter {\n\treturn &mockinterfaceB0_Expecter{mock: &_m.Mock}\n}\n\n// DoB0 provides a mock function for the type mockinterfaceB0\nfunc (_mock *mockinterfaceB0) DoB0(interfaceB01 interfaceB0) interfaceB0 {\n\tret := _mock.Called(interfaceB01)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for DoB0\")\n\t}\n\n\tvar r0 interfaceB0\n\tif returnFunc, ok := ret.Get(0).(func(interfaceB0) interfaceB0); ok {\n\t\tr0 = returnFunc(interfaceB01)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(interfaceB0)\n\t\t}\n\t}\n\treturn r0\n}\n\n// mockinterfaceB0_DoB0_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoB0'\ntype mockinterfaceB0_DoB0_Call struct {\n\t*mock.Call\n}\n\n// DoB0 is a helper method to define mock.On call\n// - interfaceB01 interfaceB0\nfunc (_e *mockinterfaceB0_Expecter) DoB0(interfaceB01 interface{}) *mockinterfaceB0_DoB0_Call {\n\treturn &mockinterfaceB0_DoB0_Call{Call: _e.mock.On(\"DoB0\", interfaceB01)}\n}\n\nfunc (_c *mockinterfaceB0_DoB0_Call) Run(run func(interfaceB01 interfaceB0)) *mockinterfaceB0_DoB0_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 interfaceB0\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(interfaceB0)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *mockinterfaceB0_DoB0_Call) Return(interfaceB0MoqParam interfaceB0) *mockinterfaceB0_DoB0_Call {\n\t_c.Call.Return(interfaceB0MoqParam)\n\treturn _c\n}\n\nfunc (_c *mockinterfaceB0_DoB0_Call) RunAndReturn(run func(interfaceB01 interfaceB0) interfaceB0) *mockinterfaceB0_DoB0_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/mock_method_uses_pkg_iface.go", "content": "package test\n\ntype Sibling interface {\n\tDoSomething()\n}\n\ntype UsesOtherPkgIface interface {\n\tDoSomethingElse(obj Sibling)\n}\n" }, { "path": "internal/fixtures/mocks_io_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage test\n\nimport (\n\t\"io\"\n\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockReader creates a new instance of MockReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReader(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReader {\n\tmock := &MockReader{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReader is an autogenerated mock type for the Reader type\ntype MockReader struct {\n\tmock.Mock\n}\n\ntype MockReader_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReader) EXPECT() *MockReader_Expecter {\n\treturn &MockReader_Expecter{mock: &_m.Mock}\n}\n\n// Read provides a mock function for the type MockReader\nfunc (_mock *MockReader) Read(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Read\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReader_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'\ntype MockReader_Read_Call struct {\n\t*mock.Call\n}\n\n// Read is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReader_Expecter) Read(p interface{}) *MockReader_Read_Call {\n\treturn &MockReader_Read_Call{Call: _e.mock.On(\"Read\", p)}\n}\n\nfunc (_c *MockReader_Read_Call) Run(run func(p []byte)) *MockReader_Read_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReader_Read_Call) Return(n int, err error) *MockReader_Read_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReader_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReader_Read_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockWriter creates a new instance of MockWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockWriter(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockWriter {\n\tmock := &MockWriter{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockWriter is an autogenerated mock type for the Writer type\ntype MockWriter struct {\n\tmock.Mock\n}\n\ntype MockWriter_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockWriter) EXPECT() *MockWriter_Expecter {\n\treturn &MockWriter_Expecter{mock: &_m.Mock}\n}\n\n// Write provides a mock function for the type MockWriter\nfunc (_mock *MockWriter) Write(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Write\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockWriter_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'\ntype MockWriter_Write_Call struct {\n\t*mock.Call\n}\n\n// Write is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockWriter_Expecter) Write(p interface{}) *MockWriter_Write_Call {\n\treturn &MockWriter_Write_Call{Call: _e.mock.On(\"Write\", p)}\n}\n\nfunc (_c *MockWriter_Write_Call) Run(run func(p []byte)) *MockWriter_Write_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockWriter_Write_Call) Return(n int, err error) *MockWriter_Write_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockWriter_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockWriter_Write_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockCloser creates a new instance of MockCloser. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockCloser(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockCloser {\n\tmock := &MockCloser{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockCloser is an autogenerated mock type for the Closer type\ntype MockCloser struct {\n\tmock.Mock\n}\n\ntype MockCloser_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockCloser) EXPECT() *MockCloser_Expecter {\n\treturn &MockCloser_Expecter{mock: &_m.Mock}\n}\n\n// Close provides a mock function for the type MockCloser\nfunc (_mock *MockCloser) Close() error {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Close\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func() error); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockCloser_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'\ntype MockCloser_Close_Call struct {\n\t*mock.Call\n}\n\n// Close is a helper method to define mock.On call\nfunc (_e *MockCloser_Expecter) Close() *MockCloser_Close_Call {\n\treturn &MockCloser_Close_Call{Call: _e.mock.On(\"Close\")}\n}\n\nfunc (_c *MockCloser_Close_Call) Run(run func()) *MockCloser_Close_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockCloser_Close_Call) Return(err error) *MockCloser_Close_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockCloser_Close_Call) RunAndReturn(run func() error) *MockCloser_Close_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockSeeker creates a new instance of MockSeeker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockSeeker(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockSeeker {\n\tmock := &MockSeeker{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockSeeker is an autogenerated mock type for the Seeker type\ntype MockSeeker struct {\n\tmock.Mock\n}\n\ntype MockSeeker_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockSeeker) EXPECT() *MockSeeker_Expecter {\n\treturn &MockSeeker_Expecter{mock: &_m.Mock}\n}\n\n// Seek provides a mock function for the type MockSeeker\nfunc (_mock *MockSeeker) Seek(offset int64, whence int) (int64, error) {\n\tret := _mock.Called(offset, whence)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Seek\")\n\t}\n\n\tvar r0 int64\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) (int64, error)); ok {\n\t\treturn returnFunc(offset, whence)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) int64); ok {\n\t\tr0 = returnFunc(offset, whence)\n\t} else {\n\t\tr0 = ret.Get(0).(int64)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(int64, int) error); ok {\n\t\tr1 = returnFunc(offset, whence)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockSeeker_Seek_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Seek'\ntype MockSeeker_Seek_Call struct {\n\t*mock.Call\n}\n\n// Seek is a helper method to define mock.On call\n// - offset int64\n// - whence int\nfunc (_e *MockSeeker_Expecter) Seek(offset interface{}, whence interface{}) *MockSeeker_Seek_Call {\n\treturn &MockSeeker_Seek_Call{Call: _e.mock.On(\"Seek\", offset, whence)}\n}\n\nfunc (_c *MockSeeker_Seek_Call) Run(run func(offset int64, whence int)) *MockSeeker_Seek_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int64\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int64)\n\t\t}\n\t\tvar arg1 int\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(int)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockSeeker_Seek_Call) Return(n int64, err error) *MockSeeker_Seek_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockSeeker_Seek_Call) RunAndReturn(run func(offset int64, whence int) (int64, error)) *MockSeeker_Seek_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReadWriter creates a new instance of MockReadWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReadWriter(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReadWriter {\n\tmock := &MockReadWriter{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReadWriter is an autogenerated mock type for the ReadWriter type\ntype MockReadWriter struct {\n\tmock.Mock\n}\n\ntype MockReadWriter_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReadWriter) EXPECT() *MockReadWriter_Expecter {\n\treturn &MockReadWriter_Expecter{mock: &_m.Mock}\n}\n\n// Read provides a mock function for the type MockReadWriter\nfunc (_mock *MockReadWriter) Read(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Read\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadWriter_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'\ntype MockReadWriter_Read_Call struct {\n\t*mock.Call\n}\n\n// Read is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReadWriter_Expecter) Read(p interface{}) *MockReadWriter_Read_Call {\n\treturn &MockReadWriter_Read_Call{Call: _e.mock.On(\"Read\", p)}\n}\n\nfunc (_c *MockReadWriter_Read_Call) Run(run func(p []byte)) *MockReadWriter_Read_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadWriter_Read_Call) Return(n int, err error) *MockReadWriter_Read_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadWriter_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReadWriter_Read_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Write provides a mock function for the type MockReadWriter\nfunc (_mock *MockReadWriter) Write(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Write\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadWriter_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'\ntype MockReadWriter_Write_Call struct {\n\t*mock.Call\n}\n\n// Write is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReadWriter_Expecter) Write(p interface{}) *MockReadWriter_Write_Call {\n\treturn &MockReadWriter_Write_Call{Call: _e.mock.On(\"Write\", p)}\n}\n\nfunc (_c *MockReadWriter_Write_Call) Run(run func(p []byte)) *MockReadWriter_Write_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadWriter_Write_Call) Return(n int, err error) *MockReadWriter_Write_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadWriter_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReadWriter_Write_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReadCloser creates a new instance of MockReadCloser. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReadCloser(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReadCloser {\n\tmock := &MockReadCloser{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReadCloser is an autogenerated mock type for the ReadCloser type\ntype MockReadCloser struct {\n\tmock.Mock\n}\n\ntype MockReadCloser_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReadCloser) EXPECT() *MockReadCloser_Expecter {\n\treturn &MockReadCloser_Expecter{mock: &_m.Mock}\n}\n\n// Close provides a mock function for the type MockReadCloser\nfunc (_mock *MockReadCloser) Close() error {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Close\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func() error); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockReadCloser_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'\ntype MockReadCloser_Close_Call struct {\n\t*mock.Call\n}\n\n// Close is a helper method to define mock.On call\nfunc (_e *MockReadCloser_Expecter) Close() *MockReadCloser_Close_Call {\n\treturn &MockReadCloser_Close_Call{Call: _e.mock.On(\"Close\")}\n}\n\nfunc (_c *MockReadCloser_Close_Call) Run(run func()) *MockReadCloser_Close_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadCloser_Close_Call) Return(err error) *MockReadCloser_Close_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockReadCloser_Close_Call) RunAndReturn(run func() error) *MockReadCloser_Close_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Read provides a mock function for the type MockReadCloser\nfunc (_mock *MockReadCloser) Read(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Read\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadCloser_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'\ntype MockReadCloser_Read_Call struct {\n\t*mock.Call\n}\n\n// Read is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReadCloser_Expecter) Read(p interface{}) *MockReadCloser_Read_Call {\n\treturn &MockReadCloser_Read_Call{Call: _e.mock.On(\"Read\", p)}\n}\n\nfunc (_c *MockReadCloser_Read_Call) Run(run func(p []byte)) *MockReadCloser_Read_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadCloser_Read_Call) Return(n int, err error) *MockReadCloser_Read_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadCloser_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReadCloser_Read_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockWriteCloser creates a new instance of MockWriteCloser. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockWriteCloser(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockWriteCloser {\n\tmock := &MockWriteCloser{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockWriteCloser is an autogenerated mock type for the WriteCloser type\ntype MockWriteCloser struct {\n\tmock.Mock\n}\n\ntype MockWriteCloser_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockWriteCloser) EXPECT() *MockWriteCloser_Expecter {\n\treturn &MockWriteCloser_Expecter{mock: &_m.Mock}\n}\n\n// Close provides a mock function for the type MockWriteCloser\nfunc (_mock *MockWriteCloser) Close() error {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Close\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func() error); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockWriteCloser_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'\ntype MockWriteCloser_Close_Call struct {\n\t*mock.Call\n}\n\n// Close is a helper method to define mock.On call\nfunc (_e *MockWriteCloser_Expecter) Close() *MockWriteCloser_Close_Call {\n\treturn &MockWriteCloser_Close_Call{Call: _e.mock.On(\"Close\")}\n}\n\nfunc (_c *MockWriteCloser_Close_Call) Run(run func()) *MockWriteCloser_Close_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockWriteCloser_Close_Call) Return(err error) *MockWriteCloser_Close_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockWriteCloser_Close_Call) RunAndReturn(run func() error) *MockWriteCloser_Close_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Write provides a mock function for the type MockWriteCloser\nfunc (_mock *MockWriteCloser) Write(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Write\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockWriteCloser_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'\ntype MockWriteCloser_Write_Call struct {\n\t*mock.Call\n}\n\n// Write is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockWriteCloser_Expecter) Write(p interface{}) *MockWriteCloser_Write_Call {\n\treturn &MockWriteCloser_Write_Call{Call: _e.mock.On(\"Write\", p)}\n}\n\nfunc (_c *MockWriteCloser_Write_Call) Run(run func(p []byte)) *MockWriteCloser_Write_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockWriteCloser_Write_Call) Return(n int, err error) *MockWriteCloser_Write_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockWriteCloser_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockWriteCloser_Write_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReadWriteCloser creates a new instance of MockReadWriteCloser. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReadWriteCloser(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReadWriteCloser {\n\tmock := &MockReadWriteCloser{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReadWriteCloser is an autogenerated mock type for the ReadWriteCloser type\ntype MockReadWriteCloser struct {\n\tmock.Mock\n}\n\ntype MockReadWriteCloser_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReadWriteCloser) EXPECT() *MockReadWriteCloser_Expecter {\n\treturn &MockReadWriteCloser_Expecter{mock: &_m.Mock}\n}\n\n// Close provides a mock function for the type MockReadWriteCloser\nfunc (_mock *MockReadWriteCloser) Close() error {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Close\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func() error); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockReadWriteCloser_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'\ntype MockReadWriteCloser_Close_Call struct {\n\t*mock.Call\n}\n\n// Close is a helper method to define mock.On call\nfunc (_e *MockReadWriteCloser_Expecter) Close() *MockReadWriteCloser_Close_Call {\n\treturn &MockReadWriteCloser_Close_Call{Call: _e.mock.On(\"Close\")}\n}\n\nfunc (_c *MockReadWriteCloser_Close_Call) Run(run func()) *MockReadWriteCloser_Close_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadWriteCloser_Close_Call) Return(err error) *MockReadWriteCloser_Close_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockReadWriteCloser_Close_Call) RunAndReturn(run func() error) *MockReadWriteCloser_Close_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Read provides a mock function for the type MockReadWriteCloser\nfunc (_mock *MockReadWriteCloser) Read(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Read\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadWriteCloser_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'\ntype MockReadWriteCloser_Read_Call struct {\n\t*mock.Call\n}\n\n// Read is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReadWriteCloser_Expecter) Read(p interface{}) *MockReadWriteCloser_Read_Call {\n\treturn &MockReadWriteCloser_Read_Call{Call: _e.mock.On(\"Read\", p)}\n}\n\nfunc (_c *MockReadWriteCloser_Read_Call) Run(run func(p []byte)) *MockReadWriteCloser_Read_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadWriteCloser_Read_Call) Return(n int, err error) *MockReadWriteCloser_Read_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadWriteCloser_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReadWriteCloser_Read_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Write provides a mock function for the type MockReadWriteCloser\nfunc (_mock *MockReadWriteCloser) Write(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Write\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadWriteCloser_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'\ntype MockReadWriteCloser_Write_Call struct {\n\t*mock.Call\n}\n\n// Write is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReadWriteCloser_Expecter) Write(p interface{}) *MockReadWriteCloser_Write_Call {\n\treturn &MockReadWriteCloser_Write_Call{Call: _e.mock.On(\"Write\", p)}\n}\n\nfunc (_c *MockReadWriteCloser_Write_Call) Run(run func(p []byte)) *MockReadWriteCloser_Write_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadWriteCloser_Write_Call) Return(n int, err error) *MockReadWriteCloser_Write_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadWriteCloser_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReadWriteCloser_Write_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReadSeeker creates a new instance of MockReadSeeker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReadSeeker(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReadSeeker {\n\tmock := &MockReadSeeker{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReadSeeker is an autogenerated mock type for the ReadSeeker type\ntype MockReadSeeker struct {\n\tmock.Mock\n}\n\ntype MockReadSeeker_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReadSeeker) EXPECT() *MockReadSeeker_Expecter {\n\treturn &MockReadSeeker_Expecter{mock: &_m.Mock}\n}\n\n// Read provides a mock function for the type MockReadSeeker\nfunc (_mock *MockReadSeeker) Read(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Read\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadSeeker_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'\ntype MockReadSeeker_Read_Call struct {\n\t*mock.Call\n}\n\n// Read is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReadSeeker_Expecter) Read(p interface{}) *MockReadSeeker_Read_Call {\n\treturn &MockReadSeeker_Read_Call{Call: _e.mock.On(\"Read\", p)}\n}\n\nfunc (_c *MockReadSeeker_Read_Call) Run(run func(p []byte)) *MockReadSeeker_Read_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadSeeker_Read_Call) Return(n int, err error) *MockReadSeeker_Read_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadSeeker_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReadSeeker_Read_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Seek provides a mock function for the type MockReadSeeker\nfunc (_mock *MockReadSeeker) Seek(offset int64, whence int) (int64, error) {\n\tret := _mock.Called(offset, whence)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Seek\")\n\t}\n\n\tvar r0 int64\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) (int64, error)); ok {\n\t\treturn returnFunc(offset, whence)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) int64); ok {\n\t\tr0 = returnFunc(offset, whence)\n\t} else {\n\t\tr0 = ret.Get(0).(int64)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(int64, int) error); ok {\n\t\tr1 = returnFunc(offset, whence)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadSeeker_Seek_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Seek'\ntype MockReadSeeker_Seek_Call struct {\n\t*mock.Call\n}\n\n// Seek is a helper method to define mock.On call\n// - offset int64\n// - whence int\nfunc (_e *MockReadSeeker_Expecter) Seek(offset interface{}, whence interface{}) *MockReadSeeker_Seek_Call {\n\treturn &MockReadSeeker_Seek_Call{Call: _e.mock.On(\"Seek\", offset, whence)}\n}\n\nfunc (_c *MockReadSeeker_Seek_Call) Run(run func(offset int64, whence int)) *MockReadSeeker_Seek_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int64\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int64)\n\t\t}\n\t\tvar arg1 int\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(int)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadSeeker_Seek_Call) Return(n int64, err error) *MockReadSeeker_Seek_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadSeeker_Seek_Call) RunAndReturn(run func(offset int64, whence int) (int64, error)) *MockReadSeeker_Seek_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReadSeekCloser creates a new instance of MockReadSeekCloser. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReadSeekCloser(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReadSeekCloser {\n\tmock := &MockReadSeekCloser{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReadSeekCloser is an autogenerated mock type for the ReadSeekCloser type\ntype MockReadSeekCloser struct {\n\tmock.Mock\n}\n\ntype MockReadSeekCloser_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReadSeekCloser) EXPECT() *MockReadSeekCloser_Expecter {\n\treturn &MockReadSeekCloser_Expecter{mock: &_m.Mock}\n}\n\n// Close provides a mock function for the type MockReadSeekCloser\nfunc (_mock *MockReadSeekCloser) Close() error {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Close\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func() error); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockReadSeekCloser_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'\ntype MockReadSeekCloser_Close_Call struct {\n\t*mock.Call\n}\n\n// Close is a helper method to define mock.On call\nfunc (_e *MockReadSeekCloser_Expecter) Close() *MockReadSeekCloser_Close_Call {\n\treturn &MockReadSeekCloser_Close_Call{Call: _e.mock.On(\"Close\")}\n}\n\nfunc (_c *MockReadSeekCloser_Close_Call) Run(run func()) *MockReadSeekCloser_Close_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadSeekCloser_Close_Call) Return(err error) *MockReadSeekCloser_Close_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockReadSeekCloser_Close_Call) RunAndReturn(run func() error) *MockReadSeekCloser_Close_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Read provides a mock function for the type MockReadSeekCloser\nfunc (_mock *MockReadSeekCloser) Read(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Read\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadSeekCloser_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'\ntype MockReadSeekCloser_Read_Call struct {\n\t*mock.Call\n}\n\n// Read is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReadSeekCloser_Expecter) Read(p interface{}) *MockReadSeekCloser_Read_Call {\n\treturn &MockReadSeekCloser_Read_Call{Call: _e.mock.On(\"Read\", p)}\n}\n\nfunc (_c *MockReadSeekCloser_Read_Call) Run(run func(p []byte)) *MockReadSeekCloser_Read_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadSeekCloser_Read_Call) Return(n int, err error) *MockReadSeekCloser_Read_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadSeekCloser_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReadSeekCloser_Read_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Seek provides a mock function for the type MockReadSeekCloser\nfunc (_mock *MockReadSeekCloser) Seek(offset int64, whence int) (int64, error) {\n\tret := _mock.Called(offset, whence)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Seek\")\n\t}\n\n\tvar r0 int64\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) (int64, error)); ok {\n\t\treturn returnFunc(offset, whence)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) int64); ok {\n\t\tr0 = returnFunc(offset, whence)\n\t} else {\n\t\tr0 = ret.Get(0).(int64)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(int64, int) error); ok {\n\t\tr1 = returnFunc(offset, whence)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadSeekCloser_Seek_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Seek'\ntype MockReadSeekCloser_Seek_Call struct {\n\t*mock.Call\n}\n\n// Seek is a helper method to define mock.On call\n// - offset int64\n// - whence int\nfunc (_e *MockReadSeekCloser_Expecter) Seek(offset interface{}, whence interface{}) *MockReadSeekCloser_Seek_Call {\n\treturn &MockReadSeekCloser_Seek_Call{Call: _e.mock.On(\"Seek\", offset, whence)}\n}\n\nfunc (_c *MockReadSeekCloser_Seek_Call) Run(run func(offset int64, whence int)) *MockReadSeekCloser_Seek_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int64\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int64)\n\t\t}\n\t\tvar arg1 int\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(int)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadSeekCloser_Seek_Call) Return(n int64, err error) *MockReadSeekCloser_Seek_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadSeekCloser_Seek_Call) RunAndReturn(run func(offset int64, whence int) (int64, error)) *MockReadSeekCloser_Seek_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockWriteSeeker creates a new instance of MockWriteSeeker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockWriteSeeker(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockWriteSeeker {\n\tmock := &MockWriteSeeker{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockWriteSeeker is an autogenerated mock type for the WriteSeeker type\ntype MockWriteSeeker struct {\n\tmock.Mock\n}\n\ntype MockWriteSeeker_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockWriteSeeker) EXPECT() *MockWriteSeeker_Expecter {\n\treturn &MockWriteSeeker_Expecter{mock: &_m.Mock}\n}\n\n// Seek provides a mock function for the type MockWriteSeeker\nfunc (_mock *MockWriteSeeker) Seek(offset int64, whence int) (int64, error) {\n\tret := _mock.Called(offset, whence)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Seek\")\n\t}\n\n\tvar r0 int64\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) (int64, error)); ok {\n\t\treturn returnFunc(offset, whence)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) int64); ok {\n\t\tr0 = returnFunc(offset, whence)\n\t} else {\n\t\tr0 = ret.Get(0).(int64)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(int64, int) error); ok {\n\t\tr1 = returnFunc(offset, whence)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockWriteSeeker_Seek_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Seek'\ntype MockWriteSeeker_Seek_Call struct {\n\t*mock.Call\n}\n\n// Seek is a helper method to define mock.On call\n// - offset int64\n// - whence int\nfunc (_e *MockWriteSeeker_Expecter) Seek(offset interface{}, whence interface{}) *MockWriteSeeker_Seek_Call {\n\treturn &MockWriteSeeker_Seek_Call{Call: _e.mock.On(\"Seek\", offset, whence)}\n}\n\nfunc (_c *MockWriteSeeker_Seek_Call) Run(run func(offset int64, whence int)) *MockWriteSeeker_Seek_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int64\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int64)\n\t\t}\n\t\tvar arg1 int\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(int)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockWriteSeeker_Seek_Call) Return(n int64, err error) *MockWriteSeeker_Seek_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockWriteSeeker_Seek_Call) RunAndReturn(run func(offset int64, whence int) (int64, error)) *MockWriteSeeker_Seek_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Write provides a mock function for the type MockWriteSeeker\nfunc (_mock *MockWriteSeeker) Write(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Write\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockWriteSeeker_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'\ntype MockWriteSeeker_Write_Call struct {\n\t*mock.Call\n}\n\n// Write is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockWriteSeeker_Expecter) Write(p interface{}) *MockWriteSeeker_Write_Call {\n\treturn &MockWriteSeeker_Write_Call{Call: _e.mock.On(\"Write\", p)}\n}\n\nfunc (_c *MockWriteSeeker_Write_Call) Run(run func(p []byte)) *MockWriteSeeker_Write_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockWriteSeeker_Write_Call) Return(n int, err error) *MockWriteSeeker_Write_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockWriteSeeker_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockWriteSeeker_Write_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReadWriteSeeker creates a new instance of MockReadWriteSeeker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReadWriteSeeker(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReadWriteSeeker {\n\tmock := &MockReadWriteSeeker{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReadWriteSeeker is an autogenerated mock type for the ReadWriteSeeker type\ntype MockReadWriteSeeker struct {\n\tmock.Mock\n}\n\ntype MockReadWriteSeeker_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReadWriteSeeker) EXPECT() *MockReadWriteSeeker_Expecter {\n\treturn &MockReadWriteSeeker_Expecter{mock: &_m.Mock}\n}\n\n// Read provides a mock function for the type MockReadWriteSeeker\nfunc (_mock *MockReadWriteSeeker) Read(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Read\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadWriteSeeker_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'\ntype MockReadWriteSeeker_Read_Call struct {\n\t*mock.Call\n}\n\n// Read is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReadWriteSeeker_Expecter) Read(p interface{}) *MockReadWriteSeeker_Read_Call {\n\treturn &MockReadWriteSeeker_Read_Call{Call: _e.mock.On(\"Read\", p)}\n}\n\nfunc (_c *MockReadWriteSeeker_Read_Call) Run(run func(p []byte)) *MockReadWriteSeeker_Read_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadWriteSeeker_Read_Call) Return(n int, err error) *MockReadWriteSeeker_Read_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadWriteSeeker_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReadWriteSeeker_Read_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Seek provides a mock function for the type MockReadWriteSeeker\nfunc (_mock *MockReadWriteSeeker) Seek(offset int64, whence int) (int64, error) {\n\tret := _mock.Called(offset, whence)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Seek\")\n\t}\n\n\tvar r0 int64\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) (int64, error)); ok {\n\t\treturn returnFunc(offset, whence)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(int64, int) int64); ok {\n\t\tr0 = returnFunc(offset, whence)\n\t} else {\n\t\tr0 = ret.Get(0).(int64)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(int64, int) error); ok {\n\t\tr1 = returnFunc(offset, whence)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadWriteSeeker_Seek_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Seek'\ntype MockReadWriteSeeker_Seek_Call struct {\n\t*mock.Call\n}\n\n// Seek is a helper method to define mock.On call\n// - offset int64\n// - whence int\nfunc (_e *MockReadWriteSeeker_Expecter) Seek(offset interface{}, whence interface{}) *MockReadWriteSeeker_Seek_Call {\n\treturn &MockReadWriteSeeker_Seek_Call{Call: _e.mock.On(\"Seek\", offset, whence)}\n}\n\nfunc (_c *MockReadWriteSeeker_Seek_Call) Run(run func(offset int64, whence int)) *MockReadWriteSeeker_Seek_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int64\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int64)\n\t\t}\n\t\tvar arg1 int\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(int)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadWriteSeeker_Seek_Call) Return(n int64, err error) *MockReadWriteSeeker_Seek_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadWriteSeeker_Seek_Call) RunAndReturn(run func(offset int64, whence int) (int64, error)) *MockReadWriteSeeker_Seek_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Write provides a mock function for the type MockReadWriteSeeker\nfunc (_mock *MockReadWriteSeeker) Write(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Write\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReadWriteSeeker_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'\ntype MockReadWriteSeeker_Write_Call struct {\n\t*mock.Call\n}\n\n// Write is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockReadWriteSeeker_Expecter) Write(p interface{}) *MockReadWriteSeeker_Write_Call {\n\treturn &MockReadWriteSeeker_Write_Call{Call: _e.mock.On(\"Write\", p)}\n}\n\nfunc (_c *MockReadWriteSeeker_Write_Call) Run(run func(p []byte)) *MockReadWriteSeeker_Write_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReadWriteSeeker_Write_Call) Return(n int, err error) *MockReadWriteSeeker_Write_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReadWriteSeeker_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockReadWriteSeeker_Write_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReaderFrom creates a new instance of MockReaderFrom. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReaderFrom(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReaderFrom {\n\tmock := &MockReaderFrom{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReaderFrom is an autogenerated mock type for the ReaderFrom type\ntype MockReaderFrom struct {\n\tmock.Mock\n}\n\ntype MockReaderFrom_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReaderFrom) EXPECT() *MockReaderFrom_Expecter {\n\treturn &MockReaderFrom_Expecter{mock: &_m.Mock}\n}\n\n// ReadFrom provides a mock function for the type MockReaderFrom\nfunc (_mock *MockReaderFrom) ReadFrom(r io.Reader) (int64, error) {\n\tret := _mock.Called(r)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for ReadFrom\")\n\t}\n\n\tvar r0 int64\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(io.Reader) (int64, error)); ok {\n\t\treturn returnFunc(r)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(io.Reader) int64); ok {\n\t\tr0 = returnFunc(r)\n\t} else {\n\t\tr0 = ret.Get(0).(int64)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(io.Reader) error); ok {\n\t\tr1 = returnFunc(r)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReaderFrom_ReadFrom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadFrom'\ntype MockReaderFrom_ReadFrom_Call struct {\n\t*mock.Call\n}\n\n// ReadFrom is a helper method to define mock.On call\n// - r io.Reader\nfunc (_e *MockReaderFrom_Expecter) ReadFrom(r interface{}) *MockReaderFrom_ReadFrom_Call {\n\treturn &MockReaderFrom_ReadFrom_Call{Call: _e.mock.On(\"ReadFrom\", r)}\n}\n\nfunc (_c *MockReaderFrom_ReadFrom_Call) Run(run func(r io.Reader)) *MockReaderFrom_ReadFrom_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 io.Reader\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(io.Reader)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReaderFrom_ReadFrom_Call) Return(n int64, err error) *MockReaderFrom_ReadFrom_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReaderFrom_ReadFrom_Call) RunAndReturn(run func(r io.Reader) (int64, error)) *MockReaderFrom_ReadFrom_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockWriterTo creates a new instance of MockWriterTo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockWriterTo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockWriterTo {\n\tmock := &MockWriterTo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockWriterTo is an autogenerated mock type for the WriterTo type\ntype MockWriterTo struct {\n\tmock.Mock\n}\n\ntype MockWriterTo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockWriterTo) EXPECT() *MockWriterTo_Expecter {\n\treturn &MockWriterTo_Expecter{mock: &_m.Mock}\n}\n\n// WriteTo provides a mock function for the type MockWriterTo\nfunc (_mock *MockWriterTo) WriteTo(w io.Writer) (int64, error) {\n\tret := _mock.Called(w)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for WriteTo\")\n\t}\n\n\tvar r0 int64\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(io.Writer) (int64, error)); ok {\n\t\treturn returnFunc(w)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(io.Writer) int64); ok {\n\t\tr0 = returnFunc(w)\n\t} else {\n\t\tr0 = ret.Get(0).(int64)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(io.Writer) error); ok {\n\t\tr1 = returnFunc(w)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockWriterTo_WriteTo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteTo'\ntype MockWriterTo_WriteTo_Call struct {\n\t*mock.Call\n}\n\n// WriteTo is a helper method to define mock.On call\n// - w io.Writer\nfunc (_e *MockWriterTo_Expecter) WriteTo(w interface{}) *MockWriterTo_WriteTo_Call {\n\treturn &MockWriterTo_WriteTo_Call{Call: _e.mock.On(\"WriteTo\", w)}\n}\n\nfunc (_c *MockWriterTo_WriteTo_Call) Run(run func(w io.Writer)) *MockWriterTo_WriteTo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 io.Writer\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(io.Writer)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockWriterTo_WriteTo_Call) Return(n int64, err error) *MockWriterTo_WriteTo_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockWriterTo_WriteTo_Call) RunAndReturn(run func(w io.Writer) (int64, error)) *MockWriterTo_WriteTo_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReaderAt creates a new instance of MockReaderAt. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReaderAt(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReaderAt {\n\tmock := &MockReaderAt{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReaderAt is an autogenerated mock type for the ReaderAt type\ntype MockReaderAt struct {\n\tmock.Mock\n}\n\ntype MockReaderAt_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReaderAt) EXPECT() *MockReaderAt_Expecter {\n\treturn &MockReaderAt_Expecter{mock: &_m.Mock}\n}\n\n// ReadAt provides a mock function for the type MockReaderAt\nfunc (_mock *MockReaderAt) ReadAt(p []byte, off int64) (int, error) {\n\tret := _mock.Called(p, off)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for ReadAt\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte, int64) (int, error)); ok {\n\t\treturn returnFunc(p, off)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte, int64) int); ok {\n\t\tr0 = returnFunc(p, off)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte, int64) error); ok {\n\t\tr1 = returnFunc(p, off)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockReaderAt_ReadAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadAt'\ntype MockReaderAt_ReadAt_Call struct {\n\t*mock.Call\n}\n\n// ReadAt is a helper method to define mock.On call\n// - p []byte\n// - off int64\nfunc (_e *MockReaderAt_Expecter) ReadAt(p interface{}, off interface{}) *MockReaderAt_ReadAt_Call {\n\treturn &MockReaderAt_ReadAt_Call{Call: _e.mock.On(\"ReadAt\", p, off)}\n}\n\nfunc (_c *MockReaderAt_ReadAt_Call) Run(run func(p []byte, off int64)) *MockReaderAt_ReadAt_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\tvar arg1 int64\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(int64)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReaderAt_ReadAt_Call) Return(n int, err error) *MockReaderAt_ReadAt_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockReaderAt_ReadAt_Call) RunAndReturn(run func(p []byte, off int64) (int, error)) *MockReaderAt_ReadAt_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockWriterAt creates a new instance of MockWriterAt. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockWriterAt(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockWriterAt {\n\tmock := &MockWriterAt{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockWriterAt is an autogenerated mock type for the WriterAt type\ntype MockWriterAt struct {\n\tmock.Mock\n}\n\ntype MockWriterAt_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockWriterAt) EXPECT() *MockWriterAt_Expecter {\n\treturn &MockWriterAt_Expecter{mock: &_m.Mock}\n}\n\n// WriteAt provides a mock function for the type MockWriterAt\nfunc (_mock *MockWriterAt) WriteAt(p []byte, off int64) (int, error) {\n\tret := _mock.Called(p, off)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for WriteAt\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte, int64) (int, error)); ok {\n\t\treturn returnFunc(p, off)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte, int64) int); ok {\n\t\tr0 = returnFunc(p, off)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte, int64) error); ok {\n\t\tr1 = returnFunc(p, off)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockWriterAt_WriteAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteAt'\ntype MockWriterAt_WriteAt_Call struct {\n\t*mock.Call\n}\n\n// WriteAt is a helper method to define mock.On call\n// - p []byte\n// - off int64\nfunc (_e *MockWriterAt_Expecter) WriteAt(p interface{}, off interface{}) *MockWriterAt_WriteAt_Call {\n\treturn &MockWriterAt_WriteAt_Call{Call: _e.mock.On(\"WriteAt\", p, off)}\n}\n\nfunc (_c *MockWriterAt_WriteAt_Call) Run(run func(p []byte, off int64)) *MockWriterAt_WriteAt_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\tvar arg1 int64\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(int64)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockWriterAt_WriteAt_Call) Return(n int, err error) *MockWriterAt_WriteAt_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockWriterAt_WriteAt_Call) RunAndReturn(run func(p []byte, off int64) (int, error)) *MockWriterAt_WriteAt_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockByteReader creates a new instance of MockByteReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockByteReader(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockByteReader {\n\tmock := &MockByteReader{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockByteReader is an autogenerated mock type for the ByteReader type\ntype MockByteReader struct {\n\tmock.Mock\n}\n\ntype MockByteReader_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockByteReader) EXPECT() *MockByteReader_Expecter {\n\treturn &MockByteReader_Expecter{mock: &_m.Mock}\n}\n\n// ReadByte provides a mock function for the type MockByteReader\nfunc (_mock *MockByteReader) ReadByte() (byte, error) {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for ReadByte\")\n\t}\n\n\tvar r0 byte\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func() (byte, error)); ok {\n\t\treturn returnFunc()\n\t}\n\tif returnFunc, ok := ret.Get(0).(func() byte); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(byte)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func() error); ok {\n\t\tr1 = returnFunc()\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockByteReader_ReadByte_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadByte'\ntype MockByteReader_ReadByte_Call struct {\n\t*mock.Call\n}\n\n// ReadByte is a helper method to define mock.On call\nfunc (_e *MockByteReader_Expecter) ReadByte() *MockByteReader_ReadByte_Call {\n\treturn &MockByteReader_ReadByte_Call{Call: _e.mock.On(\"ReadByte\")}\n}\n\nfunc (_c *MockByteReader_ReadByte_Call) Run(run func()) *MockByteReader_ReadByte_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockByteReader_ReadByte_Call) Return(v byte, err error) *MockByteReader_ReadByte_Call {\n\t_c.Call.Return(v, err)\n\treturn _c\n}\n\nfunc (_c *MockByteReader_ReadByte_Call) RunAndReturn(run func() (byte, error)) *MockByteReader_ReadByte_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockByteScanner creates a new instance of MockByteScanner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockByteScanner(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockByteScanner {\n\tmock := &MockByteScanner{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockByteScanner is an autogenerated mock type for the ByteScanner type\ntype MockByteScanner struct {\n\tmock.Mock\n}\n\ntype MockByteScanner_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockByteScanner) EXPECT() *MockByteScanner_Expecter {\n\treturn &MockByteScanner_Expecter{mock: &_m.Mock}\n}\n\n// ReadByte provides a mock function for the type MockByteScanner\nfunc (_mock *MockByteScanner) ReadByte() (byte, error) {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for ReadByte\")\n\t}\n\n\tvar r0 byte\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func() (byte, error)); ok {\n\t\treturn returnFunc()\n\t}\n\tif returnFunc, ok := ret.Get(0).(func() byte); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(byte)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func() error); ok {\n\t\tr1 = returnFunc()\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockByteScanner_ReadByte_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadByte'\ntype MockByteScanner_ReadByte_Call struct {\n\t*mock.Call\n}\n\n// ReadByte is a helper method to define mock.On call\nfunc (_e *MockByteScanner_Expecter) ReadByte() *MockByteScanner_ReadByte_Call {\n\treturn &MockByteScanner_ReadByte_Call{Call: _e.mock.On(\"ReadByte\")}\n}\n\nfunc (_c *MockByteScanner_ReadByte_Call) Run(run func()) *MockByteScanner_ReadByte_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockByteScanner_ReadByte_Call) Return(v byte, err error) *MockByteScanner_ReadByte_Call {\n\t_c.Call.Return(v, err)\n\treturn _c\n}\n\nfunc (_c *MockByteScanner_ReadByte_Call) RunAndReturn(run func() (byte, error)) *MockByteScanner_ReadByte_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// UnreadByte provides a mock function for the type MockByteScanner\nfunc (_mock *MockByteScanner) UnreadByte() error {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for UnreadByte\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func() error); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockByteScanner_UnreadByte_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnreadByte'\ntype MockByteScanner_UnreadByte_Call struct {\n\t*mock.Call\n}\n\n// UnreadByte is a helper method to define mock.On call\nfunc (_e *MockByteScanner_Expecter) UnreadByte() *MockByteScanner_UnreadByte_Call {\n\treturn &MockByteScanner_UnreadByte_Call{Call: _e.mock.On(\"UnreadByte\")}\n}\n\nfunc (_c *MockByteScanner_UnreadByte_Call) Run(run func()) *MockByteScanner_UnreadByte_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockByteScanner_UnreadByte_Call) Return(err error) *MockByteScanner_UnreadByte_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockByteScanner_UnreadByte_Call) RunAndReturn(run func() error) *MockByteScanner_UnreadByte_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockByteWriter creates a new instance of MockByteWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockByteWriter(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockByteWriter {\n\tmock := &MockByteWriter{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockByteWriter is an autogenerated mock type for the ByteWriter type\ntype MockByteWriter struct {\n\tmock.Mock\n}\n\ntype MockByteWriter_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockByteWriter) EXPECT() *MockByteWriter_Expecter {\n\treturn &MockByteWriter_Expecter{mock: &_m.Mock}\n}\n\n// WriteByte provides a mock function for the type MockByteWriter\nfunc (_mock *MockByteWriter) WriteByte(c byte) error {\n\tret := _mock.Called(c)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for WriteByte\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(byte) error); ok {\n\t\tr0 = returnFunc(c)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockByteWriter_WriteByte_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteByte'\ntype MockByteWriter_WriteByte_Call struct {\n\t*mock.Call\n}\n\n// WriteByte is a helper method to define mock.On call\n// - c byte\nfunc (_e *MockByteWriter_Expecter) WriteByte(c interface{}) *MockByteWriter_WriteByte_Call {\n\treturn &MockByteWriter_WriteByte_Call{Call: _e.mock.On(\"WriteByte\", c)}\n}\n\nfunc (_c *MockByteWriter_WriteByte_Call) Run(run func(c byte)) *MockByteWriter_WriteByte_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockByteWriter_WriteByte_Call) Return(err error) *MockByteWriter_WriteByte_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockByteWriter_WriteByte_Call) RunAndReturn(run func(c byte) error) *MockByteWriter_WriteByte_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRuneReader creates a new instance of MockRuneReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRuneReader(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRuneReader {\n\tmock := &MockRuneReader{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRuneReader is an autogenerated mock type for the RuneReader type\ntype MockRuneReader struct {\n\tmock.Mock\n}\n\ntype MockRuneReader_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRuneReader) EXPECT() *MockRuneReader_Expecter {\n\treturn &MockRuneReader_Expecter{mock: &_m.Mock}\n}\n\n// ReadRune provides a mock function for the type MockRuneReader\nfunc (_mock *MockRuneReader) ReadRune() (rune, int, error) {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for ReadRune\")\n\t}\n\n\tvar r0 rune\n\tvar r1 int\n\tvar r2 error\n\tif returnFunc, ok := ret.Get(0).(func() (rune, int, error)); ok {\n\t\treturn returnFunc()\n\t}\n\tif returnFunc, ok := ret.Get(0).(func() rune); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(rune)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func() int); ok {\n\t\tr1 = returnFunc()\n\t} else {\n\t\tr1 = ret.Get(1).(int)\n\t}\n\tif returnFunc, ok := ret.Get(2).(func() error); ok {\n\t\tr2 = returnFunc()\n\t} else {\n\t\tr2 = ret.Error(2)\n\t}\n\treturn r0, r1, r2\n}\n\n// MockRuneReader_ReadRune_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadRune'\ntype MockRuneReader_ReadRune_Call struct {\n\t*mock.Call\n}\n\n// ReadRune is a helper method to define mock.On call\nfunc (_e *MockRuneReader_Expecter) ReadRune() *MockRuneReader_ReadRune_Call {\n\treturn &MockRuneReader_ReadRune_Call{Call: _e.mock.On(\"ReadRune\")}\n}\n\nfunc (_c *MockRuneReader_ReadRune_Call) Run(run func()) *MockRuneReader_ReadRune_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRuneReader_ReadRune_Call) Return(r rune, size int, err error) *MockRuneReader_ReadRune_Call {\n\t_c.Call.Return(r, size, err)\n\treturn _c\n}\n\nfunc (_c *MockRuneReader_ReadRune_Call) RunAndReturn(run func() (rune, int, error)) *MockRuneReader_ReadRune_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRuneScanner creates a new instance of MockRuneScanner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRuneScanner(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRuneScanner {\n\tmock := &MockRuneScanner{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRuneScanner is an autogenerated mock type for the RuneScanner type\ntype MockRuneScanner struct {\n\tmock.Mock\n}\n\ntype MockRuneScanner_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRuneScanner) EXPECT() *MockRuneScanner_Expecter {\n\treturn &MockRuneScanner_Expecter{mock: &_m.Mock}\n}\n\n// ReadRune provides a mock function for the type MockRuneScanner\nfunc (_mock *MockRuneScanner) ReadRune() (rune, int, error) {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for ReadRune\")\n\t}\n\n\tvar r0 rune\n\tvar r1 int\n\tvar r2 error\n\tif returnFunc, ok := ret.Get(0).(func() (rune, int, error)); ok {\n\t\treturn returnFunc()\n\t}\n\tif returnFunc, ok := ret.Get(0).(func() rune); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(rune)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func() int); ok {\n\t\tr1 = returnFunc()\n\t} else {\n\t\tr1 = ret.Get(1).(int)\n\t}\n\tif returnFunc, ok := ret.Get(2).(func() error); ok {\n\t\tr2 = returnFunc()\n\t} else {\n\t\tr2 = ret.Error(2)\n\t}\n\treturn r0, r1, r2\n}\n\n// MockRuneScanner_ReadRune_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadRune'\ntype MockRuneScanner_ReadRune_Call struct {\n\t*mock.Call\n}\n\n// ReadRune is a helper method to define mock.On call\nfunc (_e *MockRuneScanner_Expecter) ReadRune() *MockRuneScanner_ReadRune_Call {\n\treturn &MockRuneScanner_ReadRune_Call{Call: _e.mock.On(\"ReadRune\")}\n}\n\nfunc (_c *MockRuneScanner_ReadRune_Call) Run(run func()) *MockRuneScanner_ReadRune_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRuneScanner_ReadRune_Call) Return(r rune, size int, err error) *MockRuneScanner_ReadRune_Call {\n\t_c.Call.Return(r, size, err)\n\treturn _c\n}\n\nfunc (_c *MockRuneScanner_ReadRune_Call) RunAndReturn(run func() (rune, int, error)) *MockRuneScanner_ReadRune_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// UnreadRune provides a mock function for the type MockRuneScanner\nfunc (_mock *MockRuneScanner) UnreadRune() error {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for UnreadRune\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func() error); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockRuneScanner_UnreadRune_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnreadRune'\ntype MockRuneScanner_UnreadRune_Call struct {\n\t*mock.Call\n}\n\n// UnreadRune is a helper method to define mock.On call\nfunc (_e *MockRuneScanner_Expecter) UnreadRune() *MockRuneScanner_UnreadRune_Call {\n\treturn &MockRuneScanner_UnreadRune_Call{Call: _e.mock.On(\"UnreadRune\")}\n}\n\nfunc (_c *MockRuneScanner_UnreadRune_Call) Run(run func()) *MockRuneScanner_UnreadRune_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRuneScanner_UnreadRune_Call) Return(err error) *MockRuneScanner_UnreadRune_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockRuneScanner_UnreadRune_Call) RunAndReturn(run func() error) *MockRuneScanner_UnreadRune_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockStringWriter creates a new instance of MockStringWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockStringWriter(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockStringWriter {\n\tmock := &MockStringWriter{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockStringWriter is an autogenerated mock type for the StringWriter type\ntype MockStringWriter struct {\n\tmock.Mock\n}\n\ntype MockStringWriter_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockStringWriter) EXPECT() *MockStringWriter_Expecter {\n\treturn &MockStringWriter_Expecter{mock: &_m.Mock}\n}\n\n// WriteString provides a mock function for the type MockStringWriter\nfunc (_mock *MockStringWriter) WriteString(s string) (int, error) {\n\tret := _mock.Called(s)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for WriteString\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) (int, error)); ok {\n\t\treturn returnFunc(s)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) int); ok {\n\t\tr0 = returnFunc(s)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(s)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockStringWriter_WriteString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteString'\ntype MockStringWriter_WriteString_Call struct {\n\t*mock.Call\n}\n\n// WriteString is a helper method to define mock.On call\n// - s string\nfunc (_e *MockStringWriter_Expecter) WriteString(s interface{}) *MockStringWriter_WriteString_Call {\n\treturn &MockStringWriter_WriteString_Call{Call: _e.mock.On(\"WriteString\", s)}\n}\n\nfunc (_c *MockStringWriter_WriteString_Call) Run(run func(s string)) *MockStringWriter_WriteString_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockStringWriter_WriteString_Call) Return(n int, err error) *MockStringWriter_WriteString_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockStringWriter_WriteString_Call) RunAndReturn(run func(s string) (int, error)) *MockStringWriter_WriteString_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/mocks_matryer_test_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: matryer\n\npackage test\n\nimport (\n\t\"encoding/json\"\n\t\"io\"\n\t\"net/http\"\n\t\"sync\"\n\t\"unsafe\"\n\n\thttp1 \"github.com/vektra/mockery/v3/internal/fixtures/12345678/http\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/constraints\"\n\thttp0 \"github.com/vektra/mockery/v3/internal/fixtures/http\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/redefined_type_b\"\n)\n\n// Ensure that MoqUsesAny does implement UsesAny.\n// If this is not the case, regenerate this file with mockery.\nvar _ UsesAny = &MoqUsesAny{}\n\n// MoqUsesAny is a mock implementation of UsesAny.\n//\n//\tfunc TestSomethingThatUsesUsesAny(t *testing.T) {\n//\n//\t\t// make and configure a mocked UsesAny\n//\t\tmockedUsesAny := &MoqUsesAny{\n//\t\t\tGetReaderFunc: func() any {\n//\t\t\t\tpanic(\"mock out the GetReader method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedUsesAny in code that requires UsesAny\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqUsesAny struct {\n\t// GetReaderFunc mocks the GetReader method.\n\tGetReaderFunc func() any\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// GetReader holds details about calls to the GetReader method.\n\t\tGetReader []struct {\n\t\t}\n\t}\n\tlockGetReader sync.RWMutex\n}\n\n// GetReader calls GetReaderFunc.\nfunc (mock *MoqUsesAny) GetReader() any {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockGetReader.Lock()\n\tmock.calls.GetReader = append(mock.calls.GetReader, callInfo)\n\tmock.lockGetReader.Unlock()\n\tif mock.GetReaderFunc == nil {\n\t\tvar (\n\t\t\tv any\n\t\t)\n\t\treturn v\n\t}\n\treturn mock.GetReaderFunc()\n}\n\n// GetReaderCalls gets all the calls that were made to GetReader.\n// Check the length with:\n//\n//\tlen(mockedUsesAny.GetReaderCalls())\nfunc (mock *MoqUsesAny) GetReaderCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockGetReader.RLock()\n\tcalls = mock.calls.GetReader\n\tmock.lockGetReader.RUnlock()\n\treturn calls\n}\n\n// ResetGetReaderCalls reset all the calls that were made to GetReader.\nfunc (mock *MoqUsesAny) ResetGetReaderCalls() {\n\tmock.lockGetReader.Lock()\n\tmock.calls.GetReader = nil\n\tmock.lockGetReader.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqUsesAny) ResetCalls() {\n\tmock.lockGetReader.Lock()\n\tmock.calls.GetReader = nil\n\tmock.lockGetReader.Unlock()\n}\n\n// Ensure that MoqFooer does implement Fooer.\n// If this is not the case, regenerate this file with mockery.\nvar _ Fooer = &MoqFooer{}\n\n// MoqFooer is a mock implementation of Fooer.\n//\n//\tfunc TestSomethingThatUsesFooer(t *testing.T) {\n//\n//\t\t// make and configure a mocked Fooer\n//\t\tmockedFooer := &MoqFooer{\n//\t\t\tBarFunc: func(f func([]int)) {\n//\t\t\t\tpanic(\"mock out the Bar method\")\n//\t\t\t},\n//\t\t\tBazFunc: func(path string) func(x string) string {\n//\t\t\t\tpanic(\"mock out the Baz method\")\n//\t\t\t},\n//\t\t\tFooFunc: func(f func(x string) string) error {\n//\t\t\t\tpanic(\"mock out the Foo method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedFooer in code that requires Fooer\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqFooer struct {\n\t// BarFunc mocks the Bar method.\n\tBarFunc func(f func([]int))\n\n\t// BazFunc mocks the Baz method.\n\tBazFunc func(path string) func(x string) string\n\n\t// FooFunc mocks the Foo method.\n\tFooFunc func(f func(x string) string) error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Bar holds details about calls to the Bar method.\n\t\tBar []struct {\n\t\t\t// F is the f argument value.\n\t\t\tF func([]int)\n\t\t}\n\t\t// Baz holds details about calls to the Baz method.\n\t\tBaz []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t\t// Foo holds details about calls to the Foo method.\n\t\tFoo []struct {\n\t\t\t// F is the f argument value.\n\t\t\tF func(x string) string\n\t\t}\n\t}\n\tlockBar sync.RWMutex\n\tlockBaz sync.RWMutex\n\tlockFoo sync.RWMutex\n}\n\n// Bar calls BarFunc.\nfunc (mock *MoqFooer) Bar(f func([]int)) {\n\tcallInfo := struct {\n\t\tF func([]int)\n\t}{\n\t\tF: f,\n\t}\n\tmock.lockBar.Lock()\n\tmock.calls.Bar = append(mock.calls.Bar, callInfo)\n\tmock.lockBar.Unlock()\n\tif mock.BarFunc == nil {\n\t\treturn\n\t}\n\tmock.BarFunc(f)\n}\n\n// BarCalls gets all the calls that were made to Bar.\n// Check the length with:\n//\n//\tlen(mockedFooer.BarCalls())\nfunc (mock *MoqFooer) BarCalls() []struct {\n\tF func([]int)\n} {\n\tvar calls []struct {\n\t\tF func([]int)\n\t}\n\tmock.lockBar.RLock()\n\tcalls = mock.calls.Bar\n\tmock.lockBar.RUnlock()\n\treturn calls\n}\n\n// ResetBarCalls reset all the calls that were made to Bar.\nfunc (mock *MoqFooer) ResetBarCalls() {\n\tmock.lockBar.Lock()\n\tmock.calls.Bar = nil\n\tmock.lockBar.Unlock()\n}\n\n// Baz calls BazFunc.\nfunc (mock *MoqFooer) Baz(path string) func(x string) string {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockBaz.Lock()\n\tmock.calls.Baz = append(mock.calls.Baz, callInfo)\n\tmock.lockBaz.Unlock()\n\tif mock.BazFunc == nil {\n\t\tvar (\n\t\t\tfn func(x string) string\n\t\t)\n\t\treturn fn\n\t}\n\treturn mock.BazFunc(path)\n}\n\n// BazCalls gets all the calls that were made to Baz.\n// Check the length with:\n//\n//\tlen(mockedFooer.BazCalls())\nfunc (mock *MoqFooer) BazCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockBaz.RLock()\n\tcalls = mock.calls.Baz\n\tmock.lockBaz.RUnlock()\n\treturn calls\n}\n\n// ResetBazCalls reset all the calls that were made to Baz.\nfunc (mock *MoqFooer) ResetBazCalls() {\n\tmock.lockBaz.Lock()\n\tmock.calls.Baz = nil\n\tmock.lockBaz.Unlock()\n}\n\n// Foo calls FooFunc.\nfunc (mock *MoqFooer) Foo(f func(x string) string) error {\n\tcallInfo := struct {\n\t\tF func(x string) string\n\t}{\n\t\tF: f,\n\t}\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = append(mock.calls.Foo, callInfo)\n\tmock.lockFoo.Unlock()\n\tif mock.FooFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.FooFunc(f)\n}\n\n// FooCalls gets all the calls that were made to Foo.\n// Check the length with:\n//\n//\tlen(mockedFooer.FooCalls())\nfunc (mock *MoqFooer) FooCalls() []struct {\n\tF func(x string) string\n} {\n\tvar calls []struct {\n\t\tF func(x string) string\n\t}\n\tmock.lockFoo.RLock()\n\tcalls = mock.calls.Foo\n\tmock.lockFoo.RUnlock()\n\treturn calls\n}\n\n// ResetFooCalls reset all the calls that were made to Foo.\nfunc (mock *MoqFooer) ResetFooCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqFooer) ResetCalls() {\n\tmock.lockBar.Lock()\n\tmock.calls.Bar = nil\n\tmock.lockBar.Unlock()\n\n\tmock.lockBaz.Lock()\n\tmock.calls.Baz = nil\n\tmock.lockBaz.Unlock()\n\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// Ensure that MoqMapFunc does implement MapFunc.\n// If this is not the case, regenerate this file with mockery.\nvar _ MapFunc = &MoqMapFunc{}\n\n// MoqMapFunc is a mock implementation of MapFunc.\n//\n//\tfunc TestSomethingThatUsesMapFunc(t *testing.T) {\n//\n//\t\t// make and configure a mocked MapFunc\n//\t\tmockedMapFunc := &MoqMapFunc{\n//\t\t\tGetFunc: func(m map[string]func(string) string) error {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedMapFunc in code that requires MapFunc\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqMapFunc struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(m map[string]func(string) string) error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// M is the m argument value.\n\t\t\tM map[string]func(string) string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqMapFunc) Get(m map[string]func(string) string) error {\n\tcallInfo := struct {\n\t\tM map[string]func(string) string\n\t}{\n\t\tM: m,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.GetFunc(m)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedMapFunc.GetCalls())\nfunc (mock *MoqMapFunc) GetCalls() []struct {\n\tM map[string]func(string) string\n} {\n\tvar calls []struct {\n\t\tM map[string]func(string) string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqMapFunc) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqMapFunc) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqAsyncProducer does implement AsyncProducer.\n// If this is not the case, regenerate this file with mockery.\nvar _ AsyncProducer = &MoqAsyncProducer{}\n\n// MoqAsyncProducer is a mock implementation of AsyncProducer.\n//\n//\tfunc TestSomethingThatUsesAsyncProducer(t *testing.T) {\n//\n//\t\t// make and configure a mocked AsyncProducer\n//\t\tmockedAsyncProducer := &MoqAsyncProducer{\n//\t\t\tInputFunc: func() chan<- bool {\n//\t\t\t\tpanic(\"mock out the Input method\")\n//\t\t\t},\n//\t\t\tOutputFunc: func() <-chan bool {\n//\t\t\t\tpanic(\"mock out the Output method\")\n//\t\t\t},\n//\t\t\tWhateverFunc: func() chan bool {\n//\t\t\t\tpanic(\"mock out the Whatever method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedAsyncProducer in code that requires AsyncProducer\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqAsyncProducer struct {\n\t// InputFunc mocks the Input method.\n\tInputFunc func() chan<- bool\n\n\t// OutputFunc mocks the Output method.\n\tOutputFunc func() <-chan bool\n\n\t// WhateverFunc mocks the Whatever method.\n\tWhateverFunc func() chan bool\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Input holds details about calls to the Input method.\n\t\tInput []struct {\n\t\t}\n\t\t// Output holds details about calls to the Output method.\n\t\tOutput []struct {\n\t\t}\n\t\t// Whatever holds details about calls to the Whatever method.\n\t\tWhatever []struct {\n\t\t}\n\t}\n\tlockInput sync.RWMutex\n\tlockOutput sync.RWMutex\n\tlockWhatever sync.RWMutex\n}\n\n// Input calls InputFunc.\nfunc (mock *MoqAsyncProducer) Input() chan<- bool {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockInput.Lock()\n\tmock.calls.Input = append(mock.calls.Input, callInfo)\n\tmock.lockInput.Unlock()\n\tif mock.InputFunc == nil {\n\t\tvar (\n\t\t\tboolCh chan<- bool\n\t\t)\n\t\treturn boolCh\n\t}\n\treturn mock.InputFunc()\n}\n\n// InputCalls gets all the calls that were made to Input.\n// Check the length with:\n//\n//\tlen(mockedAsyncProducer.InputCalls())\nfunc (mock *MoqAsyncProducer) InputCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockInput.RLock()\n\tcalls = mock.calls.Input\n\tmock.lockInput.RUnlock()\n\treturn calls\n}\n\n// ResetInputCalls reset all the calls that were made to Input.\nfunc (mock *MoqAsyncProducer) ResetInputCalls() {\n\tmock.lockInput.Lock()\n\tmock.calls.Input = nil\n\tmock.lockInput.Unlock()\n}\n\n// Output calls OutputFunc.\nfunc (mock *MoqAsyncProducer) Output() <-chan bool {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockOutput.Lock()\n\tmock.calls.Output = append(mock.calls.Output, callInfo)\n\tmock.lockOutput.Unlock()\n\tif mock.OutputFunc == nil {\n\t\tvar (\n\t\t\tboolCh <-chan bool\n\t\t)\n\t\treturn boolCh\n\t}\n\treturn mock.OutputFunc()\n}\n\n// OutputCalls gets all the calls that were made to Output.\n// Check the length with:\n//\n//\tlen(mockedAsyncProducer.OutputCalls())\nfunc (mock *MoqAsyncProducer) OutputCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockOutput.RLock()\n\tcalls = mock.calls.Output\n\tmock.lockOutput.RUnlock()\n\treturn calls\n}\n\n// ResetOutputCalls reset all the calls that were made to Output.\nfunc (mock *MoqAsyncProducer) ResetOutputCalls() {\n\tmock.lockOutput.Lock()\n\tmock.calls.Output = nil\n\tmock.lockOutput.Unlock()\n}\n\n// Whatever calls WhateverFunc.\nfunc (mock *MoqAsyncProducer) Whatever() chan bool {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockWhatever.Lock()\n\tmock.calls.Whatever = append(mock.calls.Whatever, callInfo)\n\tmock.lockWhatever.Unlock()\n\tif mock.WhateverFunc == nil {\n\t\tvar (\n\t\t\tboolCh chan bool\n\t\t)\n\t\treturn boolCh\n\t}\n\treturn mock.WhateverFunc()\n}\n\n// WhateverCalls gets all the calls that were made to Whatever.\n// Check the length with:\n//\n//\tlen(mockedAsyncProducer.WhateverCalls())\nfunc (mock *MoqAsyncProducer) WhateverCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockWhatever.RLock()\n\tcalls = mock.calls.Whatever\n\tmock.lockWhatever.RUnlock()\n\treturn calls\n}\n\n// ResetWhateverCalls reset all the calls that were made to Whatever.\nfunc (mock *MoqAsyncProducer) ResetWhateverCalls() {\n\tmock.lockWhatever.Lock()\n\tmock.calls.Whatever = nil\n\tmock.lockWhatever.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqAsyncProducer) ResetCalls() {\n\tmock.lockInput.Lock()\n\tmock.calls.Input = nil\n\tmock.lockInput.Unlock()\n\n\tmock.lockOutput.Lock()\n\tmock.calls.Output = nil\n\tmock.lockOutput.Unlock()\n\n\tmock.lockWhatever.Lock()\n\tmock.calls.Whatever = nil\n\tmock.lockWhatever.Unlock()\n}\n\n// Ensure that MoqConsulLock does implement ConsulLock.\n// If this is not the case, regenerate this file with mockery.\nvar _ ConsulLock = &MoqConsulLock{}\n\n// MoqConsulLock is a mock implementation of ConsulLock.\n//\n//\tfunc TestSomethingThatUsesConsulLock(t *testing.T) {\n//\n//\t\t// make and configure a mocked ConsulLock\n//\t\tmockedConsulLock := &MoqConsulLock{\n//\t\t\tLockFunc: func(valCh <-chan struct{}) (<-chan struct{}, error) {\n//\t\t\t\tpanic(\"mock out the Lock method\")\n//\t\t\t},\n//\t\t\tUnlockFunc: func() error {\n//\t\t\t\tpanic(\"mock out the Unlock method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedConsulLock in code that requires ConsulLock\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqConsulLock struct {\n\t// LockFunc mocks the Lock method.\n\tLockFunc func(valCh <-chan struct{}) (<-chan struct{}, error)\n\n\t// UnlockFunc mocks the Unlock method.\n\tUnlockFunc func() error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Lock holds details about calls to the Lock method.\n\t\tLock []struct {\n\t\t\t// ValCh is the valCh argument value.\n\t\t\tValCh <-chan struct{}\n\t\t}\n\t\t// Unlock holds details about calls to the Unlock method.\n\t\tUnlock []struct {\n\t\t}\n\t}\n\tlockLock sync.RWMutex\n\tlockUnlock sync.RWMutex\n}\n\n// Lock calls LockFunc.\nfunc (mock *MoqConsulLock) Lock(valCh <-chan struct{}) (<-chan struct{}, error) {\n\tcallInfo := struct {\n\t\tValCh <-chan struct{}\n\t}{\n\t\tValCh: valCh,\n\t}\n\tmock.lockLock.Lock()\n\tmock.calls.Lock = append(mock.calls.Lock, callInfo)\n\tmock.lockLock.Unlock()\n\tif mock.LockFunc == nil {\n\t\tvar (\n\t\t\tvalCh1 <-chan struct{}\n\t\t\terr error\n\t\t)\n\t\treturn valCh1, err\n\t}\n\treturn mock.LockFunc(valCh)\n}\n\n// LockCalls gets all the calls that were made to Lock.\n// Check the length with:\n//\n//\tlen(mockedConsulLock.LockCalls())\nfunc (mock *MoqConsulLock) LockCalls() []struct {\n\tValCh <-chan struct{}\n} {\n\tvar calls []struct {\n\t\tValCh <-chan struct{}\n\t}\n\tmock.lockLock.RLock()\n\tcalls = mock.calls.Lock\n\tmock.lockLock.RUnlock()\n\treturn calls\n}\n\n// ResetLockCalls reset all the calls that were made to Lock.\nfunc (mock *MoqConsulLock) ResetLockCalls() {\n\tmock.lockLock.Lock()\n\tmock.calls.Lock = nil\n\tmock.lockLock.Unlock()\n}\n\n// Unlock calls UnlockFunc.\nfunc (mock *MoqConsulLock) Unlock() error {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockUnlock.Lock()\n\tmock.calls.Unlock = append(mock.calls.Unlock, callInfo)\n\tmock.lockUnlock.Unlock()\n\tif mock.UnlockFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.UnlockFunc()\n}\n\n// UnlockCalls gets all the calls that were made to Unlock.\n// Check the length with:\n//\n//\tlen(mockedConsulLock.UnlockCalls())\nfunc (mock *MoqConsulLock) UnlockCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockUnlock.RLock()\n\tcalls = mock.calls.Unlock\n\tmock.lockUnlock.RUnlock()\n\treturn calls\n}\n\n// ResetUnlockCalls reset all the calls that were made to Unlock.\nfunc (mock *MoqConsulLock) ResetUnlockCalls() {\n\tmock.lockUnlock.Lock()\n\tmock.calls.Unlock = nil\n\tmock.lockUnlock.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqConsulLock) ResetCalls() {\n\tmock.lockLock.Lock()\n\tmock.calls.Lock = nil\n\tmock.lockLock.Unlock()\n\n\tmock.lockUnlock.Lock()\n\tmock.calls.Unlock = nil\n\tmock.lockUnlock.Unlock()\n}\n\n// Ensure that MoqKeyManager does implement KeyManager.\n// If this is not the case, regenerate this file with mockery.\nvar _ KeyManager = &MoqKeyManager{}\n\n// MoqKeyManager is a mock implementation of KeyManager.\n//\n//\tfunc TestSomethingThatUsesKeyManager(t *testing.T) {\n//\n//\t\t// make and configure a mocked KeyManager\n//\t\tmockedKeyManager := &MoqKeyManager{\n//\t\t\tGetKeyFunc: func(s string, v uint16) ([]byte, *Err) {\n//\t\t\t\tpanic(\"mock out the GetKey method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedKeyManager in code that requires KeyManager\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqKeyManager struct {\n\t// GetKeyFunc mocks the GetKey method.\n\tGetKeyFunc func(s string, v uint16) ([]byte, *Err)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// GetKey holds details about calls to the GetKey method.\n\t\tGetKey []struct {\n\t\t\t// S is the s argument value.\n\t\t\tS string\n\t\t\t// V is the v argument value.\n\t\t\tV uint16\n\t\t}\n\t}\n\tlockGetKey sync.RWMutex\n}\n\n// GetKey calls GetKeyFunc.\nfunc (mock *MoqKeyManager) GetKey(s string, v uint16) ([]byte, *Err) {\n\tcallInfo := struct {\n\t\tS string\n\t\tV uint16\n\t}{\n\t\tS: s,\n\t\tV: v,\n\t}\n\tmock.lockGetKey.Lock()\n\tmock.calls.GetKey = append(mock.calls.GetKey, callInfo)\n\tmock.lockGetKey.Unlock()\n\tif mock.GetKeyFunc == nil {\n\t\tvar (\n\t\t\tbytes []byte\n\t\t\terr *Err\n\t\t)\n\t\treturn bytes, err\n\t}\n\treturn mock.GetKeyFunc(s, v)\n}\n\n// GetKeyCalls gets all the calls that were made to GetKey.\n// Check the length with:\n//\n//\tlen(mockedKeyManager.GetKeyCalls())\nfunc (mock *MoqKeyManager) GetKeyCalls() []struct {\n\tS string\n\tV uint16\n} {\n\tvar calls []struct {\n\t\tS string\n\t\tV uint16\n\t}\n\tmock.lockGetKey.RLock()\n\tcalls = mock.calls.GetKey\n\tmock.lockGetKey.RUnlock()\n\treturn calls\n}\n\n// ResetGetKeyCalls reset all the calls that were made to GetKey.\nfunc (mock *MoqKeyManager) ResetGetKeyCalls() {\n\tmock.lockGetKey.Lock()\n\tmock.calls.GetKey = nil\n\tmock.lockGetKey.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqKeyManager) ResetCalls() {\n\tmock.lockGetKey.Lock()\n\tmock.calls.GetKey = nil\n\tmock.lockGetKey.Unlock()\n}\n\n// Ensure that MoqBlank does implement Blank.\n// If this is not the case, regenerate this file with mockery.\nvar _ Blank = &MoqBlank{}\n\n// MoqBlank is a mock implementation of Blank.\n//\n//\tfunc TestSomethingThatUsesBlank(t *testing.T) {\n//\n//\t\t// make and configure a mocked Blank\n//\t\tmockedBlank := &MoqBlank{\n//\t\t\tCreateFunc: func(x interface{}) error {\n//\t\t\t\tpanic(\"mock out the Create method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedBlank in code that requires Blank\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqBlank struct {\n\t// CreateFunc mocks the Create method.\n\tCreateFunc func(x interface{}) error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Create holds details about calls to the Create method.\n\t\tCreate []struct {\n\t\t\t// X is the x argument value.\n\t\t\tX interface{}\n\t\t}\n\t}\n\tlockCreate sync.RWMutex\n}\n\n// Create calls CreateFunc.\nfunc (mock *MoqBlank) Create(x interface{}) error {\n\tcallInfo := struct {\n\t\tX interface{}\n\t}{\n\t\tX: x,\n\t}\n\tmock.lockCreate.Lock()\n\tmock.calls.Create = append(mock.calls.Create, callInfo)\n\tmock.lockCreate.Unlock()\n\tif mock.CreateFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.CreateFunc(x)\n}\n\n// CreateCalls gets all the calls that were made to Create.\n// Check the length with:\n//\n//\tlen(mockedBlank.CreateCalls())\nfunc (mock *MoqBlank) CreateCalls() []struct {\n\tX interface{}\n} {\n\tvar calls []struct {\n\t\tX interface{}\n\t}\n\tmock.lockCreate.RLock()\n\tcalls = mock.calls.Create\n\tmock.lockCreate.RUnlock()\n\treturn calls\n}\n\n// ResetCreateCalls reset all the calls that were made to Create.\nfunc (mock *MoqBlank) ResetCreateCalls() {\n\tmock.lockCreate.Lock()\n\tmock.calls.Create = nil\n\tmock.lockCreate.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqBlank) ResetCalls() {\n\tmock.lockCreate.Lock()\n\tmock.calls.Create = nil\n\tmock.lockCreate.Unlock()\n}\n\n// Ensure that MoqExpecter does implement Expecter.\n// If this is not the case, regenerate this file with mockery.\nvar _ Expecter = &MoqExpecter{}\n\n// MoqExpecter is a mock implementation of Expecter.\n//\n//\tfunc TestSomethingThatUsesExpecter(t *testing.T) {\n//\n//\t\t// make and configure a mocked Expecter\n//\t\tmockedExpecter := &MoqExpecter{\n//\t\t\tManyArgsReturnsFunc: func(str string, i int) ([]string, error) {\n//\t\t\t\tpanic(\"mock out the ManyArgsReturns method\")\n//\t\t\t},\n//\t\t\tNoArgFunc: func() string {\n//\t\t\t\tpanic(\"mock out the NoArg method\")\n//\t\t\t},\n//\t\t\tNoReturnFunc: func(str string) {\n//\t\t\t\tpanic(\"mock out the NoReturn method\")\n//\t\t\t},\n//\t\t\tVariadicFunc: func(ints ...int) error {\n//\t\t\t\tpanic(\"mock out the Variadic method\")\n//\t\t\t},\n//\t\t\tVariadicManyFunc: func(i int, a string, intfs ...interface{}) error {\n//\t\t\t\tpanic(\"mock out the VariadicMany method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedExpecter in code that requires Expecter\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqExpecter struct {\n\t// ManyArgsReturnsFunc mocks the ManyArgsReturns method.\n\tManyArgsReturnsFunc func(str string, i int) ([]string, error)\n\n\t// NoArgFunc mocks the NoArg method.\n\tNoArgFunc func() string\n\n\t// NoReturnFunc mocks the NoReturn method.\n\tNoReturnFunc func(str string)\n\n\t// VariadicFunc mocks the Variadic method.\n\tVariadicFunc func(ints ...int) error\n\n\t// VariadicManyFunc mocks the VariadicMany method.\n\tVariadicManyFunc func(i int, a string, intfs ...interface{}) error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// ManyArgsReturns holds details about calls to the ManyArgsReturns method.\n\t\tManyArgsReturns []struct {\n\t\t\t// Str is the str argument value.\n\t\t\tStr string\n\t\t\t// I is the i argument value.\n\t\t\tI int\n\t\t}\n\t\t// NoArg holds details about calls to the NoArg method.\n\t\tNoArg []struct {\n\t\t}\n\t\t// NoReturn holds details about calls to the NoReturn method.\n\t\tNoReturn []struct {\n\t\t\t// Str is the str argument value.\n\t\t\tStr string\n\t\t}\n\t\t// Variadic holds details about calls to the Variadic method.\n\t\tVariadic []struct {\n\t\t\t// Ints is the ints argument value.\n\t\t\tInts []int\n\t\t}\n\t\t// VariadicMany holds details about calls to the VariadicMany method.\n\t\tVariadicMany []struct {\n\t\t\t// I is the i argument value.\n\t\t\tI int\n\t\t\t// A is the a argument value.\n\t\t\tA string\n\t\t\t// Intfs is the intfs argument value.\n\t\t\tIntfs []interface{}\n\t\t}\n\t}\n\tlockManyArgsReturns sync.RWMutex\n\tlockNoArg sync.RWMutex\n\tlockNoReturn sync.RWMutex\n\tlockVariadic sync.RWMutex\n\tlockVariadicMany sync.RWMutex\n}\n\n// ManyArgsReturns calls ManyArgsReturnsFunc.\nfunc (mock *MoqExpecter) ManyArgsReturns(str string, i int) ([]string, error) {\n\tcallInfo := struct {\n\t\tStr string\n\t\tI int\n\t}{\n\t\tStr: str,\n\t\tI: i,\n\t}\n\tmock.lockManyArgsReturns.Lock()\n\tmock.calls.ManyArgsReturns = append(mock.calls.ManyArgsReturns, callInfo)\n\tmock.lockManyArgsReturns.Unlock()\n\tif mock.ManyArgsReturnsFunc == nil {\n\t\tvar (\n\t\t\tstrs []string\n\t\t\terr error\n\t\t)\n\t\treturn strs, err\n\t}\n\treturn mock.ManyArgsReturnsFunc(str, i)\n}\n\n// ManyArgsReturnsCalls gets all the calls that were made to ManyArgsReturns.\n// Check the length with:\n//\n//\tlen(mockedExpecter.ManyArgsReturnsCalls())\nfunc (mock *MoqExpecter) ManyArgsReturnsCalls() []struct {\n\tStr string\n\tI int\n} {\n\tvar calls []struct {\n\t\tStr string\n\t\tI int\n\t}\n\tmock.lockManyArgsReturns.RLock()\n\tcalls = mock.calls.ManyArgsReturns\n\tmock.lockManyArgsReturns.RUnlock()\n\treturn calls\n}\n\n// ResetManyArgsReturnsCalls reset all the calls that were made to ManyArgsReturns.\nfunc (mock *MoqExpecter) ResetManyArgsReturnsCalls() {\n\tmock.lockManyArgsReturns.Lock()\n\tmock.calls.ManyArgsReturns = nil\n\tmock.lockManyArgsReturns.Unlock()\n}\n\n// NoArg calls NoArgFunc.\nfunc (mock *MoqExpecter) NoArg() string {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockNoArg.Lock()\n\tmock.calls.NoArg = append(mock.calls.NoArg, callInfo)\n\tmock.lockNoArg.Unlock()\n\tif mock.NoArgFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t)\n\t\treturn s\n\t}\n\treturn mock.NoArgFunc()\n}\n\n// NoArgCalls gets all the calls that were made to NoArg.\n// Check the length with:\n//\n//\tlen(mockedExpecter.NoArgCalls())\nfunc (mock *MoqExpecter) NoArgCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockNoArg.RLock()\n\tcalls = mock.calls.NoArg\n\tmock.lockNoArg.RUnlock()\n\treturn calls\n}\n\n// ResetNoArgCalls reset all the calls that were made to NoArg.\nfunc (mock *MoqExpecter) ResetNoArgCalls() {\n\tmock.lockNoArg.Lock()\n\tmock.calls.NoArg = nil\n\tmock.lockNoArg.Unlock()\n}\n\n// NoReturn calls NoReturnFunc.\nfunc (mock *MoqExpecter) NoReturn(str string) {\n\tcallInfo := struct {\n\t\tStr string\n\t}{\n\t\tStr: str,\n\t}\n\tmock.lockNoReturn.Lock()\n\tmock.calls.NoReturn = append(mock.calls.NoReturn, callInfo)\n\tmock.lockNoReturn.Unlock()\n\tif mock.NoReturnFunc == nil {\n\t\treturn\n\t}\n\tmock.NoReturnFunc(str)\n}\n\n// NoReturnCalls gets all the calls that were made to NoReturn.\n// Check the length with:\n//\n//\tlen(mockedExpecter.NoReturnCalls())\nfunc (mock *MoqExpecter) NoReturnCalls() []struct {\n\tStr string\n} {\n\tvar calls []struct {\n\t\tStr string\n\t}\n\tmock.lockNoReturn.RLock()\n\tcalls = mock.calls.NoReturn\n\tmock.lockNoReturn.RUnlock()\n\treturn calls\n}\n\n// ResetNoReturnCalls reset all the calls that were made to NoReturn.\nfunc (mock *MoqExpecter) ResetNoReturnCalls() {\n\tmock.lockNoReturn.Lock()\n\tmock.calls.NoReturn = nil\n\tmock.lockNoReturn.Unlock()\n}\n\n// Variadic calls VariadicFunc.\nfunc (mock *MoqExpecter) Variadic(ints ...int) error {\n\tcallInfo := struct {\n\t\tInts []int\n\t}{\n\t\tInts: ints,\n\t}\n\tmock.lockVariadic.Lock()\n\tmock.calls.Variadic = append(mock.calls.Variadic, callInfo)\n\tmock.lockVariadic.Unlock()\n\tif mock.VariadicFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.VariadicFunc(ints...)\n}\n\n// VariadicCalls gets all the calls that were made to Variadic.\n// Check the length with:\n//\n//\tlen(mockedExpecter.VariadicCalls())\nfunc (mock *MoqExpecter) VariadicCalls() []struct {\n\tInts []int\n} {\n\tvar calls []struct {\n\t\tInts []int\n\t}\n\tmock.lockVariadic.RLock()\n\tcalls = mock.calls.Variadic\n\tmock.lockVariadic.RUnlock()\n\treturn calls\n}\n\n// ResetVariadicCalls reset all the calls that were made to Variadic.\nfunc (mock *MoqExpecter) ResetVariadicCalls() {\n\tmock.lockVariadic.Lock()\n\tmock.calls.Variadic = nil\n\tmock.lockVariadic.Unlock()\n}\n\n// VariadicMany calls VariadicManyFunc.\nfunc (mock *MoqExpecter) VariadicMany(i int, a string, intfs ...interface{}) error {\n\tcallInfo := struct {\n\t\tI int\n\t\tA string\n\t\tIntfs []interface{}\n\t}{\n\t\tI: i,\n\t\tA: a,\n\t\tIntfs: intfs,\n\t}\n\tmock.lockVariadicMany.Lock()\n\tmock.calls.VariadicMany = append(mock.calls.VariadicMany, callInfo)\n\tmock.lockVariadicMany.Unlock()\n\tif mock.VariadicManyFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.VariadicManyFunc(i, a, intfs...)\n}\n\n// VariadicManyCalls gets all the calls that were made to VariadicMany.\n// Check the length with:\n//\n//\tlen(mockedExpecter.VariadicManyCalls())\nfunc (mock *MoqExpecter) VariadicManyCalls() []struct {\n\tI int\n\tA string\n\tIntfs []interface{}\n} {\n\tvar calls []struct {\n\t\tI int\n\t\tA string\n\t\tIntfs []interface{}\n\t}\n\tmock.lockVariadicMany.RLock()\n\tcalls = mock.calls.VariadicMany\n\tmock.lockVariadicMany.RUnlock()\n\treturn calls\n}\n\n// ResetVariadicManyCalls reset all the calls that were made to VariadicMany.\nfunc (mock *MoqExpecter) ResetVariadicManyCalls() {\n\tmock.lockVariadicMany.Lock()\n\tmock.calls.VariadicMany = nil\n\tmock.lockVariadicMany.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqExpecter) ResetCalls() {\n\tmock.lockManyArgsReturns.Lock()\n\tmock.calls.ManyArgsReturns = nil\n\tmock.lockManyArgsReturns.Unlock()\n\n\tmock.lockNoArg.Lock()\n\tmock.calls.NoArg = nil\n\tmock.lockNoArg.Unlock()\n\n\tmock.lockNoReturn.Lock()\n\tmock.calls.NoReturn = nil\n\tmock.lockNoReturn.Unlock()\n\n\tmock.lockVariadic.Lock()\n\tmock.calls.Variadic = nil\n\tmock.lockVariadic.Unlock()\n\n\tmock.lockVariadicMany.Lock()\n\tmock.calls.VariadicMany = nil\n\tmock.lockVariadicMany.Unlock()\n}\n\n// Ensure that MoqVariadicNoReturnInterface does implement VariadicNoReturnInterface.\n// If this is not the case, regenerate this file with mockery.\nvar _ VariadicNoReturnInterface = &MoqVariadicNoReturnInterface{}\n\n// MoqVariadicNoReturnInterface is a mock implementation of VariadicNoReturnInterface.\n//\n//\tfunc TestSomethingThatUsesVariadicNoReturnInterface(t *testing.T) {\n//\n//\t\t// make and configure a mocked VariadicNoReturnInterface\n//\t\tmockedVariadicNoReturnInterface := &MoqVariadicNoReturnInterface{\n//\t\t\tVariadicNoReturnFunc: func(j int, is ...interface{}) {\n//\t\t\t\tpanic(\"mock out the VariadicNoReturn method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedVariadicNoReturnInterface in code that requires VariadicNoReturnInterface\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqVariadicNoReturnInterface struct {\n\t// VariadicNoReturnFunc mocks the VariadicNoReturn method.\n\tVariadicNoReturnFunc func(j int, is ...interface{})\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// VariadicNoReturn holds details about calls to the VariadicNoReturn method.\n\t\tVariadicNoReturn []struct {\n\t\t\t// J is the j argument value.\n\t\t\tJ int\n\t\t\t// Is is the is argument value.\n\t\t\tIs []interface{}\n\t\t}\n\t}\n\tlockVariadicNoReturn sync.RWMutex\n}\n\n// VariadicNoReturn calls VariadicNoReturnFunc.\nfunc (mock *MoqVariadicNoReturnInterface) VariadicNoReturn(j int, is ...interface{}) {\n\tcallInfo := struct {\n\t\tJ int\n\t\tIs []interface{}\n\t}{\n\t\tJ: j,\n\t\tIs: is,\n\t}\n\tmock.lockVariadicNoReturn.Lock()\n\tmock.calls.VariadicNoReturn = append(mock.calls.VariadicNoReturn, callInfo)\n\tmock.lockVariadicNoReturn.Unlock()\n\tif mock.VariadicNoReturnFunc == nil {\n\t\treturn\n\t}\n\tmock.VariadicNoReturnFunc(j, is...)\n}\n\n// VariadicNoReturnCalls gets all the calls that were made to VariadicNoReturn.\n// Check the length with:\n//\n//\tlen(mockedVariadicNoReturnInterface.VariadicNoReturnCalls())\nfunc (mock *MoqVariadicNoReturnInterface) VariadicNoReturnCalls() []struct {\n\tJ int\n\tIs []interface{}\n} {\n\tvar calls []struct {\n\t\tJ int\n\t\tIs []interface{}\n\t}\n\tmock.lockVariadicNoReturn.RLock()\n\tcalls = mock.calls.VariadicNoReturn\n\tmock.lockVariadicNoReturn.RUnlock()\n\treturn calls\n}\n\n// ResetVariadicNoReturnCalls reset all the calls that were made to VariadicNoReturn.\nfunc (mock *MoqVariadicNoReturnInterface) ResetVariadicNoReturnCalls() {\n\tmock.lockVariadicNoReturn.Lock()\n\tmock.calls.VariadicNoReturn = nil\n\tmock.lockVariadicNoReturn.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqVariadicNoReturnInterface) ResetCalls() {\n\tmock.lockVariadicNoReturn.Lock()\n\tmock.calls.VariadicNoReturn = nil\n\tmock.lockVariadicNoReturn.Unlock()\n}\n\n// Ensure that MoqFuncArgsCollision does implement FuncArgsCollision.\n// If this is not the case, regenerate this file with mockery.\nvar _ FuncArgsCollision = &MoqFuncArgsCollision{}\n\n// MoqFuncArgsCollision is a mock implementation of FuncArgsCollision.\n//\n//\tfunc TestSomethingThatUsesFuncArgsCollision(t *testing.T) {\n//\n//\t\t// make and configure a mocked FuncArgsCollision\n//\t\tmockedFuncArgsCollision := &MoqFuncArgsCollision{\n//\t\t\tFooFunc: func(ret interface{}) error {\n//\t\t\t\tpanic(\"mock out the Foo method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedFuncArgsCollision in code that requires FuncArgsCollision\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqFuncArgsCollision struct {\n\t// FooFunc mocks the Foo method.\n\tFooFunc func(ret interface{}) error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Foo holds details about calls to the Foo method.\n\t\tFoo []struct {\n\t\t\t// Ret is the ret argument value.\n\t\t\tRet interface{}\n\t\t}\n\t}\n\tlockFoo sync.RWMutex\n}\n\n// Foo calls FooFunc.\nfunc (mock *MoqFuncArgsCollision) Foo(ret interface{}) error {\n\tcallInfo := struct {\n\t\tRet interface{}\n\t}{\n\t\tRet: ret,\n\t}\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = append(mock.calls.Foo, callInfo)\n\tmock.lockFoo.Unlock()\n\tif mock.FooFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.FooFunc(ret)\n}\n\n// FooCalls gets all the calls that were made to Foo.\n// Check the length with:\n//\n//\tlen(mockedFuncArgsCollision.FooCalls())\nfunc (mock *MoqFuncArgsCollision) FooCalls() []struct {\n\tRet interface{}\n} {\n\tvar calls []struct {\n\t\tRet interface{}\n\t}\n\tmock.lockFoo.RLock()\n\tcalls = mock.calls.Foo\n\tmock.lockFoo.RUnlock()\n\treturn calls\n}\n\n// ResetFooCalls reset all the calls that were made to Foo.\nfunc (mock *MoqFuncArgsCollision) ResetFooCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqFuncArgsCollision) ResetCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// Ensure that MoqGetInt does implement GetInt.\n// If this is not the case, regenerate this file with mockery.\nvar _ GetInt = &MoqGetInt{}\n\n// MoqGetInt is a mock implementation of GetInt.\n//\n//\tfunc TestSomethingThatUsesGetInt(t *testing.T) {\n//\n//\t\t// make and configure a mocked GetInt\n//\t\tmockedGetInt := &MoqGetInt{\n//\t\t\tGetFunc: func() int {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedGetInt in code that requires GetInt\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqGetInt struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func() int\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqGetInt) Get() int {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\tn int\n\t\t)\n\t\treturn n\n\t}\n\treturn mock.GetFunc()\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedGetInt.GetCalls())\nfunc (mock *MoqGetInt) GetCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqGetInt) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqGetInt) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqGetGeneric does implement GetGeneric.\n// If this is not the case, regenerate this file with mockery.\nvar _ GetGeneric[int] = &MoqGetGeneric[int]{}\n\n// MoqGetGeneric is a mock implementation of GetGeneric.\n//\n//\tfunc TestSomethingThatUsesGetGeneric(t *testing.T) {\n//\n//\t\t// make and configure a mocked GetGeneric\n//\t\tmockedGetGeneric := &MoqGetGeneric{\n//\t\t\tGetFunc: func() T {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedGetGeneric in code that requires GetGeneric\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqGetGeneric[T constraints.Integer] struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func() T\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqGetGeneric[T]) Get() T {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\tv T\n\t\t)\n\t\treturn v\n\t}\n\treturn mock.GetFunc()\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedGetGeneric.GetCalls())\nfunc (mock *MoqGetGeneric[T]) GetCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqGetGeneric[T]) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqGetGeneric[T]) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqEmbeddedGet does implement EmbeddedGet.\n// If this is not the case, regenerate this file with mockery.\nvar _ EmbeddedGet[int] = &MoqEmbeddedGet[int]{}\n\n// MoqEmbeddedGet is a mock implementation of EmbeddedGet.\n//\n//\tfunc TestSomethingThatUsesEmbeddedGet(t *testing.T) {\n//\n//\t\t// make and configure a mocked EmbeddedGet\n//\t\tmockedEmbeddedGet := &MoqEmbeddedGet{\n//\t\t\tGetFunc: func() T {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedEmbeddedGet in code that requires EmbeddedGet\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqEmbeddedGet[T constraints.Signed] struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func() T\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqEmbeddedGet[T]) Get() T {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\tv T\n\t\t)\n\t\treturn v\n\t}\n\treturn mock.GetFunc()\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedEmbeddedGet.GetCalls())\nfunc (mock *MoqEmbeddedGet[T]) GetCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqEmbeddedGet[T]) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqEmbeddedGet[T]) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqReplaceGeneric does implement ReplaceGeneric.\n// If this is not the case, regenerate this file with mockery.\nvar _ ReplaceGeneric[any, int, any] = &MoqReplaceGeneric[any, int, any]{}\n\n// MoqReplaceGeneric is a mock implementation of ReplaceGeneric.\n//\n//\tfunc TestSomethingThatUsesReplaceGeneric(t *testing.T) {\n//\n//\t\t// make and configure a mocked ReplaceGeneric\n//\t\tmockedReplaceGeneric := &MoqReplaceGeneric{\n//\t\t\tAFunc: func(t1 TImport) TKeep {\n//\t\t\t\tpanic(\"mock out the A method\")\n//\t\t\t},\n//\t\t\tBFunc: func() TImport {\n//\t\t\t\tpanic(\"mock out the B method\")\n//\t\t\t},\n//\t\t\tCFunc: func() TConstraint {\n//\t\t\t\tpanic(\"mock out the C method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedReplaceGeneric in code that requires ReplaceGeneric\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any] struct {\n\t// AFunc mocks the A method.\n\tAFunc func(t1 TImport) TKeep\n\n\t// BFunc mocks the B method.\n\tBFunc func() TImport\n\n\t// CFunc mocks the C method.\n\tCFunc func() TConstraint\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// A holds details about calls to the A method.\n\t\tA []struct {\n\t\t\t// T1 is the t1 argument value.\n\t\t\tT1 TImport\n\t\t}\n\t\t// B holds details about calls to the B method.\n\t\tB []struct {\n\t\t}\n\t\t// C holds details about calls to the C method.\n\t\tC []struct {\n\t\t}\n\t}\n\tlockA sync.RWMutex\n\tlockB sync.RWMutex\n\tlockC sync.RWMutex\n}\n\n// A calls AFunc.\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) A(t1 TImport) TKeep {\n\tcallInfo := struct {\n\t\tT1 TImport\n\t}{\n\t\tT1: t1,\n\t}\n\tmock.lockA.Lock()\n\tmock.calls.A = append(mock.calls.A, callInfo)\n\tmock.lockA.Unlock()\n\tif mock.AFunc == nil {\n\t\tvar (\n\t\t\tv TKeep\n\t\t)\n\t\treturn v\n\t}\n\treturn mock.AFunc(t1)\n}\n\n// ACalls gets all the calls that were made to A.\n// Check the length with:\n//\n//\tlen(mockedReplaceGeneric.ACalls())\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) ACalls() []struct {\n\tT1 TImport\n} {\n\tvar calls []struct {\n\t\tT1 TImport\n\t}\n\tmock.lockA.RLock()\n\tcalls = mock.calls.A\n\tmock.lockA.RUnlock()\n\treturn calls\n}\n\n// ResetACalls reset all the calls that were made to A.\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) ResetACalls() {\n\tmock.lockA.Lock()\n\tmock.calls.A = nil\n\tmock.lockA.Unlock()\n}\n\n// B calls BFunc.\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) B() TImport {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockB.Lock()\n\tmock.calls.B = append(mock.calls.B, callInfo)\n\tmock.lockB.Unlock()\n\tif mock.BFunc == nil {\n\t\tvar (\n\t\t\tv TImport\n\t\t)\n\t\treturn v\n\t}\n\treturn mock.BFunc()\n}\n\n// BCalls gets all the calls that were made to B.\n// Check the length with:\n//\n//\tlen(mockedReplaceGeneric.BCalls())\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) BCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockB.RLock()\n\tcalls = mock.calls.B\n\tmock.lockB.RUnlock()\n\treturn calls\n}\n\n// ResetBCalls reset all the calls that were made to B.\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) ResetBCalls() {\n\tmock.lockB.Lock()\n\tmock.calls.B = nil\n\tmock.lockB.Unlock()\n}\n\n// C calls CFunc.\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) C() TConstraint {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockC.Lock()\n\tmock.calls.C = append(mock.calls.C, callInfo)\n\tmock.lockC.Unlock()\n\tif mock.CFunc == nil {\n\t\tvar (\n\t\t\tv TConstraint\n\t\t)\n\t\treturn v\n\t}\n\treturn mock.CFunc()\n}\n\n// CCalls gets all the calls that were made to C.\n// Check the length with:\n//\n//\tlen(mockedReplaceGeneric.CCalls())\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) CCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockC.RLock()\n\tcalls = mock.calls.C\n\tmock.lockC.RUnlock()\n\treturn calls\n}\n\n// ResetCCalls reset all the calls that were made to C.\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) ResetCCalls() {\n\tmock.lockC.Lock()\n\tmock.calls.C = nil\n\tmock.lockC.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqReplaceGeneric[TImport, TConstraint, TKeep]) ResetCalls() {\n\tmock.lockA.Lock()\n\tmock.calls.A = nil\n\tmock.lockA.Unlock()\n\n\tmock.lockB.Lock()\n\tmock.calls.B = nil\n\tmock.lockB.Unlock()\n\n\tmock.lockC.Lock()\n\tmock.calls.C = nil\n\tmock.lockC.Unlock()\n}\n\n// Ensure that MoqReplaceGenericSelf does implement ReplaceGenericSelf.\n// If this is not the case, regenerate this file with mockery.\nvar _ ReplaceGenericSelf[any] = &MoqReplaceGenericSelf[any]{}\n\n// MoqReplaceGenericSelf is a mock implementation of ReplaceGenericSelf.\n//\n//\tfunc TestSomethingThatUsesReplaceGenericSelf(t *testing.T) {\n//\n//\t\t// make and configure a mocked ReplaceGenericSelf\n//\t\tmockedReplaceGenericSelf := &MoqReplaceGenericSelf{\n//\t\t\tAFunc: func() T {\n//\t\t\t\tpanic(\"mock out the A method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedReplaceGenericSelf in code that requires ReplaceGenericSelf\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqReplaceGenericSelf[T any] struct {\n\t// AFunc mocks the A method.\n\tAFunc func() T\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// A holds details about calls to the A method.\n\t\tA []struct {\n\t\t}\n\t}\n\tlockA sync.RWMutex\n}\n\n// A calls AFunc.\nfunc (mock *MoqReplaceGenericSelf[T]) A() T {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockA.Lock()\n\tmock.calls.A = append(mock.calls.A, callInfo)\n\tmock.lockA.Unlock()\n\tif mock.AFunc == nil {\n\t\tvar (\n\t\t\tv T\n\t\t)\n\t\treturn v\n\t}\n\treturn mock.AFunc()\n}\n\n// ACalls gets all the calls that were made to A.\n// Check the length with:\n//\n//\tlen(mockedReplaceGenericSelf.ACalls())\nfunc (mock *MoqReplaceGenericSelf[T]) ACalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockA.RLock()\n\tcalls = mock.calls.A\n\tmock.lockA.RUnlock()\n\treturn calls\n}\n\n// ResetACalls reset all the calls that were made to A.\nfunc (mock *MoqReplaceGenericSelf[T]) ResetACalls() {\n\tmock.lockA.Lock()\n\tmock.calls.A = nil\n\tmock.lockA.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqReplaceGenericSelf[T]) ResetCalls() {\n\tmock.lockA.Lock()\n\tmock.calls.A = nil\n\tmock.lockA.Unlock()\n}\n\n// Ensure that MoqHasConflictingNestedImports does implement HasConflictingNestedImports.\n// If this is not the case, regenerate this file with mockery.\nvar _ HasConflictingNestedImports = &MoqHasConflictingNestedImports{}\n\n// MoqHasConflictingNestedImports is a mock implementation of HasConflictingNestedImports.\n//\n//\tfunc TestSomethingThatUsesHasConflictingNestedImports(t *testing.T) {\n//\n//\t\t// make and configure a mocked HasConflictingNestedImports\n//\t\tmockedHasConflictingNestedImports := &MoqHasConflictingNestedImports{\n//\t\t\tGetFunc: func(path string) (http.Response, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t\tZFunc: func() http0.MyStruct {\n//\t\t\t\tpanic(\"mock out the Z method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedHasConflictingNestedImports in code that requires HasConflictingNestedImports\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqHasConflictingNestedImports struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) (http.Response, error)\n\n\t// ZFunc mocks the Z method.\n\tZFunc func() http0.MyStruct\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t\t// Z holds details about calls to the Z method.\n\t\tZ []struct {\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n\tlockZ sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqHasConflictingNestedImports) Get(path string) (http.Response, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\tresponse http.Response\n\t\t\terr error\n\t\t)\n\t\treturn response, err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedHasConflictingNestedImports.GetCalls())\nfunc (mock *MoqHasConflictingNestedImports) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqHasConflictingNestedImports) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Z calls ZFunc.\nfunc (mock *MoqHasConflictingNestedImports) Z() http0.MyStruct {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockZ.Lock()\n\tmock.calls.Z = append(mock.calls.Z, callInfo)\n\tmock.lockZ.Unlock()\n\tif mock.ZFunc == nil {\n\t\tvar (\n\t\t\tmyStruct http0.MyStruct\n\t\t)\n\t\treturn myStruct\n\t}\n\treturn mock.ZFunc()\n}\n\n// ZCalls gets all the calls that were made to Z.\n// Check the length with:\n//\n//\tlen(mockedHasConflictingNestedImports.ZCalls())\nfunc (mock *MoqHasConflictingNestedImports) ZCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockZ.RLock()\n\tcalls = mock.calls.Z\n\tmock.lockZ.RUnlock()\n\treturn calls\n}\n\n// ResetZCalls reset all the calls that were made to Z.\nfunc (mock *MoqHasConflictingNestedImports) ResetZCalls() {\n\tmock.lockZ.Lock()\n\tmock.calls.Z = nil\n\tmock.lockZ.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqHasConflictingNestedImports) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n\n\tmock.lockZ.Lock()\n\tmock.calls.Z = nil\n\tmock.lockZ.Unlock()\n}\n\n// Ensure that MoqImportsSameAsPackage does implement ImportsSameAsPackage.\n// If this is not the case, regenerate this file with mockery.\nvar _ ImportsSameAsPackage = &MoqImportsSameAsPackage{}\n\n// MoqImportsSameAsPackage is a mock implementation of ImportsSameAsPackage.\n//\n//\tfunc TestSomethingThatUsesImportsSameAsPackage(t *testing.T) {\n//\n//\t\t// make and configure a mocked ImportsSameAsPackage\n//\t\tmockedImportsSameAsPackage := &MoqImportsSameAsPackage{\n//\t\t\tAFunc: func() test.B {\n//\t\t\t\tpanic(\"mock out the A method\")\n//\t\t\t},\n//\t\t\tBFunc: func() KeyManager {\n//\t\t\t\tpanic(\"mock out the B method\")\n//\t\t\t},\n//\t\t\tCFunc: func(c C) {\n//\t\t\t\tpanic(\"mock out the C method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedImportsSameAsPackage in code that requires ImportsSameAsPackage\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqImportsSameAsPackage struct {\n\t// AFunc mocks the A method.\n\tAFunc func() test.B\n\n\t// BFunc mocks the B method.\n\tBFunc func() KeyManager\n\n\t// CFunc mocks the C method.\n\tCFunc func(c C)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// A holds details about calls to the A method.\n\t\tA []struct {\n\t\t}\n\t\t// B holds details about calls to the B method.\n\t\tB []struct {\n\t\t}\n\t\t// C holds details about calls to the C method.\n\t\tC []struct {\n\t\t\t// C is the c argument value.\n\t\t\tC C\n\t\t}\n\t}\n\tlockA sync.RWMutex\n\tlockB sync.RWMutex\n\tlockC sync.RWMutex\n}\n\n// A calls AFunc.\nfunc (mock *MoqImportsSameAsPackage) A() test.B {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockA.Lock()\n\tmock.calls.A = append(mock.calls.A, callInfo)\n\tmock.lockA.Unlock()\n\tif mock.AFunc == nil {\n\t\tvar (\n\t\t\tb test.B\n\t\t)\n\t\treturn b\n\t}\n\treturn mock.AFunc()\n}\n\n// ACalls gets all the calls that were made to A.\n// Check the length with:\n//\n//\tlen(mockedImportsSameAsPackage.ACalls())\nfunc (mock *MoqImportsSameAsPackage) ACalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockA.RLock()\n\tcalls = mock.calls.A\n\tmock.lockA.RUnlock()\n\treturn calls\n}\n\n// ResetACalls reset all the calls that were made to A.\nfunc (mock *MoqImportsSameAsPackage) ResetACalls() {\n\tmock.lockA.Lock()\n\tmock.calls.A = nil\n\tmock.lockA.Unlock()\n}\n\n// B calls BFunc.\nfunc (mock *MoqImportsSameAsPackage) B() KeyManager {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockB.Lock()\n\tmock.calls.B = append(mock.calls.B, callInfo)\n\tmock.lockB.Unlock()\n\tif mock.BFunc == nil {\n\t\tvar (\n\t\t\tkeyManager KeyManager\n\t\t)\n\t\treturn keyManager\n\t}\n\treturn mock.BFunc()\n}\n\n// BCalls gets all the calls that were made to B.\n// Check the length with:\n//\n//\tlen(mockedImportsSameAsPackage.BCalls())\nfunc (mock *MoqImportsSameAsPackage) BCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockB.RLock()\n\tcalls = mock.calls.B\n\tmock.lockB.RUnlock()\n\treturn calls\n}\n\n// ResetBCalls reset all the calls that were made to B.\nfunc (mock *MoqImportsSameAsPackage) ResetBCalls() {\n\tmock.lockB.Lock()\n\tmock.calls.B = nil\n\tmock.lockB.Unlock()\n}\n\n// C calls CFunc.\nfunc (mock *MoqImportsSameAsPackage) C(c C) {\n\tcallInfo := struct {\n\t\tC C\n\t}{\n\t\tC: c,\n\t}\n\tmock.lockC.Lock()\n\tmock.calls.C = append(mock.calls.C, callInfo)\n\tmock.lockC.Unlock()\n\tif mock.CFunc == nil {\n\t\treturn\n\t}\n\tmock.CFunc(c)\n}\n\n// CCalls gets all the calls that were made to C.\n// Check the length with:\n//\n//\tlen(mockedImportsSameAsPackage.CCalls())\nfunc (mock *MoqImportsSameAsPackage) CCalls() []struct {\n\tC C\n} {\n\tvar calls []struct {\n\t\tC C\n\t}\n\tmock.lockC.RLock()\n\tcalls = mock.calls.C\n\tmock.lockC.RUnlock()\n\treturn calls\n}\n\n// ResetCCalls reset all the calls that were made to C.\nfunc (mock *MoqImportsSameAsPackage) ResetCCalls() {\n\tmock.lockC.Lock()\n\tmock.calls.C = nil\n\tmock.lockC.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqImportsSameAsPackage) ResetCalls() {\n\tmock.lockA.Lock()\n\tmock.calls.A = nil\n\tmock.lockA.Unlock()\n\n\tmock.lockB.Lock()\n\tmock.calls.B = nil\n\tmock.lockB.Unlock()\n\n\tmock.lockC.Lock()\n\tmock.calls.C = nil\n\tmock.lockC.Unlock()\n}\n\n// Ensure that MoqGenericInterface does implement GenericInterface.\n// If this is not the case, regenerate this file with mockery.\nvar _ GenericInterface[any] = &MoqGenericInterface[any]{}\n\n// MoqGenericInterface is a mock implementation of GenericInterface.\n//\n//\tfunc TestSomethingThatUsesGenericInterface(t *testing.T) {\n//\n//\t\t// make and configure a mocked GenericInterface\n//\t\tmockedGenericInterface := &MoqGenericInterface{\n//\t\t\tFuncFunc: func(arg *M) int {\n//\t\t\t\tpanic(\"mock out the Func method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedGenericInterface in code that requires GenericInterface\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqGenericInterface[M any] struct {\n\t// FuncFunc mocks the Func method.\n\tFuncFunc func(arg *M) int\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Func holds details about calls to the Func method.\n\t\tFunc []struct {\n\t\t\t// Arg is the arg argument value.\n\t\t\tArg *M\n\t\t}\n\t}\n\tlockFunc sync.RWMutex\n}\n\n// Func calls FuncFunc.\nfunc (mock *MoqGenericInterface[M]) Func(arg *M) int {\n\tcallInfo := struct {\n\t\tArg *M\n\t}{\n\t\tArg: arg,\n\t}\n\tmock.lockFunc.Lock()\n\tmock.calls.Func = append(mock.calls.Func, callInfo)\n\tmock.lockFunc.Unlock()\n\tif mock.FuncFunc == nil {\n\t\tvar (\n\t\t\tn int\n\t\t)\n\t\treturn n\n\t}\n\treturn mock.FuncFunc(arg)\n}\n\n// FuncCalls gets all the calls that were made to Func.\n// Check the length with:\n//\n//\tlen(mockedGenericInterface.FuncCalls())\nfunc (mock *MoqGenericInterface[M]) FuncCalls() []struct {\n\tArg *M\n} {\n\tvar calls []struct {\n\t\tArg *M\n\t}\n\tmock.lockFunc.RLock()\n\tcalls = mock.calls.Func\n\tmock.lockFunc.RUnlock()\n\treturn calls\n}\n\n// ResetFuncCalls reset all the calls that were made to Func.\nfunc (mock *MoqGenericInterface[M]) ResetFuncCalls() {\n\tmock.lockFunc.Lock()\n\tmock.calls.Func = nil\n\tmock.lockFunc.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqGenericInterface[M]) ResetCalls() {\n\tmock.lockFunc.Lock()\n\tmock.calls.Func = nil\n\tmock.lockFunc.Unlock()\n}\n\n// Ensure that MoqInstantiatedGenericInterface does implement InstantiatedGenericInterface.\n// If this is not the case, regenerate this file with mockery.\nvar _ InstantiatedGenericInterface = &MoqInstantiatedGenericInterface{}\n\n// MoqInstantiatedGenericInterface is a mock implementation of InstantiatedGenericInterface.\n//\n//\tfunc TestSomethingThatUsesInstantiatedGenericInterface(t *testing.T) {\n//\n//\t\t// make and configure a mocked InstantiatedGenericInterface\n//\t\tmockedInstantiatedGenericInterface := &MoqInstantiatedGenericInterface{\n//\t\t\tFuncFunc: func(arg *float32) int {\n//\t\t\t\tpanic(\"mock out the Func method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedInstantiatedGenericInterface in code that requires InstantiatedGenericInterface\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqInstantiatedGenericInterface struct {\n\t// FuncFunc mocks the Func method.\n\tFuncFunc func(arg *float32) int\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Func holds details about calls to the Func method.\n\t\tFunc []struct {\n\t\t\t// Arg is the arg argument value.\n\t\t\tArg *float32\n\t\t}\n\t}\n\tlockFunc sync.RWMutex\n}\n\n// Func calls FuncFunc.\nfunc (mock *MoqInstantiatedGenericInterface) Func(arg *float32) int {\n\tcallInfo := struct {\n\t\tArg *float32\n\t}{\n\t\tArg: arg,\n\t}\n\tmock.lockFunc.Lock()\n\tmock.calls.Func = append(mock.calls.Func, callInfo)\n\tmock.lockFunc.Unlock()\n\tif mock.FuncFunc == nil {\n\t\tvar (\n\t\t\tn int\n\t\t)\n\t\treturn n\n\t}\n\treturn mock.FuncFunc(arg)\n}\n\n// FuncCalls gets all the calls that were made to Func.\n// Check the length with:\n//\n//\tlen(mockedInstantiatedGenericInterface.FuncCalls())\nfunc (mock *MoqInstantiatedGenericInterface) FuncCalls() []struct {\n\tArg *float32\n} {\n\tvar calls []struct {\n\t\tArg *float32\n\t}\n\tmock.lockFunc.RLock()\n\tcalls = mock.calls.Func\n\tmock.lockFunc.RUnlock()\n\treturn calls\n}\n\n// ResetFuncCalls reset all the calls that were made to Func.\nfunc (mock *MoqInstantiatedGenericInterface) ResetFuncCalls() {\n\tmock.lockFunc.Lock()\n\tmock.calls.Func = nil\n\tmock.lockFunc.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqInstantiatedGenericInterface) ResetCalls() {\n\tmock.lockFunc.Lock()\n\tmock.calls.Func = nil\n\tmock.lockFunc.Unlock()\n}\n\n// Ensure that MoqMyReader does implement MyReader.\n// If this is not the case, regenerate this file with mockery.\nvar _ MyReader = &MoqMyReader{}\n\n// MoqMyReader is a mock implementation of MyReader.\n//\n//\tfunc TestSomethingThatUsesMyReader(t *testing.T) {\n//\n//\t\t// make and configure a mocked MyReader\n//\t\tmockedMyReader := &MoqMyReader{\n//\t\t\tReadFunc: func(p []byte) (int, error) {\n//\t\t\t\tpanic(\"mock out the Read method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedMyReader in code that requires MyReader\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqMyReader struct {\n\t// ReadFunc mocks the Read method.\n\tReadFunc func(p []byte) (int, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Read holds details about calls to the Read method.\n\t\tRead []struct {\n\t\t\t// P is the p argument value.\n\t\t\tP []byte\n\t\t}\n\t}\n\tlockRead sync.RWMutex\n}\n\n// Read calls ReadFunc.\nfunc (mock *MoqMyReader) Read(p []byte) (int, error) {\n\tcallInfo := struct {\n\t\tP []byte\n\t}{\n\t\tP: p,\n\t}\n\tmock.lockRead.Lock()\n\tmock.calls.Read = append(mock.calls.Read, callInfo)\n\tmock.lockRead.Unlock()\n\tif mock.ReadFunc == nil {\n\t\tvar (\n\t\t\tn int\n\t\t\terr error\n\t\t)\n\t\treturn n, err\n\t}\n\treturn mock.ReadFunc(p)\n}\n\n// ReadCalls gets all the calls that were made to Read.\n// Check the length with:\n//\n//\tlen(mockedMyReader.ReadCalls())\nfunc (mock *MoqMyReader) ReadCalls() []struct {\n\tP []byte\n} {\n\tvar calls []struct {\n\t\tP []byte\n\t}\n\tmock.lockRead.RLock()\n\tcalls = mock.calls.Read\n\tmock.lockRead.RUnlock()\n\treturn calls\n}\n\n// ResetReadCalls reset all the calls that were made to Read.\nfunc (mock *MoqMyReader) ResetReadCalls() {\n\tmock.lockRead.Lock()\n\tmock.calls.Read = nil\n\tmock.lockRead.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqMyReader) ResetCalls() {\n\tmock.lockRead.Lock()\n\tmock.calls.Read = nil\n\tmock.lockRead.Unlock()\n}\n\n// Ensure that MoqIssue766 does implement Issue766.\n// If this is not the case, regenerate this file with mockery.\nvar _ Issue766 = &MoqIssue766{}\n\n// MoqIssue766 is a mock implementation of Issue766.\n//\n//\tfunc TestSomethingThatUsesIssue766(t *testing.T) {\n//\n//\t\t// make and configure a mocked Issue766\n//\t\tmockedIssue766 := &MoqIssue766{\n//\t\t\tFetchDataFunc: func(fetchFunc func(x ...int) ([]int, error)) ([]int, error) {\n//\t\t\t\tpanic(\"mock out the FetchData method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedIssue766 in code that requires Issue766\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqIssue766 struct {\n\t// FetchDataFunc mocks the FetchData method.\n\tFetchDataFunc func(fetchFunc func(x ...int) ([]int, error)) ([]int, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// FetchData holds details about calls to the FetchData method.\n\t\tFetchData []struct {\n\t\t\t// FetchFunc is the fetchFunc argument value.\n\t\t\tFetchFunc func(x ...int) ([]int, error)\n\t\t}\n\t}\n\tlockFetchData sync.RWMutex\n}\n\n// FetchData calls FetchDataFunc.\nfunc (mock *MoqIssue766) FetchData(fetchFunc func(x ...int) ([]int, error)) ([]int, error) {\n\tcallInfo := struct {\n\t\tFetchFunc func(x ...int) ([]int, error)\n\t}{\n\t\tFetchFunc: fetchFunc,\n\t}\n\tmock.lockFetchData.Lock()\n\tmock.calls.FetchData = append(mock.calls.FetchData, callInfo)\n\tmock.lockFetchData.Unlock()\n\tif mock.FetchDataFunc == nil {\n\t\tvar (\n\t\t\tints []int\n\t\t\terr error\n\t\t)\n\t\treturn ints, err\n\t}\n\treturn mock.FetchDataFunc(fetchFunc)\n}\n\n// FetchDataCalls gets all the calls that were made to FetchData.\n// Check the length with:\n//\n//\tlen(mockedIssue766.FetchDataCalls())\nfunc (mock *MoqIssue766) FetchDataCalls() []struct {\n\tFetchFunc func(x ...int) ([]int, error)\n} {\n\tvar calls []struct {\n\t\tFetchFunc func(x ...int) ([]int, error)\n\t}\n\tmock.lockFetchData.RLock()\n\tcalls = mock.calls.FetchData\n\tmock.lockFetchData.RUnlock()\n\treturn calls\n}\n\n// ResetFetchDataCalls reset all the calls that were made to FetchData.\nfunc (mock *MoqIssue766) ResetFetchDataCalls() {\n\tmock.lockFetchData.Lock()\n\tmock.calls.FetchData = nil\n\tmock.lockFetchData.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqIssue766) ResetCalls() {\n\tmock.lockFetchData.Lock()\n\tmock.calls.FetchData = nil\n\tmock.lockFetchData.Unlock()\n}\n\n// Ensure that MoqMapToInterface does implement MapToInterface.\n// If this is not the case, regenerate this file with mockery.\nvar _ MapToInterface = &MoqMapToInterface{}\n\n// MoqMapToInterface is a mock implementation of MapToInterface.\n//\n//\tfunc TestSomethingThatUsesMapToInterface(t *testing.T) {\n//\n//\t\t// make and configure a mocked MapToInterface\n//\t\tmockedMapToInterface := &MoqMapToInterface{\n//\t\t\tFooFunc: func(arg1 ...map[string]interface{}) {\n//\t\t\t\tpanic(\"mock out the Foo method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedMapToInterface in code that requires MapToInterface\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqMapToInterface struct {\n\t// FooFunc mocks the Foo method.\n\tFooFunc func(arg1 ...map[string]interface{})\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Foo holds details about calls to the Foo method.\n\t\tFoo []struct {\n\t\t\t// Arg1 is the arg1 argument value.\n\t\t\tArg1 []map[string]interface{}\n\t\t}\n\t}\n\tlockFoo sync.RWMutex\n}\n\n// Foo calls FooFunc.\nfunc (mock *MoqMapToInterface) Foo(arg1 ...map[string]interface{}) {\n\tcallInfo := struct {\n\t\tArg1 []map[string]interface{}\n\t}{\n\t\tArg1: arg1,\n\t}\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = append(mock.calls.Foo, callInfo)\n\tmock.lockFoo.Unlock()\n\tif mock.FooFunc == nil {\n\t\treturn\n\t}\n\tmock.FooFunc(arg1...)\n}\n\n// FooCalls gets all the calls that were made to Foo.\n// Check the length with:\n//\n//\tlen(mockedMapToInterface.FooCalls())\nfunc (mock *MoqMapToInterface) FooCalls() []struct {\n\tArg1 []map[string]interface{}\n} {\n\tvar calls []struct {\n\t\tArg1 []map[string]interface{}\n\t}\n\tmock.lockFoo.RLock()\n\tcalls = mock.calls.Foo\n\tmock.lockFoo.RUnlock()\n\treturn calls\n}\n\n// ResetFooCalls reset all the calls that were made to Foo.\nfunc (mock *MoqMapToInterface) ResetFooCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqMapToInterface) ResetCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// Ensure that MoqSibling does implement Sibling.\n// If this is not the case, regenerate this file with mockery.\nvar _ Sibling = &MoqSibling{}\n\n// MoqSibling is a mock implementation of Sibling.\n//\n//\tfunc TestSomethingThatUsesSibling(t *testing.T) {\n//\n//\t\t// make and configure a mocked Sibling\n//\t\tmockedSibling := &MoqSibling{\n//\t\t\tDoSomethingFunc: func() {\n//\t\t\t\tpanic(\"mock out the DoSomething method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedSibling in code that requires Sibling\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqSibling struct {\n\t// DoSomethingFunc mocks the DoSomething method.\n\tDoSomethingFunc func()\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// DoSomething holds details about calls to the DoSomething method.\n\t\tDoSomething []struct {\n\t\t}\n\t}\n\tlockDoSomething sync.RWMutex\n}\n\n// DoSomething calls DoSomethingFunc.\nfunc (mock *MoqSibling) DoSomething() {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockDoSomething.Lock()\n\tmock.calls.DoSomething = append(mock.calls.DoSomething, callInfo)\n\tmock.lockDoSomething.Unlock()\n\tif mock.DoSomethingFunc == nil {\n\t\treturn\n\t}\n\tmock.DoSomethingFunc()\n}\n\n// DoSomethingCalls gets all the calls that were made to DoSomething.\n// Check the length with:\n//\n//\tlen(mockedSibling.DoSomethingCalls())\nfunc (mock *MoqSibling) DoSomethingCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockDoSomething.RLock()\n\tcalls = mock.calls.DoSomething\n\tmock.lockDoSomething.RUnlock()\n\treturn calls\n}\n\n// ResetDoSomethingCalls reset all the calls that were made to DoSomething.\nfunc (mock *MoqSibling) ResetDoSomethingCalls() {\n\tmock.lockDoSomething.Lock()\n\tmock.calls.DoSomething = nil\n\tmock.lockDoSomething.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqSibling) ResetCalls() {\n\tmock.lockDoSomething.Lock()\n\tmock.calls.DoSomething = nil\n\tmock.lockDoSomething.Unlock()\n}\n\n// Ensure that MoqUsesOtherPkgIface does implement UsesOtherPkgIface.\n// If this is not the case, regenerate this file with mockery.\nvar _ UsesOtherPkgIface = &MoqUsesOtherPkgIface{}\n\n// MoqUsesOtherPkgIface is a mock implementation of UsesOtherPkgIface.\n//\n//\tfunc TestSomethingThatUsesUsesOtherPkgIface(t *testing.T) {\n//\n//\t\t// make and configure a mocked UsesOtherPkgIface\n//\t\tmockedUsesOtherPkgIface := &MoqUsesOtherPkgIface{\n//\t\t\tDoSomethingElseFunc: func(obj Sibling) {\n//\t\t\t\tpanic(\"mock out the DoSomethingElse method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedUsesOtherPkgIface in code that requires UsesOtherPkgIface\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqUsesOtherPkgIface struct {\n\t// DoSomethingElseFunc mocks the DoSomethingElse method.\n\tDoSomethingElseFunc func(obj Sibling)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// DoSomethingElse holds details about calls to the DoSomethingElse method.\n\t\tDoSomethingElse []struct {\n\t\t\t// Obj is the obj argument value.\n\t\t\tObj Sibling\n\t\t}\n\t}\n\tlockDoSomethingElse sync.RWMutex\n}\n\n// DoSomethingElse calls DoSomethingElseFunc.\nfunc (mock *MoqUsesOtherPkgIface) DoSomethingElse(obj Sibling) {\n\tcallInfo := struct {\n\t\tObj Sibling\n\t}{\n\t\tObj: obj,\n\t}\n\tmock.lockDoSomethingElse.Lock()\n\tmock.calls.DoSomethingElse = append(mock.calls.DoSomethingElse, callInfo)\n\tmock.lockDoSomethingElse.Unlock()\n\tif mock.DoSomethingElseFunc == nil {\n\t\treturn\n\t}\n\tmock.DoSomethingElseFunc(obj)\n}\n\n// DoSomethingElseCalls gets all the calls that were made to DoSomethingElse.\n// Check the length with:\n//\n//\tlen(mockedUsesOtherPkgIface.DoSomethingElseCalls())\nfunc (mock *MoqUsesOtherPkgIface) DoSomethingElseCalls() []struct {\n\tObj Sibling\n} {\n\tvar calls []struct {\n\t\tObj Sibling\n\t}\n\tmock.lockDoSomethingElse.RLock()\n\tcalls = mock.calls.DoSomethingElse\n\tmock.lockDoSomethingElse.RUnlock()\n\treturn calls\n}\n\n// ResetDoSomethingElseCalls reset all the calls that were made to DoSomethingElse.\nfunc (mock *MoqUsesOtherPkgIface) ResetDoSomethingElseCalls() {\n\tmock.lockDoSomethingElse.Lock()\n\tmock.calls.DoSomethingElse = nil\n\tmock.lockDoSomethingElse.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqUsesOtherPkgIface) ResetCalls() {\n\tmock.lockDoSomethingElse.Lock()\n\tmock.calls.DoSomethingElse = nil\n\tmock.lockDoSomethingElse.Unlock()\n}\n\n// Ensure that MoqNilRun does implement NilRun.\n// If this is not the case, regenerate this file with mockery.\nvar _ NilRun = &MoqNilRun{}\n\n// MoqNilRun is a mock implementation of NilRun.\n//\n//\tfunc TestSomethingThatUsesNilRun(t *testing.T) {\n//\n//\t\t// make and configure a mocked NilRun\n//\t\tmockedNilRun := &MoqNilRun{\n//\t\t\tFooFunc: func(nilRun NilRun) {\n//\t\t\t\tpanic(\"mock out the Foo method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedNilRun in code that requires NilRun\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqNilRun struct {\n\t// FooFunc mocks the Foo method.\n\tFooFunc func(nilRun NilRun)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Foo holds details about calls to the Foo method.\n\t\tFoo []struct {\n\t\t\t// NilRun is the nilRun argument value.\n\t\t\tNilRun NilRun\n\t\t}\n\t}\n\tlockFoo sync.RWMutex\n}\n\n// Foo calls FooFunc.\nfunc (mock *MoqNilRun) Foo(nilRun NilRun) {\n\tcallInfo := struct {\n\t\tNilRun NilRun\n\t}{\n\t\tNilRun: nilRun,\n\t}\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = append(mock.calls.Foo, callInfo)\n\tmock.lockFoo.Unlock()\n\tif mock.FooFunc == nil {\n\t\treturn\n\t}\n\tmock.FooFunc(nilRun)\n}\n\n// FooCalls gets all the calls that were made to Foo.\n// Check the length with:\n//\n//\tlen(mockedNilRun.FooCalls())\nfunc (mock *MoqNilRun) FooCalls() []struct {\n\tNilRun NilRun\n} {\n\tvar calls []struct {\n\t\tNilRun NilRun\n\t}\n\tmock.lockFoo.RLock()\n\tcalls = mock.calls.Foo\n\tmock.lockFoo.RUnlock()\n\treturn calls\n}\n\n// ResetFooCalls reset all the calls that were made to Foo.\nfunc (mock *MoqNilRun) ResetFooCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqNilRun) ResetCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// Ensure that MoqPanicOnNoReturnValue does implement PanicOnNoReturnValue.\n// If this is not the case, regenerate this file with mockery.\nvar _ PanicOnNoReturnValue = &MoqPanicOnNoReturnValue{}\n\n// MoqPanicOnNoReturnValue is a mock implementation of PanicOnNoReturnValue.\n//\n//\tfunc TestSomethingThatUsesPanicOnNoReturnValue(t *testing.T) {\n//\n//\t\t// make and configure a mocked PanicOnNoReturnValue\n//\t\tmockedPanicOnNoReturnValue := &MoqPanicOnNoReturnValue{\n//\t\t\tDoSomethingFunc: func() string {\n//\t\t\t\tpanic(\"mock out the DoSomething method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedPanicOnNoReturnValue in code that requires PanicOnNoReturnValue\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqPanicOnNoReturnValue struct {\n\t// DoSomethingFunc mocks the DoSomething method.\n\tDoSomethingFunc func() string\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// DoSomething holds details about calls to the DoSomething method.\n\t\tDoSomething []struct {\n\t\t}\n\t}\n\tlockDoSomething sync.RWMutex\n}\n\n// DoSomething calls DoSomethingFunc.\nfunc (mock *MoqPanicOnNoReturnValue) DoSomething() string {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockDoSomething.Lock()\n\tmock.calls.DoSomething = append(mock.calls.DoSomething, callInfo)\n\tmock.lockDoSomething.Unlock()\n\tif mock.DoSomethingFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t)\n\t\treturn s\n\t}\n\treturn mock.DoSomethingFunc()\n}\n\n// DoSomethingCalls gets all the calls that were made to DoSomething.\n// Check the length with:\n//\n//\tlen(mockedPanicOnNoReturnValue.DoSomethingCalls())\nfunc (mock *MoqPanicOnNoReturnValue) DoSomethingCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockDoSomething.RLock()\n\tcalls = mock.calls.DoSomething\n\tmock.lockDoSomething.RUnlock()\n\treturn calls\n}\n\n// ResetDoSomethingCalls reset all the calls that were made to DoSomething.\nfunc (mock *MoqPanicOnNoReturnValue) ResetDoSomethingCalls() {\n\tmock.lockDoSomething.Lock()\n\tmock.calls.DoSomething = nil\n\tmock.lockDoSomething.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqPanicOnNoReturnValue) ResetCalls() {\n\tmock.lockDoSomething.Lock()\n\tmock.calls.DoSomething = nil\n\tmock.lockDoSomething.Unlock()\n}\n\n// MoqRequesterSkipEnsure is a mock implementation of Requester.\n//\n//\tfunc TestSomethingThatUsesRequester(t *testing.T) {\n//\n//\t\t// make and configure a mocked Requester\n//\t\tmockedRequester := &MoqRequesterSkipEnsure{\n//\t\t\tGetFunc: func(path string) (string, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequester in code that requires Requester\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterSkipEnsure struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) (string, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterSkipEnsure) Get(path string) (string, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t\terr error\n\t\t)\n\t\treturn s, err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequester.GetCalls())\nfunc (mock *MoqRequesterSkipEnsure) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterSkipEnsure) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterSkipEnsure) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequester does implement Requester.\n// If this is not the case, regenerate this file with mockery.\nvar _ Requester = &MoqRequester{}\n\n// MoqRequester is a mock implementation of Requester.\n//\n//\tfunc TestSomethingThatUsesRequester(t *testing.T) {\n//\n//\t\t// make and configure a mocked Requester\n//\t\tmockedRequester := &MoqRequester{\n//\t\t\tGetFunc: func(path string) (string, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequester in code that requires Requester\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequester struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) (string, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequester) Get(path string) (string, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t\terr error\n\t\t)\n\t\treturn s, err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequester.GetCalls())\nfunc (mock *MoqRequester) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequester) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequester) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that StubMatyerRequester does implement Requester.\n// If this is not the case, regenerate this file with mockery.\nvar _ Requester = &StubMatyerRequester{}\n\n// StubMatyerRequester is a mock implementation of Requester.\n//\n//\tfunc TestSomethingThatUsesRequester(t *testing.T) {\n//\n//\t\t// make and configure a mocked Requester\n//\t\tmockedRequester := &StubMatyerRequester{\n//\t\t\tGetFunc: func(path string) (string, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequester in code that requires Requester\n//\t\t// and then make assertions.\n//\n//\t}\ntype StubMatyerRequester struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) (string, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *StubMatyerRequester) Get(path string) (string, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t\terr error\n\t\t)\n\t\treturn s, err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequester.GetCalls())\nfunc (mock *StubMatyerRequester) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *StubMatyerRequester) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *StubMatyerRequester) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequester2 does implement Requester2.\n// If this is not the case, regenerate this file with mockery.\nvar _ Requester2 = &MoqRequester2{}\n\n// MoqRequester2 is a mock implementation of Requester2.\n//\n//\tfunc TestSomethingThatUsesRequester2(t *testing.T) {\n//\n//\t\t// make and configure a mocked Requester2\n//\t\tmockedRequester2 := &MoqRequester2{\n//\t\t\tGetFunc: func(path string) error {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequester2 in code that requires Requester2\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequester2 struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequester2) Get(path string) error {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequester2.GetCalls())\nfunc (mock *MoqRequester2) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequester2) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequester2) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequester3 does implement Requester3.\n// If this is not the case, regenerate this file with mockery.\nvar _ Requester3 = &MoqRequester3{}\n\n// MoqRequester3 is a mock implementation of Requester3.\n//\n//\tfunc TestSomethingThatUsesRequester3(t *testing.T) {\n//\n//\t\t// make and configure a mocked Requester3\n//\t\tmockedRequester3 := &MoqRequester3{\n//\t\t\tGetFunc: func() error {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequester3 in code that requires Requester3\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequester3 struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func() error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequester3) Get() error {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.GetFunc()\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequester3.GetCalls())\nfunc (mock *MoqRequester3) GetCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequester3) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequester3) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequester4 does implement Requester4.\n// If this is not the case, regenerate this file with mockery.\nvar _ Requester4 = &MoqRequester4{}\n\n// MoqRequester4 is a mock implementation of Requester4.\n//\n//\tfunc TestSomethingThatUsesRequester4(t *testing.T) {\n//\n//\t\t// make and configure a mocked Requester4\n//\t\tmockedRequester4 := &MoqRequester4{\n//\t\t\tGetFunc: func() {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequester4 in code that requires Requester4\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequester4 struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func()\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequester4) Get() {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\treturn\n\t}\n\tmock.GetFunc()\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequester4.GetCalls())\nfunc (mock *MoqRequester4) GetCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequester4) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequester4) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterArgSameAsImport does implement RequesterArgSameAsImport.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterArgSameAsImport = &MoqRequesterArgSameAsImport{}\n\n// MoqRequesterArgSameAsImport is a mock implementation of RequesterArgSameAsImport.\n//\n//\tfunc TestSomethingThatUsesRequesterArgSameAsImport(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterArgSameAsImport\n//\t\tmockedRequesterArgSameAsImport := &MoqRequesterArgSameAsImport{\n//\t\t\tGetFunc: func(json1 string) *json.RawMessage {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterArgSameAsImport in code that requires RequesterArgSameAsImport\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterArgSameAsImport struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(json1 string) *json.RawMessage\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Json1 is the json1 argument value.\n\t\t\tJson1 string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterArgSameAsImport) Get(json1 string) *json.RawMessage {\n\tcallInfo := struct {\n\t\tJson1 string\n\t}{\n\t\tJson1: json1,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\trawMessage *json.RawMessage\n\t\t)\n\t\treturn rawMessage\n\t}\n\treturn mock.GetFunc(json1)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterArgSameAsImport.GetCalls())\nfunc (mock *MoqRequesterArgSameAsImport) GetCalls() []struct {\n\tJson1 string\n} {\n\tvar calls []struct {\n\t\tJson1 string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterArgSameAsImport) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterArgSameAsImport) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterArgSameAsNamedImport does implement RequesterArgSameAsNamedImport.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterArgSameAsNamedImport = &MoqRequesterArgSameAsNamedImport{}\n\n// MoqRequesterArgSameAsNamedImport is a mock implementation of RequesterArgSameAsNamedImport.\n//\n//\tfunc TestSomethingThatUsesRequesterArgSameAsNamedImport(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterArgSameAsNamedImport\n//\t\tmockedRequesterArgSameAsNamedImport := &MoqRequesterArgSameAsNamedImport{\n//\t\t\tGetFunc: func(json1 string) *json.RawMessage {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterArgSameAsNamedImport in code that requires RequesterArgSameAsNamedImport\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterArgSameAsNamedImport struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(json1 string) *json.RawMessage\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Json1 is the json1 argument value.\n\t\t\tJson1 string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterArgSameAsNamedImport) Get(json1 string) *json.RawMessage {\n\tcallInfo := struct {\n\t\tJson1 string\n\t}{\n\t\tJson1: json1,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\trawMessage *json.RawMessage\n\t\t)\n\t\treturn rawMessage\n\t}\n\treturn mock.GetFunc(json1)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterArgSameAsNamedImport.GetCalls())\nfunc (mock *MoqRequesterArgSameAsNamedImport) GetCalls() []struct {\n\tJson1 string\n} {\n\tvar calls []struct {\n\t\tJson1 string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterArgSameAsNamedImport) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterArgSameAsNamedImport) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterArgSameAsPkg does implement RequesterArgSameAsPkg.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterArgSameAsPkg = &MoqRequesterArgSameAsPkg{}\n\n// MoqRequesterArgSameAsPkg is a mock implementation of RequesterArgSameAsPkg.\n//\n//\tfunc TestSomethingThatUsesRequesterArgSameAsPkg(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterArgSameAsPkg\n//\t\tmockedRequesterArgSameAsPkg := &MoqRequesterArgSameAsPkg{\n//\t\t\tGetFunc: func(test1 string) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterArgSameAsPkg in code that requires RequesterArgSameAsPkg\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterArgSameAsPkg struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(test1 string)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Test1 is the test1 argument value.\n\t\t\tTest1 string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterArgSameAsPkg) Get(test1 string) {\n\tcallInfo := struct {\n\t\tTest1 string\n\t}{\n\t\tTest1: test1,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\treturn\n\t}\n\tmock.GetFunc(test1)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterArgSameAsPkg.GetCalls())\nfunc (mock *MoqRequesterArgSameAsPkg) GetCalls() []struct {\n\tTest1 string\n} {\n\tvar calls []struct {\n\t\tTest1 string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterArgSameAsPkg) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterArgSameAsPkg) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterArray does implement RequesterArray.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterArray = &MoqRequesterArray{}\n\n// MoqRequesterArray is a mock implementation of RequesterArray.\n//\n//\tfunc TestSomethingThatUsesRequesterArray(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterArray\n//\t\tmockedRequesterArray := &MoqRequesterArray{\n//\t\t\tGetFunc: func(path string) ([2]string, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterArray in code that requires RequesterArray\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterArray struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) ([2]string, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterArray) Get(path string) ([2]string, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\tstrings [2]string\n\t\t\terr error\n\t\t)\n\t\treturn strings, err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterArray.GetCalls())\nfunc (mock *MoqRequesterArray) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterArray) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterArray) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterElided does implement RequesterElided.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterElided = &MoqRequesterElided{}\n\n// MoqRequesterElided is a mock implementation of RequesterElided.\n//\n//\tfunc TestSomethingThatUsesRequesterElided(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterElided\n//\t\tmockedRequesterElided := &MoqRequesterElided{\n//\t\t\tGetFunc: func(path string, url string) error {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterElided in code that requires RequesterElided\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterElided struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string, url string) error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t\t// URL is the url argument value.\n\t\t\tURL string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterElided) Get(path string, url string) error {\n\tcallInfo := struct {\n\t\tPath string\n\t\tURL string\n\t}{\n\t\tPath: path,\n\t\tURL: url,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.GetFunc(path, url)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterElided.GetCalls())\nfunc (mock *MoqRequesterElided) GetCalls() []struct {\n\tPath string\n\tURL string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t\tURL string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterElided) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterElided) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterIface does implement RequesterIface.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterIface = &MoqRequesterIface{}\n\n// MoqRequesterIface is a mock implementation of RequesterIface.\n//\n//\tfunc TestSomethingThatUsesRequesterIface(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterIface\n//\t\tmockedRequesterIface := &MoqRequesterIface{\n//\t\t\tGetFunc: func() io.Reader {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterIface in code that requires RequesterIface\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterIface struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func() io.Reader\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterIface) Get() io.Reader {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\treader io.Reader\n\t\t)\n\t\treturn reader\n\t}\n\treturn mock.GetFunc()\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterIface.GetCalls())\nfunc (mock *MoqRequesterIface) GetCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterIface) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterIface) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterNS does implement RequesterNS.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterNS = &MoqRequesterNS{}\n\n// MoqRequesterNS is a mock implementation of RequesterNS.\n//\n//\tfunc TestSomethingThatUsesRequesterNS(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterNS\n//\t\tmockedRequesterNS := &MoqRequesterNS{\n//\t\t\tGetFunc: func(path string) (http.Response, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterNS in code that requires RequesterNS\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterNS struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) (http.Response, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterNS) Get(path string) (http.Response, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\tresponse http.Response\n\t\t\terr error\n\t\t)\n\t\treturn response, err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterNS.GetCalls())\nfunc (mock *MoqRequesterNS) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterNS) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterNS) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterPtr does implement RequesterPtr.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterPtr = &MoqRequesterPtr{}\n\n// MoqRequesterPtr is a mock implementation of RequesterPtr.\n//\n//\tfunc TestSomethingThatUsesRequesterPtr(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterPtr\n//\t\tmockedRequesterPtr := &MoqRequesterPtr{\n//\t\t\tGetFunc: func(path string) (*string, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterPtr in code that requires RequesterPtr\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterPtr struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) (*string, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterPtr) Get(path string) (*string, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\ts *string\n\t\t\terr error\n\t\t)\n\t\treturn s, err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterPtr.GetCalls())\nfunc (mock *MoqRequesterPtr) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterPtr) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterPtr) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterReturnElided does implement RequesterReturnElided.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterReturnElided = &MoqRequesterReturnElided{}\n\n// MoqRequesterReturnElided is a mock implementation of RequesterReturnElided.\n//\n//\tfunc TestSomethingThatUsesRequesterReturnElided(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterReturnElided\n//\t\tmockedRequesterReturnElided := &MoqRequesterReturnElided{\n//\t\t\tGetFunc: func(path string) (int, int, int, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t\tPutFunc: func(path string) (int, error) {\n//\t\t\t\tpanic(\"mock out the Put method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterReturnElided in code that requires RequesterReturnElided\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterReturnElided struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) (int, int, int, error)\n\n\t// PutFunc mocks the Put method.\n\tPutFunc func(path string) (int, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t\t// Put holds details about calls to the Put method.\n\t\tPut []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n\tlockPut sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterReturnElided) Get(path string) (int, int, int, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\ta int\n\t\t\tb int\n\t\t\tc int\n\t\t\terr error\n\t\t)\n\t\treturn a, b, c, err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterReturnElided.GetCalls())\nfunc (mock *MoqRequesterReturnElided) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterReturnElided) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Put calls PutFunc.\nfunc (mock *MoqRequesterReturnElided) Put(path string) (int, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockPut.Lock()\n\tmock.calls.Put = append(mock.calls.Put, callInfo)\n\tmock.lockPut.Unlock()\n\tif mock.PutFunc == nil {\n\t\tvar (\n\t\t\tn int\n\t\t\terr error\n\t\t)\n\t\treturn n, err\n\t}\n\treturn mock.PutFunc(path)\n}\n\n// PutCalls gets all the calls that were made to Put.\n// Check the length with:\n//\n//\tlen(mockedRequesterReturnElided.PutCalls())\nfunc (mock *MoqRequesterReturnElided) PutCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockPut.RLock()\n\tcalls = mock.calls.Put\n\tmock.lockPut.RUnlock()\n\treturn calls\n}\n\n// ResetPutCalls reset all the calls that were made to Put.\nfunc (mock *MoqRequesterReturnElided) ResetPutCalls() {\n\tmock.lockPut.Lock()\n\tmock.calls.Put = nil\n\tmock.lockPut.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterReturnElided) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n\n\tmock.lockPut.Lock()\n\tmock.calls.Put = nil\n\tmock.lockPut.Unlock()\n}\n\n// Ensure that MoqRequesterSlice does implement RequesterSlice.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterSlice = &MoqRequesterSlice{}\n\n// MoqRequesterSlice is a mock implementation of RequesterSlice.\n//\n//\tfunc TestSomethingThatUsesRequesterSlice(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterSlice\n//\t\tmockedRequesterSlice := &MoqRequesterSlice{\n//\t\t\tGetFunc: func(path string) ([]string, error) {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterSlice in code that requires RequesterSlice\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterSlice struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(path string) ([]string, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Path is the path argument value.\n\t\t\tPath string\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterSlice) Get(path string) ([]string, error) {\n\tcallInfo := struct {\n\t\tPath string\n\t}{\n\t\tPath: path,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\tstrings []string\n\t\t\terr error\n\t\t)\n\t\treturn strings, err\n\t}\n\treturn mock.GetFunc(path)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterSlice.GetCalls())\nfunc (mock *MoqRequesterSlice) GetCalls() []struct {\n\tPath string\n} {\n\tvar calls []struct {\n\t\tPath string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterSlice) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterSlice) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqrequesterUnexported does implement requesterUnexported.\n// If this is not the case, regenerate this file with mockery.\nvar _ requesterUnexported = &MoqrequesterUnexported{}\n\n// MoqrequesterUnexported is a mock implementation of requesterUnexported.\n//\n//\tfunc TestSomethingThatUsesrequesterUnexported(t *testing.T) {\n//\n//\t\t// make and configure a mocked requesterUnexported\n//\t\tmockedrequesterUnexported := &MoqrequesterUnexported{\n//\t\t\tGetFunc: func() {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedrequesterUnexported in code that requires requesterUnexported\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqrequesterUnexported struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func()\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqrequesterUnexported) Get() {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\treturn\n\t}\n\tmock.GetFunc()\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedrequesterUnexported.GetCalls())\nfunc (mock *MoqrequesterUnexported) GetCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqrequesterUnexported) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqrequesterUnexported) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// Ensure that MoqRequesterVariadic does implement RequesterVariadic.\n// If this is not the case, regenerate this file with mockery.\nvar _ RequesterVariadic = &MoqRequesterVariadic{}\n\n// MoqRequesterVariadic is a mock implementation of RequesterVariadic.\n//\n//\tfunc TestSomethingThatUsesRequesterVariadic(t *testing.T) {\n//\n//\t\t// make and configure a mocked RequesterVariadic\n//\t\tmockedRequesterVariadic := &MoqRequesterVariadic{\n//\t\t\tGetFunc: func(values ...string) bool {\n//\t\t\t\tpanic(\"mock out the Get method\")\n//\t\t\t},\n//\t\t\tMultiWriteToFileFunc: func(filename string, w ...io.Writer) string {\n//\t\t\t\tpanic(\"mock out the MultiWriteToFile method\")\n//\t\t\t},\n//\t\t\tOneInterfaceFunc: func(a ...interface{}) bool {\n//\t\t\t\tpanic(\"mock out the OneInterface method\")\n//\t\t\t},\n//\t\t\tSprintfFunc: func(format string, a ...interface{}) string {\n//\t\t\t\tpanic(\"mock out the Sprintf method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedRequesterVariadic in code that requires RequesterVariadic\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqRequesterVariadic struct {\n\t// GetFunc mocks the Get method.\n\tGetFunc func(values ...string) bool\n\n\t// MultiWriteToFileFunc mocks the MultiWriteToFile method.\n\tMultiWriteToFileFunc func(filename string, w ...io.Writer) string\n\n\t// OneInterfaceFunc mocks the OneInterface method.\n\tOneInterfaceFunc func(a ...interface{}) bool\n\n\t// SprintfFunc mocks the Sprintf method.\n\tSprintfFunc func(format string, a ...interface{}) string\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Get holds details about calls to the Get method.\n\t\tGet []struct {\n\t\t\t// Values is the values argument value.\n\t\t\tValues []string\n\t\t}\n\t\t// MultiWriteToFile holds details about calls to the MultiWriteToFile method.\n\t\tMultiWriteToFile []struct {\n\t\t\t// Filename is the filename argument value.\n\t\t\tFilename string\n\t\t\t// W is the w argument value.\n\t\t\tW []io.Writer\n\t\t}\n\t\t// OneInterface holds details about calls to the OneInterface method.\n\t\tOneInterface []struct {\n\t\t\t// A is the a argument value.\n\t\t\tA []interface{}\n\t\t}\n\t\t// Sprintf holds details about calls to the Sprintf method.\n\t\tSprintf []struct {\n\t\t\t// Format is the format argument value.\n\t\t\tFormat string\n\t\t\t// A is the a argument value.\n\t\t\tA []interface{}\n\t\t}\n\t}\n\tlockGet sync.RWMutex\n\tlockMultiWriteToFile sync.RWMutex\n\tlockOneInterface sync.RWMutex\n\tlockSprintf sync.RWMutex\n}\n\n// Get calls GetFunc.\nfunc (mock *MoqRequesterVariadic) Get(values ...string) bool {\n\tcallInfo := struct {\n\t\tValues []string\n\t}{\n\t\tValues: values,\n\t}\n\tmock.lockGet.Lock()\n\tmock.calls.Get = append(mock.calls.Get, callInfo)\n\tmock.lockGet.Unlock()\n\tif mock.GetFunc == nil {\n\t\tvar (\n\t\t\tb bool\n\t\t)\n\t\treturn b\n\t}\n\treturn mock.GetFunc(values...)\n}\n\n// GetCalls gets all the calls that were made to Get.\n// Check the length with:\n//\n//\tlen(mockedRequesterVariadic.GetCalls())\nfunc (mock *MoqRequesterVariadic) GetCalls() []struct {\n\tValues []string\n} {\n\tvar calls []struct {\n\t\tValues []string\n\t}\n\tmock.lockGet.RLock()\n\tcalls = mock.calls.Get\n\tmock.lockGet.RUnlock()\n\treturn calls\n}\n\n// ResetGetCalls reset all the calls that were made to Get.\nfunc (mock *MoqRequesterVariadic) ResetGetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n}\n\n// MultiWriteToFile calls MultiWriteToFileFunc.\nfunc (mock *MoqRequesterVariadic) MultiWriteToFile(filename string, w ...io.Writer) string {\n\tcallInfo := struct {\n\t\tFilename string\n\t\tW []io.Writer\n\t}{\n\t\tFilename: filename,\n\t\tW: w,\n\t}\n\tmock.lockMultiWriteToFile.Lock()\n\tmock.calls.MultiWriteToFile = append(mock.calls.MultiWriteToFile, callInfo)\n\tmock.lockMultiWriteToFile.Unlock()\n\tif mock.MultiWriteToFileFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t)\n\t\treturn s\n\t}\n\treturn mock.MultiWriteToFileFunc(filename, w...)\n}\n\n// MultiWriteToFileCalls gets all the calls that were made to MultiWriteToFile.\n// Check the length with:\n//\n//\tlen(mockedRequesterVariadic.MultiWriteToFileCalls())\nfunc (mock *MoqRequesterVariadic) MultiWriteToFileCalls() []struct {\n\tFilename string\n\tW []io.Writer\n} {\n\tvar calls []struct {\n\t\tFilename string\n\t\tW []io.Writer\n\t}\n\tmock.lockMultiWriteToFile.RLock()\n\tcalls = mock.calls.MultiWriteToFile\n\tmock.lockMultiWriteToFile.RUnlock()\n\treturn calls\n}\n\n// ResetMultiWriteToFileCalls reset all the calls that were made to MultiWriteToFile.\nfunc (mock *MoqRequesterVariadic) ResetMultiWriteToFileCalls() {\n\tmock.lockMultiWriteToFile.Lock()\n\tmock.calls.MultiWriteToFile = nil\n\tmock.lockMultiWriteToFile.Unlock()\n}\n\n// OneInterface calls OneInterfaceFunc.\nfunc (mock *MoqRequesterVariadic) OneInterface(a ...interface{}) bool {\n\tcallInfo := struct {\n\t\tA []interface{}\n\t}{\n\t\tA: a,\n\t}\n\tmock.lockOneInterface.Lock()\n\tmock.calls.OneInterface = append(mock.calls.OneInterface, callInfo)\n\tmock.lockOneInterface.Unlock()\n\tif mock.OneInterfaceFunc == nil {\n\t\tvar (\n\t\t\tb bool\n\t\t)\n\t\treturn b\n\t}\n\treturn mock.OneInterfaceFunc(a...)\n}\n\n// OneInterfaceCalls gets all the calls that were made to OneInterface.\n// Check the length with:\n//\n//\tlen(mockedRequesterVariadic.OneInterfaceCalls())\nfunc (mock *MoqRequesterVariadic) OneInterfaceCalls() []struct {\n\tA []interface{}\n} {\n\tvar calls []struct {\n\t\tA []interface{}\n\t}\n\tmock.lockOneInterface.RLock()\n\tcalls = mock.calls.OneInterface\n\tmock.lockOneInterface.RUnlock()\n\treturn calls\n}\n\n// ResetOneInterfaceCalls reset all the calls that were made to OneInterface.\nfunc (mock *MoqRequesterVariadic) ResetOneInterfaceCalls() {\n\tmock.lockOneInterface.Lock()\n\tmock.calls.OneInterface = nil\n\tmock.lockOneInterface.Unlock()\n}\n\n// Sprintf calls SprintfFunc.\nfunc (mock *MoqRequesterVariadic) Sprintf(format string, a ...interface{}) string {\n\tcallInfo := struct {\n\t\tFormat string\n\t\tA []interface{}\n\t}{\n\t\tFormat: format,\n\t\tA: a,\n\t}\n\tmock.lockSprintf.Lock()\n\tmock.calls.Sprintf = append(mock.calls.Sprintf, callInfo)\n\tmock.lockSprintf.Unlock()\n\tif mock.SprintfFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t)\n\t\treturn s\n\t}\n\treturn mock.SprintfFunc(format, a...)\n}\n\n// SprintfCalls gets all the calls that were made to Sprintf.\n// Check the length with:\n//\n//\tlen(mockedRequesterVariadic.SprintfCalls())\nfunc (mock *MoqRequesterVariadic) SprintfCalls() []struct {\n\tFormat string\n\tA []interface{}\n} {\n\tvar calls []struct {\n\t\tFormat string\n\t\tA []interface{}\n\t}\n\tmock.lockSprintf.RLock()\n\tcalls = mock.calls.Sprintf\n\tmock.lockSprintf.RUnlock()\n\treturn calls\n}\n\n// ResetSprintfCalls reset all the calls that were made to Sprintf.\nfunc (mock *MoqRequesterVariadic) ResetSprintfCalls() {\n\tmock.lockSprintf.Lock()\n\tmock.calls.Sprintf = nil\n\tmock.lockSprintf.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqRequesterVariadic) ResetCalls() {\n\tmock.lockGet.Lock()\n\tmock.calls.Get = nil\n\tmock.lockGet.Unlock()\n\n\tmock.lockMultiWriteToFile.Lock()\n\tmock.calls.MultiWriteToFile = nil\n\tmock.lockMultiWriteToFile.Unlock()\n\n\tmock.lockOneInterface.Lock()\n\tmock.calls.OneInterface = nil\n\tmock.lockOneInterface.Unlock()\n\n\tmock.lockSprintf.Lock()\n\tmock.calls.Sprintf = nil\n\tmock.lockSprintf.Unlock()\n}\n\n// Ensure that MoqExample does implement Example.\n// If this is not the case, regenerate this file with mockery.\nvar _ Example = &MoqExample{}\n\n// MoqExample is a mock implementation of Example.\n//\n//\tfunc TestSomethingThatUsesExample(t *testing.T) {\n//\n//\t\t// make and configure a mocked Example\n//\t\tmockedExample := &MoqExample{\n//\t\t\tAFunc: func() http.Flusher {\n//\t\t\t\tpanic(\"mock out the A method\")\n//\t\t\t},\n//\t\t\tBFunc: func(fixtureshttp string) http0.MyStruct {\n//\t\t\t\tpanic(\"mock out the B method\")\n//\t\t\t},\n//\t\t\tCFunc: func(fixtureshttp string) http1.MyStruct {\n//\t\t\t\tpanic(\"mock out the C method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedExample in code that requires Example\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqExample struct {\n\t// AFunc mocks the A method.\n\tAFunc func() http.Flusher\n\n\t// BFunc mocks the B method.\n\tBFunc func(fixtureshttp string) http0.MyStruct\n\n\t// CFunc mocks the C method.\n\tCFunc func(fixtureshttp string) http1.MyStruct\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// A holds details about calls to the A method.\n\t\tA []struct {\n\t\t}\n\t\t// B holds details about calls to the B method.\n\t\tB []struct {\n\t\t\t// Fixtureshttp is the fixtureshttp argument value.\n\t\t\tFixtureshttp string\n\t\t}\n\t\t// C holds details about calls to the C method.\n\t\tC []struct {\n\t\t\t// Fixtureshttp is the fixtureshttp argument value.\n\t\t\tFixtureshttp string\n\t\t}\n\t}\n\tlockA sync.RWMutex\n\tlockB sync.RWMutex\n\tlockC sync.RWMutex\n}\n\n// A calls AFunc.\nfunc (mock *MoqExample) A() http.Flusher {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockA.Lock()\n\tmock.calls.A = append(mock.calls.A, callInfo)\n\tmock.lockA.Unlock()\n\tif mock.AFunc == nil {\n\t\tvar (\n\t\t\tflusher http.Flusher\n\t\t)\n\t\treturn flusher\n\t}\n\treturn mock.AFunc()\n}\n\n// ACalls gets all the calls that were made to A.\n// Check the length with:\n//\n//\tlen(mockedExample.ACalls())\nfunc (mock *MoqExample) ACalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockA.RLock()\n\tcalls = mock.calls.A\n\tmock.lockA.RUnlock()\n\treturn calls\n}\n\n// ResetACalls reset all the calls that were made to A.\nfunc (mock *MoqExample) ResetACalls() {\n\tmock.lockA.Lock()\n\tmock.calls.A = nil\n\tmock.lockA.Unlock()\n}\n\n// B calls BFunc.\nfunc (mock *MoqExample) B(fixtureshttp string) http0.MyStruct {\n\tcallInfo := struct {\n\t\tFixtureshttp string\n\t}{\n\t\tFixtureshttp: fixtureshttp,\n\t}\n\tmock.lockB.Lock()\n\tmock.calls.B = append(mock.calls.B, callInfo)\n\tmock.lockB.Unlock()\n\tif mock.BFunc == nil {\n\t\tvar (\n\t\t\tmyStruct http0.MyStruct\n\t\t)\n\t\treturn myStruct\n\t}\n\treturn mock.BFunc(fixtureshttp)\n}\n\n// BCalls gets all the calls that were made to B.\n// Check the length with:\n//\n//\tlen(mockedExample.BCalls())\nfunc (mock *MoqExample) BCalls() []struct {\n\tFixtureshttp string\n} {\n\tvar calls []struct {\n\t\tFixtureshttp string\n\t}\n\tmock.lockB.RLock()\n\tcalls = mock.calls.B\n\tmock.lockB.RUnlock()\n\treturn calls\n}\n\n// ResetBCalls reset all the calls that were made to B.\nfunc (mock *MoqExample) ResetBCalls() {\n\tmock.lockB.Lock()\n\tmock.calls.B = nil\n\tmock.lockB.Unlock()\n}\n\n// C calls CFunc.\nfunc (mock *MoqExample) C(fixtureshttp string) http1.MyStruct {\n\tcallInfo := struct {\n\t\tFixtureshttp string\n\t}{\n\t\tFixtureshttp: fixtureshttp,\n\t}\n\tmock.lockC.Lock()\n\tmock.calls.C = append(mock.calls.C, callInfo)\n\tmock.lockC.Unlock()\n\tif mock.CFunc == nil {\n\t\tvar (\n\t\t\tmyStruct http1.MyStruct\n\t\t)\n\t\treturn myStruct\n\t}\n\treturn mock.CFunc(fixtureshttp)\n}\n\n// CCalls gets all the calls that were made to C.\n// Check the length with:\n//\n//\tlen(mockedExample.CCalls())\nfunc (mock *MoqExample) CCalls() []struct {\n\tFixtureshttp string\n} {\n\tvar calls []struct {\n\t\tFixtureshttp string\n\t}\n\tmock.lockC.RLock()\n\tcalls = mock.calls.C\n\tmock.lockC.RUnlock()\n\treturn calls\n}\n\n// ResetCCalls reset all the calls that were made to C.\nfunc (mock *MoqExample) ResetCCalls() {\n\tmock.lockC.Lock()\n\tmock.calls.C = nil\n\tmock.lockC.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqExample) ResetCalls() {\n\tmock.lockA.Lock()\n\tmock.calls.A = nil\n\tmock.lockA.Unlock()\n\n\tmock.lockB.Lock()\n\tmock.calls.B = nil\n\tmock.lockB.Unlock()\n\n\tmock.lockC.Lock()\n\tmock.calls.C = nil\n\tmock.lockC.Unlock()\n}\n\n// Ensure that MoqA does implement A.\n// If this is not the case, regenerate this file with mockery.\nvar _ A = &MoqA{}\n\n// MoqA is a mock implementation of A.\n//\n//\tfunc TestSomethingThatUsesA(t *testing.T) {\n//\n//\t\t// make and configure a mocked A\n//\t\tmockedA := &MoqA{\n//\t\t\tCallFunc: func() (B, error) {\n//\t\t\t\tpanic(\"mock out the Call method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedA in code that requires A\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqA struct {\n\t// CallFunc mocks the Call method.\n\tCallFunc func() (B, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Call holds details about calls to the Call method.\n\t\tCall []struct {\n\t\t}\n\t}\n\tlockCall sync.RWMutex\n}\n\n// Call calls CallFunc.\nfunc (mock *MoqA) Call() (B, error) {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockCall.Lock()\n\tmock.calls.Call = append(mock.calls.Call, callInfo)\n\tmock.lockCall.Unlock()\n\tif mock.CallFunc == nil {\n\t\tvar (\n\t\t\tb B\n\t\t\terr error\n\t\t)\n\t\treturn b, err\n\t}\n\treturn mock.CallFunc()\n}\n\n// CallCalls gets all the calls that were made to Call.\n// Check the length with:\n//\n//\tlen(mockedA.CallCalls())\nfunc (mock *MoqA) CallCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockCall.RLock()\n\tcalls = mock.calls.Call\n\tmock.lockCall.RUnlock()\n\treturn calls\n}\n\n// ResetCallCalls reset all the calls that were made to Call.\nfunc (mock *MoqA) ResetCallCalls() {\n\tmock.lockCall.Lock()\n\tmock.calls.Call = nil\n\tmock.lockCall.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqA) ResetCalls() {\n\tmock.lockCall.Lock()\n\tmock.calls.Call = nil\n\tmock.lockCall.Unlock()\n}\n\n// Ensure that MoqStructWithTag does implement StructWithTag.\n// If this is not the case, regenerate this file with mockery.\nvar _ StructWithTag = &MoqStructWithTag{}\n\n// MoqStructWithTag is a mock implementation of StructWithTag.\n//\n//\tfunc TestSomethingThatUsesStructWithTag(t *testing.T) {\n//\n//\t\t// make and configure a mocked StructWithTag\n//\t\tmockedStructWithTag := &MoqStructWithTag{\n//\t\t\tMethodAFunc: func(v *struct{FieldA int \"json:\\\"field_a\\\"\"; FieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"}) *struct{FieldC int \"json:\\\"field_c\\\"\"; FieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"} {\n//\t\t\t\tpanic(\"mock out the MethodA method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedStructWithTag in code that requires StructWithTag\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqStructWithTag struct {\n\t// MethodAFunc mocks the MethodA method.\n\tMethodAFunc func(v *struct {\n\t\tFieldA int \"json:\\\"field_a\\\"\"\n\t\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n\t}) *struct {\n\t\tFieldC int \"json:\\\"field_c\\\"\"\n\t\tFieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"\n\t}\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// MethodA holds details about calls to the MethodA method.\n\t\tMethodA []struct {\n\t\t\t// V is the v argument value.\n\t\t\tV *struct {\n\t\t\t\tFieldA int \"json:\\\"field_a\\\"\"\n\t\t\t\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n\t\t\t}\n\t\t}\n\t}\n\tlockMethodA sync.RWMutex\n}\n\n// MethodA calls MethodAFunc.\nfunc (mock *MoqStructWithTag) MethodA(v *struct {\n\tFieldA int \"json:\\\"field_a\\\"\"\n\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n}) *struct {\n\tFieldC int \"json:\\\"field_c\\\"\"\n\tFieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"\n} {\n\tcallInfo := struct {\n\t\tV *struct {\n\t\t\tFieldA int \"json:\\\"field_a\\\"\"\n\t\t\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n\t\t}\n\t}{\n\t\tV: v,\n\t}\n\tmock.lockMethodA.Lock()\n\tmock.calls.MethodA = append(mock.calls.MethodA, callInfo)\n\tmock.lockMethodA.Unlock()\n\tif mock.MethodAFunc == nil {\n\t\tvar (\n\t\t\tval *struct {\n\t\t\t\tFieldC int \"json:\\\"field_c\\\"\"\n\t\t\t\tFieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"\n\t\t\t}\n\t\t)\n\t\treturn val\n\t}\n\treturn mock.MethodAFunc(v)\n}\n\n// MethodACalls gets all the calls that were made to MethodA.\n// Check the length with:\n//\n//\tlen(mockedStructWithTag.MethodACalls())\nfunc (mock *MoqStructWithTag) MethodACalls() []struct {\n\tV *struct {\n\t\tFieldA int \"json:\\\"field_a\\\"\"\n\t\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n\t}\n} {\n\tvar calls []struct {\n\t\tV *struct {\n\t\t\tFieldA int \"json:\\\"field_a\\\"\"\n\t\t\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n\t\t}\n\t}\n\tmock.lockMethodA.RLock()\n\tcalls = mock.calls.MethodA\n\tmock.lockMethodA.RUnlock()\n\treturn calls\n}\n\n// ResetMethodACalls reset all the calls that were made to MethodA.\nfunc (mock *MoqStructWithTag) ResetMethodACalls() {\n\tmock.lockMethodA.Lock()\n\tmock.calls.MethodA = nil\n\tmock.lockMethodA.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqStructWithTag) ResetCalls() {\n\tmock.lockMethodA.Lock()\n\tmock.calls.MethodA = nil\n\tmock.lockMethodA.Unlock()\n}\n\n// Ensure that MoqUnsafeInterface does implement UnsafeInterface.\n// If this is not the case, regenerate this file with mockery.\nvar _ UnsafeInterface = &MoqUnsafeInterface{}\n\n// MoqUnsafeInterface is a mock implementation of UnsafeInterface.\n//\n//\tfunc TestSomethingThatUsesUnsafeInterface(t *testing.T) {\n//\n//\t\t// make and configure a mocked UnsafeInterface\n//\t\tmockedUnsafeInterface := &MoqUnsafeInterface{\n//\t\t\tDoFunc: func(ptr *unsafe.Pointer) {\n//\t\t\t\tpanic(\"mock out the Do method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedUnsafeInterface in code that requires UnsafeInterface\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqUnsafeInterface struct {\n\t// DoFunc mocks the Do method.\n\tDoFunc func(ptr *unsafe.Pointer)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Do holds details about calls to the Do method.\n\t\tDo []struct {\n\t\t\t// Ptr is the ptr argument value.\n\t\t\tPtr *unsafe.Pointer\n\t\t}\n\t}\n\tlockDo sync.RWMutex\n}\n\n// Do calls DoFunc.\nfunc (mock *MoqUnsafeInterface) Do(ptr *unsafe.Pointer) {\n\tcallInfo := struct {\n\t\tPtr *unsafe.Pointer\n\t}{\n\t\tPtr: ptr,\n\t}\n\tmock.lockDo.Lock()\n\tmock.calls.Do = append(mock.calls.Do, callInfo)\n\tmock.lockDo.Unlock()\n\tif mock.DoFunc == nil {\n\t\treturn\n\t}\n\tmock.DoFunc(ptr)\n}\n\n// DoCalls gets all the calls that were made to Do.\n// Check the length with:\n//\n//\tlen(mockedUnsafeInterface.DoCalls())\nfunc (mock *MoqUnsafeInterface) DoCalls() []struct {\n\tPtr *unsafe.Pointer\n} {\n\tvar calls []struct {\n\t\tPtr *unsafe.Pointer\n\t}\n\tmock.lockDo.RLock()\n\tcalls = mock.calls.Do\n\tmock.lockDo.RUnlock()\n\treturn calls\n}\n\n// ResetDoCalls reset all the calls that were made to Do.\nfunc (mock *MoqUnsafeInterface) ResetDoCalls() {\n\tmock.lockDo.Lock()\n\tmock.calls.Do = nil\n\tmock.lockDo.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqUnsafeInterface) ResetCalls() {\n\tmock.lockDo.Lock()\n\tmock.calls.Do = nil\n\tmock.lockDo.Unlock()\n}\n\n// Ensure that MoqVariadic does implement Variadic.\n// If this is not the case, regenerate this file with mockery.\nvar _ Variadic = &MoqVariadic{}\n\n// MoqVariadic is a mock implementation of Variadic.\n//\n//\tfunc TestSomethingThatUsesVariadic(t *testing.T) {\n//\n//\t\t// make and configure a mocked Variadic\n//\t\tmockedVariadic := &MoqVariadic{\n//\t\t\tVariadicFunctionFunc: func(str string, vFunc VariadicFunction) error {\n//\t\t\t\tpanic(\"mock out the VariadicFunction method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedVariadic in code that requires Variadic\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqVariadic struct {\n\t// VariadicFunctionFunc mocks the VariadicFunction method.\n\tVariadicFunctionFunc func(str string, vFunc VariadicFunction) error\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// VariadicFunction holds details about calls to the VariadicFunction method.\n\t\tVariadicFunction []struct {\n\t\t\t// Str is the str argument value.\n\t\t\tStr string\n\t\t\t// VFunc is the vFunc argument value.\n\t\t\tVFunc VariadicFunction\n\t\t}\n\t}\n\tlockVariadicFunction sync.RWMutex\n}\n\n// VariadicFunction calls VariadicFunctionFunc.\nfunc (mock *MoqVariadic) VariadicFunction(str string, vFunc VariadicFunction) error {\n\tcallInfo := struct {\n\t\tStr string\n\t\tVFunc VariadicFunction\n\t}{\n\t\tStr: str,\n\t\tVFunc: vFunc,\n\t}\n\tmock.lockVariadicFunction.Lock()\n\tmock.calls.VariadicFunction = append(mock.calls.VariadicFunction, callInfo)\n\tmock.lockVariadicFunction.Unlock()\n\tif mock.VariadicFunctionFunc == nil {\n\t\tvar (\n\t\t\terr error\n\t\t)\n\t\treturn err\n\t}\n\treturn mock.VariadicFunctionFunc(str, vFunc)\n}\n\n// VariadicFunctionCalls gets all the calls that were made to VariadicFunction.\n// Check the length with:\n//\n//\tlen(mockedVariadic.VariadicFunctionCalls())\nfunc (mock *MoqVariadic) VariadicFunctionCalls() []struct {\n\tStr string\n\tVFunc VariadicFunction\n} {\n\tvar calls []struct {\n\t\tStr string\n\t\tVFunc VariadicFunction\n\t}\n\tmock.lockVariadicFunction.RLock()\n\tcalls = mock.calls.VariadicFunction\n\tmock.lockVariadicFunction.RUnlock()\n\treturn calls\n}\n\n// ResetVariadicFunctionCalls reset all the calls that were made to VariadicFunction.\nfunc (mock *MoqVariadic) ResetVariadicFunctionCalls() {\n\tmock.lockVariadicFunction.Lock()\n\tmock.calls.VariadicFunction = nil\n\tmock.lockVariadicFunction.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqVariadic) ResetCalls() {\n\tmock.lockVariadicFunction.Lock()\n\tmock.calls.VariadicFunction = nil\n\tmock.lockVariadicFunction.Unlock()\n}\n\n// Ensure that MoqVariadicReturnFunc does implement VariadicReturnFunc.\n// If this is not the case, regenerate this file with mockery.\nvar _ VariadicReturnFunc = &MoqVariadicReturnFunc{}\n\n// MoqVariadicReturnFunc is a mock implementation of VariadicReturnFunc.\n//\n//\tfunc TestSomethingThatUsesVariadicReturnFunc(t *testing.T) {\n//\n//\t\t// make and configure a mocked VariadicReturnFunc\n//\t\tmockedVariadicReturnFunc := &MoqVariadicReturnFunc{\n//\t\t\tSampleMethodFunc: func(str string) func(str string, arr []int, a ...interface{}) {\n//\t\t\t\tpanic(\"mock out the SampleMethod method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedVariadicReturnFunc in code that requires VariadicReturnFunc\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqVariadicReturnFunc struct {\n\t// SampleMethodFunc mocks the SampleMethod method.\n\tSampleMethodFunc func(str string) func(str string, arr []int, a ...interface{})\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// SampleMethod holds details about calls to the SampleMethod method.\n\t\tSampleMethod []struct {\n\t\t\t// Str is the str argument value.\n\t\t\tStr string\n\t\t}\n\t}\n\tlockSampleMethod sync.RWMutex\n}\n\n// SampleMethod calls SampleMethodFunc.\nfunc (mock *MoqVariadicReturnFunc) SampleMethod(str string) func(str string, arr []int, a ...interface{}) {\n\tcallInfo := struct {\n\t\tStr string\n\t}{\n\t\tStr: str,\n\t}\n\tmock.lockSampleMethod.Lock()\n\tmock.calls.SampleMethod = append(mock.calls.SampleMethod, callInfo)\n\tmock.lockSampleMethod.Unlock()\n\tif mock.SampleMethodFunc == nil {\n\t\tvar (\n\t\t\tfn func(str string, arr []int, a ...interface{})\n\t\t)\n\t\treturn fn\n\t}\n\treturn mock.SampleMethodFunc(str)\n}\n\n// SampleMethodCalls gets all the calls that were made to SampleMethod.\n// Check the length with:\n//\n//\tlen(mockedVariadicReturnFunc.SampleMethodCalls())\nfunc (mock *MoqVariadicReturnFunc) SampleMethodCalls() []struct {\n\tStr string\n} {\n\tvar calls []struct {\n\t\tStr string\n\t}\n\tmock.lockSampleMethod.RLock()\n\tcalls = mock.calls.SampleMethod\n\tmock.lockSampleMethod.RUnlock()\n\treturn calls\n}\n\n// ResetSampleMethodCalls reset all the calls that were made to SampleMethod.\nfunc (mock *MoqVariadicReturnFunc) ResetSampleMethodCalls() {\n\tmock.lockSampleMethod.Lock()\n\tmock.calls.SampleMethod = nil\n\tmock.lockSampleMethod.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqVariadicReturnFunc) ResetCalls() {\n\tmock.lockSampleMethod.Lock()\n\tmock.calls.SampleMethod = nil\n\tmock.lockSampleMethod.Unlock()\n}\n\n// Ensure that MoqVariadicWithMultipleReturns does implement VariadicWithMultipleReturns.\n// If this is not the case, regenerate this file with mockery.\nvar _ VariadicWithMultipleReturns = &MoqVariadicWithMultipleReturns{}\n\n// MoqVariadicWithMultipleReturns is a mock implementation of VariadicWithMultipleReturns.\n//\n//\tfunc TestSomethingThatUsesVariadicWithMultipleReturns(t *testing.T) {\n//\n//\t\t// make and configure a mocked VariadicWithMultipleReturns\n//\t\tmockedVariadicWithMultipleReturns := &MoqVariadicWithMultipleReturns{\n//\t\t\tFooFunc: func(one string, two ...string) (string, error) {\n//\t\t\t\tpanic(\"mock out the Foo method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedVariadicWithMultipleReturns in code that requires VariadicWithMultipleReturns\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqVariadicWithMultipleReturns struct {\n\t// FooFunc mocks the Foo method.\n\tFooFunc func(one string, two ...string) (string, error)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Foo holds details about calls to the Foo method.\n\t\tFoo []struct {\n\t\t\t// One is the one argument value.\n\t\t\tOne string\n\t\t\t// Two is the two argument value.\n\t\t\tTwo []string\n\t\t}\n\t}\n\tlockFoo sync.RWMutex\n}\n\n// Foo calls FooFunc.\nfunc (mock *MoqVariadicWithMultipleReturns) Foo(one string, two ...string) (string, error) {\n\tcallInfo := struct {\n\t\tOne string\n\t\tTwo []string\n\t}{\n\t\tOne: one,\n\t\tTwo: two,\n\t}\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = append(mock.calls.Foo, callInfo)\n\tmock.lockFoo.Unlock()\n\tif mock.FooFunc == nil {\n\t\tvar (\n\t\t\tresult string\n\t\t\terr error\n\t\t)\n\t\treturn result, err\n\t}\n\treturn mock.FooFunc(one, two...)\n}\n\n// FooCalls gets all the calls that were made to Foo.\n// Check the length with:\n//\n//\tlen(mockedVariadicWithMultipleReturns.FooCalls())\nfunc (mock *MoqVariadicWithMultipleReturns) FooCalls() []struct {\n\tOne string\n\tTwo []string\n} {\n\tvar calls []struct {\n\t\tOne string\n\t\tTwo []string\n\t}\n\tmock.lockFoo.RLock()\n\tcalls = mock.calls.Foo\n\tmock.lockFoo.RUnlock()\n\treturn calls\n}\n\n// ResetFooCalls reset all the calls that were made to Foo.\nfunc (mock *MoqVariadicWithMultipleReturns) ResetFooCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqVariadicWithMultipleReturns) ResetCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// Ensure that MoqVariadicWithNoReturns does implement VariadicWithNoReturns.\n// If this is not the case, regenerate this file with mockery.\nvar _ VariadicWithNoReturns = &MoqVariadicWithNoReturns{}\n\n// MoqVariadicWithNoReturns is a mock implementation of VariadicWithNoReturns.\n//\n//\tfunc TestSomethingThatUsesVariadicWithNoReturns(t *testing.T) {\n//\n//\t\t// make and configure a mocked VariadicWithNoReturns\n//\t\tmockedVariadicWithNoReturns := &MoqVariadicWithNoReturns{\n//\t\t\tFooFunc: func(one string, two ...string) {\n//\t\t\t\tpanic(\"mock out the Foo method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedVariadicWithNoReturns in code that requires VariadicWithNoReturns\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqVariadicWithNoReturns struct {\n\t// FooFunc mocks the Foo method.\n\tFooFunc func(one string, two ...string)\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Foo holds details about calls to the Foo method.\n\t\tFoo []struct {\n\t\t\t// One is the one argument value.\n\t\t\tOne string\n\t\t\t// Two is the two argument value.\n\t\t\tTwo []string\n\t\t}\n\t}\n\tlockFoo sync.RWMutex\n}\n\n// Foo calls FooFunc.\nfunc (mock *MoqVariadicWithNoReturns) Foo(one string, two ...string) {\n\tcallInfo := struct {\n\t\tOne string\n\t\tTwo []string\n\t}{\n\t\tOne: one,\n\t\tTwo: two,\n\t}\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = append(mock.calls.Foo, callInfo)\n\tmock.lockFoo.Unlock()\n\tif mock.FooFunc == nil {\n\t\treturn\n\t}\n\tmock.FooFunc(one, two...)\n}\n\n// FooCalls gets all the calls that were made to Foo.\n// Check the length with:\n//\n//\tlen(mockedVariadicWithNoReturns.FooCalls())\nfunc (mock *MoqVariadicWithNoReturns) FooCalls() []struct {\n\tOne string\n\tTwo []string\n} {\n\tvar calls []struct {\n\t\tOne string\n\t\tTwo []string\n\t}\n\tmock.lockFoo.RLock()\n\tcalls = mock.calls.Foo\n\tmock.lockFoo.RUnlock()\n\treturn calls\n}\n\n// ResetFooCalls reset all the calls that were made to Foo.\nfunc (mock *MoqVariadicWithNoReturns) ResetFooCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqVariadicWithNoReturns) ResetCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n" }, { "path": "internal/fixtures/mocks_net_http_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage test\n\nimport (\n\t\"net/http\"\n\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockResponseWriter creates a new instance of MockResponseWriter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockResponseWriter(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockResponseWriter {\n\tmock := &MockResponseWriter{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockResponseWriter is an autogenerated mock type for the ResponseWriter type\ntype MockResponseWriter struct {\n\tmock.Mock\n}\n\ntype MockResponseWriter_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockResponseWriter) EXPECT() *MockResponseWriter_Expecter {\n\treturn &MockResponseWriter_Expecter{mock: &_m.Mock}\n}\n\n// Header provides a mock function for the type MockResponseWriter\nfunc (_mock *MockResponseWriter) Header() http.Header {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Header\")\n\t}\n\n\tvar r0 http.Header\n\tif returnFunc, ok := ret.Get(0).(func() http.Header); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(http.Header)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockResponseWriter_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'\ntype MockResponseWriter_Header_Call struct {\n\t*mock.Call\n}\n\n// Header is a helper method to define mock.On call\nfunc (_e *MockResponseWriter_Expecter) Header() *MockResponseWriter_Header_Call {\n\treturn &MockResponseWriter_Header_Call{Call: _e.mock.On(\"Header\")}\n}\n\nfunc (_c *MockResponseWriter_Header_Call) Run(run func()) *MockResponseWriter_Header_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockResponseWriter_Header_Call) Return(header http.Header) *MockResponseWriter_Header_Call {\n\t_c.Call.Return(header)\n\treturn _c\n}\n\nfunc (_c *MockResponseWriter_Header_Call) RunAndReturn(run func() http.Header) *MockResponseWriter_Header_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Write provides a mock function for the type MockResponseWriter\nfunc (_mock *MockResponseWriter) Write(bytes []byte) (int, error) {\n\tret := _mock.Called(bytes)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Write\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(bytes)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(bytes)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(bytes)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockResponseWriter_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'\ntype MockResponseWriter_Write_Call struct {\n\t*mock.Call\n}\n\n// Write is a helper method to define mock.On call\n// - bytes []byte\nfunc (_e *MockResponseWriter_Expecter) Write(bytes interface{}) *MockResponseWriter_Write_Call {\n\treturn &MockResponseWriter_Write_Call{Call: _e.mock.On(\"Write\", bytes)}\n}\n\nfunc (_c *MockResponseWriter_Write_Call) Run(run func(bytes []byte)) *MockResponseWriter_Write_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockResponseWriter_Write_Call) Return(n int, err error) *MockResponseWriter_Write_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockResponseWriter_Write_Call) RunAndReturn(run func(bytes []byte) (int, error)) *MockResponseWriter_Write_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// WriteHeader provides a mock function for the type MockResponseWriter\nfunc (_mock *MockResponseWriter) WriteHeader(statusCode int) {\n\t_mock.Called(statusCode)\n\treturn\n}\n\n// MockResponseWriter_WriteHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteHeader'\ntype MockResponseWriter_WriteHeader_Call struct {\n\t*mock.Call\n}\n\n// WriteHeader is a helper method to define mock.On call\n// - statusCode int\nfunc (_e *MockResponseWriter_Expecter) WriteHeader(statusCode interface{}) *MockResponseWriter_WriteHeader_Call {\n\treturn &MockResponseWriter_WriteHeader_Call{Call: _e.mock.On(\"WriteHeader\", statusCode)}\n}\n\nfunc (_c *MockResponseWriter_WriteHeader_Call) Run(run func(statusCode int)) *MockResponseWriter_WriteHeader_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockResponseWriter_WriteHeader_Call) Return() *MockResponseWriter_WriteHeader_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockResponseWriter_WriteHeader_Call) RunAndReturn(run func(statusCode int)) *MockResponseWriter_WriteHeader_Call {\n\t_c.Run(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/mocks_testify_test_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage test\n\nimport (\n\t\"encoding/json\"\n\t\"io\"\n\t\"net/http\"\n\t\"unsafe\"\n\n\tmock \"github.com/stretchr/testify/mock\"\n\thttp1 \"github.com/vektra/mockery/v3/internal/fixtures/12345678/http\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/constraints\"\n\thttp0 \"github.com/vektra/mockery/v3/internal/fixtures/http\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/redefined_type_b\"\n)\n\n// NewMockUsesAny creates a new instance of MockUsesAny. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockUsesAny(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockUsesAny {\n\tmock := &MockUsesAny{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockUsesAny is an autogenerated mock type for the UsesAny type\ntype MockUsesAny struct {\n\tmock.Mock\n}\n\ntype MockUsesAny_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockUsesAny) EXPECT() *MockUsesAny_Expecter {\n\treturn &MockUsesAny_Expecter{mock: &_m.Mock}\n}\n\n// GetReader provides a mock function for the type MockUsesAny\nfunc (_mock *MockUsesAny) GetReader() any {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for GetReader\")\n\t}\n\n\tvar r0 any\n\tif returnFunc, ok := ret.Get(0).(func() any); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(any)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockUsesAny_GetReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReader'\ntype MockUsesAny_GetReader_Call struct {\n\t*mock.Call\n}\n\n// GetReader is a helper method to define mock.On call\nfunc (_e *MockUsesAny_Expecter) GetReader() *MockUsesAny_GetReader_Call {\n\treturn &MockUsesAny_GetReader_Call{Call: _e.mock.On(\"GetReader\")}\n}\n\nfunc (_c *MockUsesAny_GetReader_Call) Run(run func()) *MockUsesAny_GetReader_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockUsesAny_GetReader_Call) Return(v any) *MockUsesAny_GetReader_Call {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockUsesAny_GetReader_Call) RunAndReturn(run func() any) *MockUsesAny_GetReader_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockFooer creates a new instance of MockFooer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFooer(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFooer {\n\tmock := &MockFooer{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFooer is an autogenerated mock type for the Fooer type\ntype MockFooer struct {\n\tmock.Mock\n}\n\ntype MockFooer_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFooer) EXPECT() *MockFooer_Expecter {\n\treturn &MockFooer_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type MockFooer\nfunc (_mock *MockFooer) Bar(f func([]int)) {\n\t_mock.Called(f)\n\treturn\n}\n\n// MockFooer_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype MockFooer_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\n// - f func([]int)\nfunc (_e *MockFooer_Expecter) Bar(f interface{}) *MockFooer_Bar_Call {\n\treturn &MockFooer_Bar_Call{Call: _e.mock.On(\"Bar\", f)}\n}\n\nfunc (_c *MockFooer_Bar_Call) Run(run func(f func([]int))) *MockFooer_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 func([]int)\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(func([]int))\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFooer_Bar_Call) Return() *MockFooer_Bar_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockFooer_Bar_Call) RunAndReturn(run func(f func([]int))) *MockFooer_Bar_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// Baz provides a mock function for the type MockFooer\nfunc (_mock *MockFooer) Baz(path string) func(x string) string {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Baz\")\n\t}\n\n\tvar r0 func(x string) string\n\tif returnFunc, ok := ret.Get(0).(func(string) func(x string) string); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(func(x string) string)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockFooer_Baz_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Baz'\ntype MockFooer_Baz_Call struct {\n\t*mock.Call\n}\n\n// Baz is a helper method to define mock.On call\n// - path string\nfunc (_e *MockFooer_Expecter) Baz(path interface{}) *MockFooer_Baz_Call {\n\treturn &MockFooer_Baz_Call{Call: _e.mock.On(\"Baz\", path)}\n}\n\nfunc (_c *MockFooer_Baz_Call) Run(run func(path string)) *MockFooer_Baz_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFooer_Baz_Call) Return(fn func(x string) string) *MockFooer_Baz_Call {\n\t_c.Call.Return(fn)\n\treturn _c\n}\n\nfunc (_c *MockFooer_Baz_Call) RunAndReturn(run func(path string) func(x string) string) *MockFooer_Baz_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Foo provides a mock function for the type MockFooer\nfunc (_mock *MockFooer) Foo(f func(x string) string) error {\n\tret := _mock.Called(f)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Foo\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(func(x string) string) error); ok {\n\t\tr0 = returnFunc(f)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockFooer_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype MockFooer_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\n// - f func(x string) string\nfunc (_e *MockFooer_Expecter) Foo(f interface{}) *MockFooer_Foo_Call {\n\treturn &MockFooer_Foo_Call{Call: _e.mock.On(\"Foo\", f)}\n}\n\nfunc (_c *MockFooer_Foo_Call) Run(run func(f func(x string) string)) *MockFooer_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 func(x string) string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(func(x string) string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFooer_Foo_Call) Return(err error) *MockFooer_Foo_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockFooer_Foo_Call) RunAndReturn(run func(f func(x string) string) error) *MockFooer_Foo_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockMapFunc creates a new instance of MockMapFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockMapFunc(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockMapFunc {\n\tmock := &MockMapFunc{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockMapFunc is an autogenerated mock type for the MapFunc type\ntype MockMapFunc struct {\n\tmock.Mock\n}\n\ntype MockMapFunc_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockMapFunc) EXPECT() *MockMapFunc_Expecter {\n\treturn &MockMapFunc_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockMapFunc\nfunc (_mock *MockMapFunc) Get(m map[string]func(string) string) error {\n\tret := _mock.Called(m)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(map[string]func(string) string) error); ok {\n\t\tr0 = returnFunc(m)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockMapFunc_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockMapFunc_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - m map[string]func(string) string\nfunc (_e *MockMapFunc_Expecter) Get(m interface{}) *MockMapFunc_Get_Call {\n\treturn &MockMapFunc_Get_Call{Call: _e.mock.On(\"Get\", m)}\n}\n\nfunc (_c *MockMapFunc_Get_Call) Run(run func(m map[string]func(string) string)) *MockMapFunc_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 map[string]func(string) string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(map[string]func(string) string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockMapFunc_Get_Call) Return(err error) *MockMapFunc_Get_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockMapFunc_Get_Call) RunAndReturn(run func(m map[string]func(string) string) error) *MockMapFunc_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockAsyncProducer creates a new instance of MockAsyncProducer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockAsyncProducer(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockAsyncProducer {\n\tmock := &MockAsyncProducer{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockAsyncProducer is an autogenerated mock type for the AsyncProducer type\ntype MockAsyncProducer struct {\n\tmock.Mock\n}\n\ntype MockAsyncProducer_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockAsyncProducer) EXPECT() *MockAsyncProducer_Expecter {\n\treturn &MockAsyncProducer_Expecter{mock: &_m.Mock}\n}\n\n// Input provides a mock function for the type MockAsyncProducer\nfunc (_mock *MockAsyncProducer) Input() chan<- bool {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Input\")\n\t}\n\n\tvar r0 chan<- bool\n\tif returnFunc, ok := ret.Get(0).(func() chan<- bool); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(chan<- bool)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockAsyncProducer_Input_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Input'\ntype MockAsyncProducer_Input_Call struct {\n\t*mock.Call\n}\n\n// Input is a helper method to define mock.On call\nfunc (_e *MockAsyncProducer_Expecter) Input() *MockAsyncProducer_Input_Call {\n\treturn &MockAsyncProducer_Input_Call{Call: _e.mock.On(\"Input\")}\n}\n\nfunc (_c *MockAsyncProducer_Input_Call) Run(run func()) *MockAsyncProducer_Input_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockAsyncProducer_Input_Call) Return(boolCh chan<- bool) *MockAsyncProducer_Input_Call {\n\t_c.Call.Return(boolCh)\n\treturn _c\n}\n\nfunc (_c *MockAsyncProducer_Input_Call) RunAndReturn(run func() chan<- bool) *MockAsyncProducer_Input_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Output provides a mock function for the type MockAsyncProducer\nfunc (_mock *MockAsyncProducer) Output() <-chan bool {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Output\")\n\t}\n\n\tvar r0 <-chan bool\n\tif returnFunc, ok := ret.Get(0).(func() <-chan bool); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(<-chan bool)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockAsyncProducer_Output_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Output'\ntype MockAsyncProducer_Output_Call struct {\n\t*mock.Call\n}\n\n// Output is a helper method to define mock.On call\nfunc (_e *MockAsyncProducer_Expecter) Output() *MockAsyncProducer_Output_Call {\n\treturn &MockAsyncProducer_Output_Call{Call: _e.mock.On(\"Output\")}\n}\n\nfunc (_c *MockAsyncProducer_Output_Call) Run(run func()) *MockAsyncProducer_Output_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockAsyncProducer_Output_Call) Return(boolCh <-chan bool) *MockAsyncProducer_Output_Call {\n\t_c.Call.Return(boolCh)\n\treturn _c\n}\n\nfunc (_c *MockAsyncProducer_Output_Call) RunAndReturn(run func() <-chan bool) *MockAsyncProducer_Output_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Whatever provides a mock function for the type MockAsyncProducer\nfunc (_mock *MockAsyncProducer) Whatever() chan bool {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Whatever\")\n\t}\n\n\tvar r0 chan bool\n\tif returnFunc, ok := ret.Get(0).(func() chan bool); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(chan bool)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockAsyncProducer_Whatever_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Whatever'\ntype MockAsyncProducer_Whatever_Call struct {\n\t*mock.Call\n}\n\n// Whatever is a helper method to define mock.On call\nfunc (_e *MockAsyncProducer_Expecter) Whatever() *MockAsyncProducer_Whatever_Call {\n\treturn &MockAsyncProducer_Whatever_Call{Call: _e.mock.On(\"Whatever\")}\n}\n\nfunc (_c *MockAsyncProducer_Whatever_Call) Run(run func()) *MockAsyncProducer_Whatever_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockAsyncProducer_Whatever_Call) Return(boolCh chan bool) *MockAsyncProducer_Whatever_Call {\n\t_c.Call.Return(boolCh)\n\treturn _c\n}\n\nfunc (_c *MockAsyncProducer_Whatever_Call) RunAndReturn(run func() chan bool) *MockAsyncProducer_Whatever_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockConsulLock creates a new instance of MockConsulLock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockConsulLock(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockConsulLock {\n\tmock := &MockConsulLock{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockConsulLock is an autogenerated mock type for the ConsulLock type\ntype MockConsulLock struct {\n\tmock.Mock\n}\n\ntype MockConsulLock_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockConsulLock) EXPECT() *MockConsulLock_Expecter {\n\treturn &MockConsulLock_Expecter{mock: &_m.Mock}\n}\n\n// Lock provides a mock function for the type MockConsulLock\nfunc (_mock *MockConsulLock) Lock(valCh <-chan struct{}) (<-chan struct{}, error) {\n\tret := _mock.Called(valCh)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Lock\")\n\t}\n\n\tvar r0 <-chan struct{}\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(<-chan struct{}) (<-chan struct{}, error)); ok {\n\t\treturn returnFunc(valCh)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(<-chan struct{}) <-chan struct{}); ok {\n\t\tr0 = returnFunc(valCh)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(<-chan struct{})\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(<-chan struct{}) error); ok {\n\t\tr1 = returnFunc(valCh)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockConsulLock_Lock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Lock'\ntype MockConsulLock_Lock_Call struct {\n\t*mock.Call\n}\n\n// Lock is a helper method to define mock.On call\n// - valCh <-chan struct{}\nfunc (_e *MockConsulLock_Expecter) Lock(valCh interface{}) *MockConsulLock_Lock_Call {\n\treturn &MockConsulLock_Lock_Call{Call: _e.mock.On(\"Lock\", valCh)}\n}\n\nfunc (_c *MockConsulLock_Lock_Call) Run(run func(valCh <-chan struct{})) *MockConsulLock_Lock_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 <-chan struct{}\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(<-chan struct{})\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockConsulLock_Lock_Call) Return(valCh1 <-chan struct{}, err error) *MockConsulLock_Lock_Call {\n\t_c.Call.Return(valCh1, err)\n\treturn _c\n}\n\nfunc (_c *MockConsulLock_Lock_Call) RunAndReturn(run func(valCh <-chan struct{}) (<-chan struct{}, error)) *MockConsulLock_Lock_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Unlock provides a mock function for the type MockConsulLock\nfunc (_mock *MockConsulLock) Unlock() error {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Unlock\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func() error); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockConsulLock_Unlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unlock'\ntype MockConsulLock_Unlock_Call struct {\n\t*mock.Call\n}\n\n// Unlock is a helper method to define mock.On call\nfunc (_e *MockConsulLock_Expecter) Unlock() *MockConsulLock_Unlock_Call {\n\treturn &MockConsulLock_Unlock_Call{Call: _e.mock.On(\"Unlock\")}\n}\n\nfunc (_c *MockConsulLock_Unlock_Call) Run(run func()) *MockConsulLock_Unlock_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockConsulLock_Unlock_Call) Return(err error) *MockConsulLock_Unlock_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockConsulLock_Unlock_Call) RunAndReturn(run func() error) *MockConsulLock_Unlock_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockKeyManager creates a new instance of MockKeyManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockKeyManager(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockKeyManager {\n\tmock := &MockKeyManager{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockKeyManager is an autogenerated mock type for the KeyManager type\ntype MockKeyManager struct {\n\tmock.Mock\n}\n\ntype MockKeyManager_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockKeyManager) EXPECT() *MockKeyManager_Expecter {\n\treturn &MockKeyManager_Expecter{mock: &_m.Mock}\n}\n\n// GetKey provides a mock function for the type MockKeyManager\nfunc (_mock *MockKeyManager) GetKey(s string, v uint16) ([]byte, *Err) {\n\tret := _mock.Called(s, v)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for GetKey\")\n\t}\n\n\tvar r0 []byte\n\tvar r1 *Err\n\tif returnFunc, ok := ret.Get(0).(func(string, uint16) ([]byte, *Err)); ok {\n\t\treturn returnFunc(s, v)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string, uint16) []byte); ok {\n\t\tr0 = returnFunc(s, v)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).([]byte)\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string, uint16) *Err); ok {\n\t\tr1 = returnFunc(s, v)\n\t} else {\n\t\tif ret.Get(1) != nil {\n\t\t\tr1 = ret.Get(1).(*Err)\n\t\t}\n\t}\n\treturn r0, r1\n}\n\n// MockKeyManager_GetKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKey'\ntype MockKeyManager_GetKey_Call struct {\n\t*mock.Call\n}\n\n// GetKey is a helper method to define mock.On call\n// - s string\n// - v uint16\nfunc (_e *MockKeyManager_Expecter) GetKey(s interface{}, v interface{}) *MockKeyManager_GetKey_Call {\n\treturn &MockKeyManager_GetKey_Call{Call: _e.mock.On(\"GetKey\", s, v)}\n}\n\nfunc (_c *MockKeyManager_GetKey_Call) Run(run func(s string, v uint16)) *MockKeyManager_GetKey_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 uint16\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(uint16)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockKeyManager_GetKey_Call) Return(bytes []byte, err *Err) *MockKeyManager_GetKey_Call {\n\t_c.Call.Return(bytes, err)\n\treturn _c\n}\n\nfunc (_c *MockKeyManager_GetKey_Call) RunAndReturn(run func(s string, v uint16) ([]byte, *Err)) *MockKeyManager_GetKey_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockBlank creates a new instance of MockBlank. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockBlank(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockBlank {\n\tmock := &MockBlank{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockBlank is an autogenerated mock type for the Blank type\ntype MockBlank struct {\n\tmock.Mock\n}\n\ntype MockBlank_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockBlank) EXPECT() *MockBlank_Expecter {\n\treturn &MockBlank_Expecter{mock: &_m.Mock}\n}\n\n// Create provides a mock function for the type MockBlank\nfunc (_mock *MockBlank) Create(x interface{}) error {\n\tret := _mock.Called(x)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Create\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(interface{}) error); ok {\n\t\tr0 = returnFunc(x)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockBlank_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'\ntype MockBlank_Create_Call struct {\n\t*mock.Call\n}\n\n// Create is a helper method to define mock.On call\n// - x interface{}\nfunc (_e *MockBlank_Expecter) Create(x interface{}) *MockBlank_Create_Call {\n\treturn &MockBlank_Create_Call{Call: _e.mock.On(\"Create\", x)}\n}\n\nfunc (_c *MockBlank_Create_Call) Run(run func(x interface{})) *MockBlank_Create_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 interface{}\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(interface{})\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockBlank_Create_Call) Return(err error) *MockBlank_Create_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockBlank_Create_Call) RunAndReturn(run func(x interface{}) error) *MockBlank_Create_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockExpecterAndRolledVariadic creates a new instance of MockExpecterAndRolledVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockExpecterAndRolledVariadic(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockExpecterAndRolledVariadic {\n\tmock := &MockExpecterAndRolledVariadic{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockExpecterAndRolledVariadic is an autogenerated mock type for the Expecter type\ntype MockExpecterAndRolledVariadic struct {\n\tmock.Mock\n}\n\ntype MockExpecterAndRolledVariadic_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockExpecterAndRolledVariadic) EXPECT() *MockExpecterAndRolledVariadic_Expecter {\n\treturn &MockExpecterAndRolledVariadic_Expecter{mock: &_m.Mock}\n}\n\n// ManyArgsReturns provides a mock function for the type MockExpecterAndRolledVariadic\nfunc (_mock *MockExpecterAndRolledVariadic) ManyArgsReturns(str string, i int) ([]string, error) {\n\tret := _mock.Called(str, i)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for ManyArgsReturns\")\n\t}\n\n\tvar r0 []string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string, int) ([]string, error)); ok {\n\t\treturn returnFunc(str, i)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string, int) []string); ok {\n\t\tr0 = returnFunc(str, i)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).([]string)\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string, int) error); ok {\n\t\tr1 = returnFunc(str, i)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockExpecterAndRolledVariadic_ManyArgsReturns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManyArgsReturns'\ntype MockExpecterAndRolledVariadic_ManyArgsReturns_Call struct {\n\t*mock.Call\n}\n\n// ManyArgsReturns is a helper method to define mock.On call\n// - str string\n// - i int\nfunc (_e *MockExpecterAndRolledVariadic_Expecter) ManyArgsReturns(str interface{}, i interface{}) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call {\n\treturn &MockExpecterAndRolledVariadic_ManyArgsReturns_Call{Call: _e.mock.On(\"ManyArgsReturns\", str, i)}\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Run(run func(str string, i int)) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 int\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(int)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Return(strs []string, err error) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call {\n\t_c.Call.Return(strs, err)\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int) ([]string, error)) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NoArg provides a mock function for the type MockExpecterAndRolledVariadic\nfunc (_mock *MockExpecterAndRolledVariadic) NoArg() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for NoArg\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockExpecterAndRolledVariadic_NoArg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoArg'\ntype MockExpecterAndRolledVariadic_NoArg_Call struct {\n\t*mock.Call\n}\n\n// NoArg is a helper method to define mock.On call\nfunc (_e *MockExpecterAndRolledVariadic_Expecter) NoArg() *MockExpecterAndRolledVariadic_NoArg_Call {\n\treturn &MockExpecterAndRolledVariadic_NoArg_Call{Call: _e.mock.On(\"NoArg\")}\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_NoArg_Call) Run(run func()) *MockExpecterAndRolledVariadic_NoArg_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_NoArg_Call) Return(s string) *MockExpecterAndRolledVariadic_NoArg_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_NoArg_Call) RunAndReturn(run func() string) *MockExpecterAndRolledVariadic_NoArg_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NoReturn provides a mock function for the type MockExpecterAndRolledVariadic\nfunc (_mock *MockExpecterAndRolledVariadic) NoReturn(str string) {\n\t_mock.Called(str)\n\treturn\n}\n\n// MockExpecterAndRolledVariadic_NoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoReturn'\ntype MockExpecterAndRolledVariadic_NoReturn_Call struct {\n\t*mock.Call\n}\n\n// NoReturn is a helper method to define mock.On call\n// - str string\nfunc (_e *MockExpecterAndRolledVariadic_Expecter) NoReturn(str interface{}) *MockExpecterAndRolledVariadic_NoReturn_Call {\n\treturn &MockExpecterAndRolledVariadic_NoReturn_Call{Call: _e.mock.On(\"NoReturn\", str)}\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_NoReturn_Call) Run(run func(str string)) *MockExpecterAndRolledVariadic_NoReturn_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_NoReturn_Call) Return() *MockExpecterAndRolledVariadic_NoReturn_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_NoReturn_Call) RunAndReturn(run func(str string)) *MockExpecterAndRolledVariadic_NoReturn_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// Variadic provides a mock function for the type MockExpecterAndRolledVariadic\nfunc (_mock *MockExpecterAndRolledVariadic) Variadic(ints ...int) error {\n\tvar tmpRet mock.Arguments\n\tif len(ints) > 0 {\n\t\ttmpRet = _mock.Called(ints)\n\t} else {\n\t\ttmpRet = _mock.Called()\n\t}\n\tret := tmpRet\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Variadic\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(...int) error); ok {\n\t\tr0 = returnFunc(ints...)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockExpecterAndRolledVariadic_Variadic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Variadic'\ntype MockExpecterAndRolledVariadic_Variadic_Call struct {\n\t*mock.Call\n}\n\n// Variadic is a helper method to define mock.On call\n// - ints ...int\nfunc (_e *MockExpecterAndRolledVariadic_Expecter) Variadic(ints ...interface{}) *MockExpecterAndRolledVariadic_Variadic_Call {\n\treturn &MockExpecterAndRolledVariadic_Variadic_Call{Call: _e.mock.On(\"Variadic\",\n\t\tappend([]interface{}{}, ints...)...)}\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_Variadic_Call) Run(run func(ints ...int)) *MockExpecterAndRolledVariadic_Variadic_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []int\n\t\tvar variadicArgs []int\n\t\tif len(args) > 0 {\n\t\t\tvariadicArgs = args[0].([]int)\n\t\t}\n\t\targ0 = variadicArgs\n\t\trun(\n\t\t\targ0...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_Variadic_Call) Return(err error) *MockExpecterAndRolledVariadic_Variadic_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_Variadic_Call) RunAndReturn(run func(ints ...int) error) *MockExpecterAndRolledVariadic_Variadic_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// VariadicMany provides a mock function for the type MockExpecterAndRolledVariadic\nfunc (_mock *MockExpecterAndRolledVariadic) VariadicMany(i int, a string, intfs ...interface{}) error {\n\tvar tmpRet mock.Arguments\n\tif len(intfs) > 0 {\n\t\ttmpRet = _mock.Called(i, a, intfs)\n\t} else {\n\t\ttmpRet = _mock.Called(i, a)\n\t}\n\tret := tmpRet\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for VariadicMany\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(int, string, ...interface{}) error); ok {\n\t\tr0 = returnFunc(i, a, intfs...)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockExpecterAndRolledVariadic_VariadicMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicMany'\ntype MockExpecterAndRolledVariadic_VariadicMany_Call struct {\n\t*mock.Call\n}\n\n// VariadicMany is a helper method to define mock.On call\n// - i int\n// - a string\n// - intfs ...interface{}\nfunc (_e *MockExpecterAndRolledVariadic_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}) *MockExpecterAndRolledVariadic_VariadicMany_Call {\n\treturn &MockExpecterAndRolledVariadic_VariadicMany_Call{Call: _e.mock.On(\"VariadicMany\",\n\t\tappend([]interface{}{i, a}, intfs...)...)}\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *MockExpecterAndRolledVariadic_VariadicMany_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int)\n\t\t}\n\t\tvar arg1 string\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(string)\n\t\t}\n\t\tvar arg2 []interface{}\n\t\tvar variadicArgs []interface{}\n\t\tif len(args) > 2 {\n\t\t\tvariadicArgs = args[2].([]interface{})\n\t\t}\n\t\targ2 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t\targ2...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) Return(err error) *MockExpecterAndRolledVariadic_VariadicMany_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{}) error) *MockExpecterAndRolledVariadic_VariadicMany_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockExpecter creates a new instance of MockExpecter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockExpecter(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockExpecter {\n\tmock := &MockExpecter{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockExpecter is an autogenerated mock type for the Expecter type\ntype MockExpecter struct {\n\tmock.Mock\n}\n\ntype MockExpecter_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockExpecter) EXPECT() *MockExpecter_Expecter {\n\treturn &MockExpecter_Expecter{mock: &_m.Mock}\n}\n\n// ManyArgsReturns provides a mock function for the type MockExpecter\nfunc (_mock *MockExpecter) ManyArgsReturns(str string, i int) ([]string, error) {\n\tret := _mock.Called(str, i)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for ManyArgsReturns\")\n\t}\n\n\tvar r0 []string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string, int) ([]string, error)); ok {\n\t\treturn returnFunc(str, i)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string, int) []string); ok {\n\t\tr0 = returnFunc(str, i)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).([]string)\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string, int) error); ok {\n\t\tr1 = returnFunc(str, i)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockExpecter_ManyArgsReturns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManyArgsReturns'\ntype MockExpecter_ManyArgsReturns_Call struct {\n\t*mock.Call\n}\n\n// ManyArgsReturns is a helper method to define mock.On call\n// - str string\n// - i int\nfunc (_e *MockExpecter_Expecter) ManyArgsReturns(str interface{}, i interface{}) *MockExpecter_ManyArgsReturns_Call {\n\treturn &MockExpecter_ManyArgsReturns_Call{Call: _e.mock.On(\"ManyArgsReturns\", str, i)}\n}\n\nfunc (_c *MockExpecter_ManyArgsReturns_Call) Run(run func(str string, i int)) *MockExpecter_ManyArgsReturns_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 int\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(int)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecter_ManyArgsReturns_Call) Return(strs []string, err error) *MockExpecter_ManyArgsReturns_Call {\n\t_c.Call.Return(strs, err)\n\treturn _c\n}\n\nfunc (_c *MockExpecter_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int) ([]string, error)) *MockExpecter_ManyArgsReturns_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NoArg provides a mock function for the type MockExpecter\nfunc (_mock *MockExpecter) NoArg() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for NoArg\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockExpecter_NoArg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoArg'\ntype MockExpecter_NoArg_Call struct {\n\t*mock.Call\n}\n\n// NoArg is a helper method to define mock.On call\nfunc (_e *MockExpecter_Expecter) NoArg() *MockExpecter_NoArg_Call {\n\treturn &MockExpecter_NoArg_Call{Call: _e.mock.On(\"NoArg\")}\n}\n\nfunc (_c *MockExpecter_NoArg_Call) Run(run func()) *MockExpecter_NoArg_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecter_NoArg_Call) Return(s string) *MockExpecter_NoArg_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockExpecter_NoArg_Call) RunAndReturn(run func() string) *MockExpecter_NoArg_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NoReturn provides a mock function for the type MockExpecter\nfunc (_mock *MockExpecter) NoReturn(str string) {\n\t_mock.Called(str)\n\treturn\n}\n\n// MockExpecter_NoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoReturn'\ntype MockExpecter_NoReturn_Call struct {\n\t*mock.Call\n}\n\n// NoReturn is a helper method to define mock.On call\n// - str string\nfunc (_e *MockExpecter_Expecter) NoReturn(str interface{}) *MockExpecter_NoReturn_Call {\n\treturn &MockExpecter_NoReturn_Call{Call: _e.mock.On(\"NoReturn\", str)}\n}\n\nfunc (_c *MockExpecter_NoReturn_Call) Run(run func(str string)) *MockExpecter_NoReturn_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecter_NoReturn_Call) Return() *MockExpecter_NoReturn_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockExpecter_NoReturn_Call) RunAndReturn(run func(str string)) *MockExpecter_NoReturn_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// Variadic provides a mock function for the type MockExpecter\nfunc (_mock *MockExpecter) Variadic(ints ...int) error {\n\t// int\n\t_va := make([]interface{}, len(ints))\n\tfor _i := range ints {\n\t\t_va[_i] = ints[_i]\n\t}\n\tvar _ca []interface{}\n\t_ca = append(_ca, _va...)\n\tret := _mock.Called(_ca...)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Variadic\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(...int) error); ok {\n\t\tr0 = returnFunc(ints...)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockExpecter_Variadic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Variadic'\ntype MockExpecter_Variadic_Call struct {\n\t*mock.Call\n}\n\n// Variadic is a helper method to define mock.On call\n// - ints ...int\nfunc (_e *MockExpecter_Expecter) Variadic(ints ...interface{}) *MockExpecter_Variadic_Call {\n\treturn &MockExpecter_Variadic_Call{Call: _e.mock.On(\"Variadic\",\n\t\tappend([]interface{}{}, ints...)...)}\n}\n\nfunc (_c *MockExpecter_Variadic_Call) Run(run func(ints ...int)) *MockExpecter_Variadic_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []int\n\t\tvariadicArgs := make([]int, len(args)-0)\n\t\tfor i, a := range args[0:] {\n\t\t\tif a != nil {\n\t\t\t\tvariadicArgs[i] = a.(int)\n\t\t\t}\n\t\t}\n\t\targ0 = variadicArgs\n\t\trun(\n\t\t\targ0...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecter_Variadic_Call) Return(err error) *MockExpecter_Variadic_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockExpecter_Variadic_Call) RunAndReturn(run func(ints ...int) error) *MockExpecter_Variadic_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// VariadicMany provides a mock function for the type MockExpecter\nfunc (_mock *MockExpecter) VariadicMany(i int, a string, intfs ...interface{}) error {\n\tvar _ca []interface{}\n\t_ca = append(_ca, i, a)\n\t_ca = append(_ca, intfs...)\n\tret := _mock.Called(_ca...)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for VariadicMany\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(int, string, ...interface{}) error); ok {\n\t\tr0 = returnFunc(i, a, intfs...)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockExpecter_VariadicMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicMany'\ntype MockExpecter_VariadicMany_Call struct {\n\t*mock.Call\n}\n\n// VariadicMany is a helper method to define mock.On call\n// - i int\n// - a string\n// - intfs ...interface{}\nfunc (_e *MockExpecter_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}) *MockExpecter_VariadicMany_Call {\n\treturn &MockExpecter_VariadicMany_Call{Call: _e.mock.On(\"VariadicMany\",\n\t\tappend([]interface{}{i, a}, intfs...)...)}\n}\n\nfunc (_c *MockExpecter_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *MockExpecter_VariadicMany_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int)\n\t\t}\n\t\tvar arg1 string\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(string)\n\t\t}\n\t\tvar arg2 []interface{}\n\t\tvariadicArgs := make([]interface{}, len(args)-2)\n\t\tfor i, a := range args[2:] {\n\t\t\tif a != nil {\n\t\t\t\tvariadicArgs[i] = a.(interface{})\n\t\t\t}\n\t\t}\n\t\targ2 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t\targ2...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExpecter_VariadicMany_Call) Return(err error) *MockExpecter_VariadicMany_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockExpecter_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{}) error) *MockExpecter_VariadicMany_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockVariadicNoReturnInterface creates a new instance of MockVariadicNoReturnInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockVariadicNoReturnInterface(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockVariadicNoReturnInterface {\n\tmock := &MockVariadicNoReturnInterface{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockVariadicNoReturnInterface is an autogenerated mock type for the VariadicNoReturnInterface type\ntype MockVariadicNoReturnInterface struct {\n\tmock.Mock\n}\n\ntype MockVariadicNoReturnInterface_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockVariadicNoReturnInterface) EXPECT() *MockVariadicNoReturnInterface_Expecter {\n\treturn &MockVariadicNoReturnInterface_Expecter{mock: &_m.Mock}\n}\n\n// VariadicNoReturn provides a mock function for the type MockVariadicNoReturnInterface\nfunc (_mock *MockVariadicNoReturnInterface) VariadicNoReturn(j int, is ...interface{}) {\n\tif len(is) > 0 {\n\t\t_mock.Called(j, is)\n\t} else {\n\t\t_mock.Called(j)\n\t}\n\n\treturn\n}\n\n// MockVariadicNoReturnInterface_VariadicNoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicNoReturn'\ntype MockVariadicNoReturnInterface_VariadicNoReturn_Call struct {\n\t*mock.Call\n}\n\n// VariadicNoReturn is a helper method to define mock.On call\n// - j int\n// - is ...interface{}\nfunc (_e *MockVariadicNoReturnInterface_Expecter) VariadicNoReturn(j interface{}, is ...interface{}) *MockVariadicNoReturnInterface_VariadicNoReturn_Call {\n\treturn &MockVariadicNoReturnInterface_VariadicNoReturn_Call{Call: _e.mock.On(\"VariadicNoReturn\",\n\t\tappend([]interface{}{j}, is...)...)}\n}\n\nfunc (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) Run(run func(j int, is ...interface{})) *MockVariadicNoReturnInterface_VariadicNoReturn_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 int\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(int)\n\t\t}\n\t\tvar arg1 []interface{}\n\t\tvar variadicArgs []interface{}\n\t\tif len(args) > 1 {\n\t\t\tvariadicArgs = args[1].([]interface{})\n\t\t}\n\t\targ1 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) Return() *MockVariadicNoReturnInterface_VariadicNoReturn_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) RunAndReturn(run func(j int, is ...interface{})) *MockVariadicNoReturnInterface_VariadicNoReturn_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockFuncArgsCollision creates a new instance of MockFuncArgsCollision. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFuncArgsCollision(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFuncArgsCollision {\n\tmock := &MockFuncArgsCollision{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFuncArgsCollision is an autogenerated mock type for the FuncArgsCollision type\ntype MockFuncArgsCollision struct {\n\tmock.Mock\n}\n\ntype MockFuncArgsCollision_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFuncArgsCollision) EXPECT() *MockFuncArgsCollision_Expecter {\n\treturn &MockFuncArgsCollision_Expecter{mock: &_m.Mock}\n}\n\n// Foo provides a mock function for the type MockFuncArgsCollision\nfunc (_mock *MockFuncArgsCollision) Foo(ret interface{}) error {\n\tret1 := _mock.Called(ret)\n\n\tif len(ret1) == 0 {\n\t\tpanic(\"no return value specified for Foo\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret1.Get(0).(func(interface{}) error); ok {\n\t\tr0 = returnFunc(ret)\n\t} else {\n\t\tr0 = ret1.Error(0)\n\t}\n\treturn r0\n}\n\n// MockFuncArgsCollision_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype MockFuncArgsCollision_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\n// - ret interface{}\nfunc (_e *MockFuncArgsCollision_Expecter) Foo(ret interface{}) *MockFuncArgsCollision_Foo_Call {\n\treturn &MockFuncArgsCollision_Foo_Call{Call: _e.mock.On(\"Foo\", ret)}\n}\n\nfunc (_c *MockFuncArgsCollision_Foo_Call) Run(run func(ret interface{})) *MockFuncArgsCollision_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 interface{}\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(interface{})\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFuncArgsCollision_Foo_Call) Return(err error) *MockFuncArgsCollision_Foo_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockFuncArgsCollision_Foo_Call) RunAndReturn(run func(ret interface{}) error) *MockFuncArgsCollision_Foo_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterGenerics creates a new instance of MockRequesterGenerics. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterGenerics[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {\n\t~int | GenericType[int, GetInt]\n\tcomparable\n}](t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\tmock := &MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterGenerics is an autogenerated mock type for the RequesterGenerics type\ntype MockRequesterGenerics[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {\n\t~int | GenericType[int, GetInt]\n\tcomparable\n}] struct {\n\tmock.Mock\n}\n\ntype MockRequesterGenerics_Expecter[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {\n\t~int | GenericType[int, GetInt]\n\tcomparable\n}] struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) EXPECT() *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\treturn &MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{mock: &_m.Mock}\n}\n\n// GenericAnonymousStructs provides a mock function for the type MockRequesterGenerics\nfunc (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs(val struct{ Type1 TExternalIntf }) struct {\n\tType2 GenericType[string, EmbeddedGet[int]]\n} {\n\tret := _mock.Called(val)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for GenericAnonymousStructs\")\n\t}\n\n\tvar r0 struct {\n\t\tType2 GenericType[string, EmbeddedGet[int]]\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(struct{ Type1 TExternalIntf }) struct {\n\t\tType2 GenericType[string, EmbeddedGet[int]]\n\t}); ok {\n\t\tr0 = returnFunc(val)\n\t} else {\n\t\tr0 = ret.Get(0).(struct {\n\t\t\tType2 GenericType[string, EmbeddedGet[int]]\n\t\t})\n\t}\n\treturn r0\n}\n\n// MockRequesterGenerics_GenericAnonymousStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericAnonymousStructs'\ntype MockRequesterGenerics_GenericAnonymousStructs_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {\n\t~int | GenericType[int, GetInt]\n\tcomparable\n}] struct {\n\t*mock.Call\n}\n\n// GenericAnonymousStructs is a helper method to define mock.On call\n// - val struct{Type1 TExternalIntf}\nfunc (_e *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs(val interface{}) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\treturn &MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On(\"GenericAnonymousStructs\", val)}\n}\n\nfunc (_c *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(val struct{ Type1 TExternalIntf })) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 struct{ Type1 TExternalIntf }\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(struct{ Type1 TExternalIntf })\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(val1 struct {\n\tType2 GenericType[string, EmbeddedGet[int]]\n}) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\t_c.Call.Return(val1)\n\treturn _c\n}\n\nfunc (_c *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(val struct{ Type1 TExternalIntf }) struct {\n\tType2 GenericType[string, EmbeddedGet[int]]\n}) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// GenericArguments provides a mock function for the type MockRequesterGenerics\nfunc (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments(v TAny, v1 TComparable) (TSigned, TIntf) {\n\tret := _mock.Called(v, v1)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for GenericArguments\")\n\t}\n\n\tvar r0 TSigned\n\tvar r1 TIntf\n\tif returnFunc, ok := ret.Get(0).(func(TAny, TComparable) (TSigned, TIntf)); ok {\n\t\treturn returnFunc(v, v1)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(TAny, TComparable) TSigned); ok {\n\t\tr0 = returnFunc(v, v1)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(TSigned)\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(TAny, TComparable) TIntf); ok {\n\t\tr1 = returnFunc(v, v1)\n\t} else {\n\t\tif ret.Get(1) != nil {\n\t\t\tr1 = ret.Get(1).(TIntf)\n\t\t}\n\t}\n\treturn r0, r1\n}\n\n// MockRequesterGenerics_GenericArguments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericArguments'\ntype MockRequesterGenerics_GenericArguments_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {\n\t~int | GenericType[int, GetInt]\n\tcomparable\n}] struct {\n\t*mock.Call\n}\n\n// GenericArguments is a helper method to define mock.On call\n// - v TAny\n// - v1 TComparable\nfunc (_e *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments(v interface{}, v1 interface{}) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\treturn &MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On(\"GenericArguments\", v, v1)}\n}\n\nfunc (_c *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(v TAny, v1 TComparable)) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 TAny\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(TAny)\n\t\t}\n\t\tvar arg1 TComparable\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(TComparable)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(v2 TSigned, v3 TIntf) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\t_c.Call.Return(v2, v3)\n\treturn _c\n}\n\nfunc (_c *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(v TAny, v1 TComparable) (TSigned, TIntf)) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// GenericStructs provides a mock function for the type MockRequesterGenerics\nfunc (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs(genericType GenericType[TAny, TIntf]) GenericType[TSigned, TIntf] {\n\tret := _mock.Called(genericType)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for GenericStructs\")\n\t}\n\n\tvar r0 GenericType[TSigned, TIntf]\n\tif returnFunc, ok := ret.Get(0).(func(GenericType[TAny, TIntf]) GenericType[TSigned, TIntf]); ok {\n\t\tr0 = returnFunc(genericType)\n\t} else {\n\t\tr0 = ret.Get(0).(GenericType[TSigned, TIntf])\n\t}\n\treturn r0\n}\n\n// MockRequesterGenerics_GenericStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericStructs'\ntype MockRequesterGenerics_GenericStructs_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {\n\t~int | GenericType[int, GetInt]\n\tcomparable\n}] struct {\n\t*mock.Call\n}\n\n// GenericStructs is a helper method to define mock.On call\n// - genericType GenericType[TAny, TIntf]\nfunc (_e *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs(genericType interface{}) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\treturn &MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On(\"GenericStructs\", genericType)}\n}\n\nfunc (_c *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(genericType GenericType[TAny, TIntf])) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 GenericType[TAny, TIntf]\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(GenericType[TAny, TIntf])\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(genericType1 GenericType[TSigned, TIntf]) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\t_c.Call.Return(genericType1)\n\treturn _c\n}\n\nfunc (_c *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(genericType GenericType[TAny, TIntf]) GenericType[TSigned, TIntf]) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockGetInt creates a new instance of MockGetInt. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockGetInt(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockGetInt {\n\tmock := &MockGetInt{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockGetInt is an autogenerated mock type for the GetInt type\ntype MockGetInt struct {\n\tmock.Mock\n}\n\ntype MockGetInt_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockGetInt) EXPECT() *MockGetInt_Expecter {\n\treturn &MockGetInt_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockGetInt\nfunc (_mock *MockGetInt) Get() int {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 int\n\tif returnFunc, ok := ret.Get(0).(func() int); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\treturn r0\n}\n\n// MockGetInt_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockGetInt_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockGetInt_Expecter) Get() *MockGetInt_Get_Call {\n\treturn &MockGetInt_Get_Call{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockGetInt_Get_Call) Run(run func()) *MockGetInt_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockGetInt_Get_Call) Return(n int) *MockGetInt_Get_Call {\n\t_c.Call.Return(n)\n\treturn _c\n}\n\nfunc (_c *MockGetInt_Get_Call) RunAndReturn(run func() int) *MockGetInt_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockGetGeneric creates a new instance of MockGetGeneric. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockGetGeneric[T constraints.Integer](t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockGetGeneric[T] {\n\tmock := &MockGetGeneric[T]{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockGetGeneric is an autogenerated mock type for the GetGeneric type\ntype MockGetGeneric[T constraints.Integer] struct {\n\tmock.Mock\n}\n\ntype MockGetGeneric_Expecter[T constraints.Integer] struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockGetGeneric[T]) EXPECT() *MockGetGeneric_Expecter[T] {\n\treturn &MockGetGeneric_Expecter[T]{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockGetGeneric\nfunc (_mock *MockGetGeneric[T]) Get() T {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 T\n\tif returnFunc, ok := ret.Get(0).(func() T); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(T)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockGetGeneric_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockGetGeneric_Get_Call[T constraints.Integer] struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockGetGeneric_Expecter[T]) Get() *MockGetGeneric_Get_Call[T] {\n\treturn &MockGetGeneric_Get_Call[T]{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockGetGeneric_Get_Call[T]) Run(run func()) *MockGetGeneric_Get_Call[T] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockGetGeneric_Get_Call[T]) Return(v T) *MockGetGeneric_Get_Call[T] {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockGetGeneric_Get_Call[T]) RunAndReturn(run func() T) *MockGetGeneric_Get_Call[T] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockEmbeddedGet creates a new instance of MockEmbeddedGet. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockEmbeddedGet[T constraints.Signed](t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockEmbeddedGet[T] {\n\tmock := &MockEmbeddedGet[T]{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockEmbeddedGet is an autogenerated mock type for the EmbeddedGet type\ntype MockEmbeddedGet[T constraints.Signed] struct {\n\tmock.Mock\n}\n\ntype MockEmbeddedGet_Expecter[T constraints.Signed] struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockEmbeddedGet[T]) EXPECT() *MockEmbeddedGet_Expecter[T] {\n\treturn &MockEmbeddedGet_Expecter[T]{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockEmbeddedGet\nfunc (_mock *MockEmbeddedGet[T]) Get() T {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 T\n\tif returnFunc, ok := ret.Get(0).(func() T); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(T)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockEmbeddedGet_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockEmbeddedGet_Get_Call[T constraints.Signed] struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockEmbeddedGet_Expecter[T]) Get() *MockEmbeddedGet_Get_Call[T] {\n\treturn &MockEmbeddedGet_Get_Call[T]{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockEmbeddedGet_Get_Call[T]) Run(run func()) *MockEmbeddedGet_Get_Call[T] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockEmbeddedGet_Get_Call[T]) Return(v T) *MockEmbeddedGet_Get_Call[T] {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockEmbeddedGet_Get_Call[T]) RunAndReturn(run func() T) *MockEmbeddedGet_Get_Call[T] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReplaceGeneric creates a new instance of MockReplaceGeneric. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any](t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReplaceGeneric[TImport, TConstraint, TKeep] {\n\tmock := &MockReplaceGeneric[TImport, TConstraint, TKeep]{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReplaceGeneric is an autogenerated mock type for the ReplaceGeneric type\ntype MockReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any] struct {\n\tmock.Mock\n}\n\ntype MockReplaceGeneric_Expecter[TImport any, TConstraint constraints.Signed, TKeep any] struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReplaceGeneric[TImport, TConstraint, TKeep]) EXPECT() *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep] {\n\treturn &MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]{mock: &_m.Mock}\n}\n\n// A provides a mock function for the type MockReplaceGeneric\nfunc (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) A(t1 TImport) TKeep {\n\tret := _mock.Called(t1)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for A\")\n\t}\n\n\tvar r0 TKeep\n\tif returnFunc, ok := ret.Get(0).(func(TImport) TKeep); ok {\n\t\tr0 = returnFunc(t1)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(TKeep)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockReplaceGeneric_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'\ntype MockReplaceGeneric_A_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct {\n\t*mock.Call\n}\n\n// A is a helper method to define mock.On call\n// - t1 TImport\nfunc (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) A(t1 interface{}) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] {\n\treturn &MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On(\"A\", t1)}\n}\n\nfunc (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Run(run func(t1 TImport)) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 TImport\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(TImport)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Return(v TKeep) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func(t1 TImport) TKeep) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// B provides a mock function for the type MockReplaceGeneric\nfunc (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) B() TImport {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for B\")\n\t}\n\n\tvar r0 TImport\n\tif returnFunc, ok := ret.Get(0).(func() TImport); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(TImport)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockReplaceGeneric_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B'\ntype MockReplaceGeneric_B_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct {\n\t*mock.Call\n}\n\n// B is a helper method to define mock.On call\nfunc (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) B() *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] {\n\treturn &MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On(\"B\")}\n}\n\nfunc (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Run(run func()) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Return(v TImport) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func() TImport) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// C provides a mock function for the type MockReplaceGeneric\nfunc (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) C() TConstraint {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for C\")\n\t}\n\n\tvar r0 TConstraint\n\tif returnFunc, ok := ret.Get(0).(func() TConstraint); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(TConstraint)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockReplaceGeneric_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'\ntype MockReplaceGeneric_C_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct {\n\t*mock.Call\n}\n\n// C is a helper method to define mock.On call\nfunc (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) C() *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] {\n\treturn &MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On(\"C\")}\n}\n\nfunc (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Run(run func()) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Return(v TConstraint) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func() TConstraint) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockReplaceGenericSelf creates a new instance of MockReplaceGenericSelf. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockReplaceGenericSelf[T any](t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockReplaceGenericSelf[T] {\n\tmock := &MockReplaceGenericSelf[T]{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockReplaceGenericSelf is an autogenerated mock type for the ReplaceGenericSelf type\ntype MockReplaceGenericSelf[T any] struct {\n\tmock.Mock\n}\n\ntype MockReplaceGenericSelf_Expecter[T any] struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockReplaceGenericSelf[T]) EXPECT() *MockReplaceGenericSelf_Expecter[T] {\n\treturn &MockReplaceGenericSelf_Expecter[T]{mock: &_m.Mock}\n}\n\n// A provides a mock function for the type MockReplaceGenericSelf\nfunc (_mock *MockReplaceGenericSelf[T]) A() T {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for A\")\n\t}\n\n\tvar r0 T\n\tif returnFunc, ok := ret.Get(0).(func() T); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(T)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockReplaceGenericSelf_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'\ntype MockReplaceGenericSelf_A_Call[T any] struct {\n\t*mock.Call\n}\n\n// A is a helper method to define mock.On call\nfunc (_e *MockReplaceGenericSelf_Expecter[T]) A() *MockReplaceGenericSelf_A_Call[T] {\n\treturn &MockReplaceGenericSelf_A_Call[T]{Call: _e.mock.On(\"A\")}\n}\n\nfunc (_c *MockReplaceGenericSelf_A_Call[T]) Run(run func()) *MockReplaceGenericSelf_A_Call[T] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockReplaceGenericSelf_A_Call[T]) Return(v T) *MockReplaceGenericSelf_A_Call[T] {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockReplaceGenericSelf_A_Call[T]) RunAndReturn(run func() T) *MockReplaceGenericSelf_A_Call[T] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockHasConflictingNestedImports creates a new instance of MockHasConflictingNestedImports. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockHasConflictingNestedImports(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockHasConflictingNestedImports {\n\tmock := &MockHasConflictingNestedImports{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockHasConflictingNestedImports is an autogenerated mock type for the HasConflictingNestedImports type\ntype MockHasConflictingNestedImports struct {\n\tmock.Mock\n}\n\ntype MockHasConflictingNestedImports_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockHasConflictingNestedImports) EXPECT() *MockHasConflictingNestedImports_Expecter {\n\treturn &MockHasConflictingNestedImports_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockHasConflictingNestedImports\nfunc (_mock *MockHasConflictingNestedImports) Get(path string) (http.Response, error) {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 http.Response\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) (http.Response, error)); ok {\n\t\treturn returnFunc(path)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) http.Response); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tr0 = ret.Get(0).(http.Response)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(path)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockHasConflictingNestedImports_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockHasConflictingNestedImports_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\nfunc (_e *MockHasConflictingNestedImports_Expecter) Get(path interface{}) *MockHasConflictingNestedImports_Get_Call {\n\treturn &MockHasConflictingNestedImports_Get_Call{Call: _e.mock.On(\"Get\", path)}\n}\n\nfunc (_c *MockHasConflictingNestedImports_Get_Call) Run(run func(path string)) *MockHasConflictingNestedImports_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockHasConflictingNestedImports_Get_Call) Return(response http.Response, err error) *MockHasConflictingNestedImports_Get_Call {\n\t_c.Call.Return(response, err)\n\treturn _c\n}\n\nfunc (_c *MockHasConflictingNestedImports_Get_Call) RunAndReturn(run func(path string) (http.Response, error)) *MockHasConflictingNestedImports_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Z provides a mock function for the type MockHasConflictingNestedImports\nfunc (_mock *MockHasConflictingNestedImports) Z() http0.MyStruct {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Z\")\n\t}\n\n\tvar r0 http0.MyStruct\n\tif returnFunc, ok := ret.Get(0).(func() http0.MyStruct); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(http0.MyStruct)\n\t}\n\treturn r0\n}\n\n// MockHasConflictingNestedImports_Z_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Z'\ntype MockHasConflictingNestedImports_Z_Call struct {\n\t*mock.Call\n}\n\n// Z is a helper method to define mock.On call\nfunc (_e *MockHasConflictingNestedImports_Expecter) Z() *MockHasConflictingNestedImports_Z_Call {\n\treturn &MockHasConflictingNestedImports_Z_Call{Call: _e.mock.On(\"Z\")}\n}\n\nfunc (_c *MockHasConflictingNestedImports_Z_Call) Run(run func()) *MockHasConflictingNestedImports_Z_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockHasConflictingNestedImports_Z_Call) Return(myStruct http0.MyStruct) *MockHasConflictingNestedImports_Z_Call {\n\t_c.Call.Return(myStruct)\n\treturn _c\n}\n\nfunc (_c *MockHasConflictingNestedImports_Z_Call) RunAndReturn(run func() http0.MyStruct) *MockHasConflictingNestedImports_Z_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockImportsSameAsPackage creates a new instance of MockImportsSameAsPackage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockImportsSameAsPackage(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockImportsSameAsPackage {\n\tmock := &MockImportsSameAsPackage{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockImportsSameAsPackage is an autogenerated mock type for the ImportsSameAsPackage type\ntype MockImportsSameAsPackage struct {\n\tmock.Mock\n}\n\ntype MockImportsSameAsPackage_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockImportsSameAsPackage) EXPECT() *MockImportsSameAsPackage_Expecter {\n\treturn &MockImportsSameAsPackage_Expecter{mock: &_m.Mock}\n}\n\n// A provides a mock function for the type MockImportsSameAsPackage\nfunc (_mock *MockImportsSameAsPackage) A() test.B {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for A\")\n\t}\n\n\tvar r0 test.B\n\tif returnFunc, ok := ret.Get(0).(func() test.B); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(test.B)\n\t}\n\treturn r0\n}\n\n// MockImportsSameAsPackage_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'\ntype MockImportsSameAsPackage_A_Call struct {\n\t*mock.Call\n}\n\n// A is a helper method to define mock.On call\nfunc (_e *MockImportsSameAsPackage_Expecter) A() *MockImportsSameAsPackage_A_Call {\n\treturn &MockImportsSameAsPackage_A_Call{Call: _e.mock.On(\"A\")}\n}\n\nfunc (_c *MockImportsSameAsPackage_A_Call) Run(run func()) *MockImportsSameAsPackage_A_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockImportsSameAsPackage_A_Call) Return(b test.B) *MockImportsSameAsPackage_A_Call {\n\t_c.Call.Return(b)\n\treturn _c\n}\n\nfunc (_c *MockImportsSameAsPackage_A_Call) RunAndReturn(run func() test.B) *MockImportsSameAsPackage_A_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// B provides a mock function for the type MockImportsSameAsPackage\nfunc (_mock *MockImportsSameAsPackage) B() KeyManager {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for B\")\n\t}\n\n\tvar r0 KeyManager\n\tif returnFunc, ok := ret.Get(0).(func() KeyManager); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(KeyManager)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockImportsSameAsPackage_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B'\ntype MockImportsSameAsPackage_B_Call struct {\n\t*mock.Call\n}\n\n// B is a helper method to define mock.On call\nfunc (_e *MockImportsSameAsPackage_Expecter) B() *MockImportsSameAsPackage_B_Call {\n\treturn &MockImportsSameAsPackage_B_Call{Call: _e.mock.On(\"B\")}\n}\n\nfunc (_c *MockImportsSameAsPackage_B_Call) Run(run func()) *MockImportsSameAsPackage_B_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockImportsSameAsPackage_B_Call) Return(keyManager KeyManager) *MockImportsSameAsPackage_B_Call {\n\t_c.Call.Return(keyManager)\n\treturn _c\n}\n\nfunc (_c *MockImportsSameAsPackage_B_Call) RunAndReturn(run func() KeyManager) *MockImportsSameAsPackage_B_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// C provides a mock function for the type MockImportsSameAsPackage\nfunc (_mock *MockImportsSameAsPackage) C(c C) {\n\t_mock.Called(c)\n\treturn\n}\n\n// MockImportsSameAsPackage_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'\ntype MockImportsSameAsPackage_C_Call struct {\n\t*mock.Call\n}\n\n// C is a helper method to define mock.On call\n// - c C\nfunc (_e *MockImportsSameAsPackage_Expecter) C(c interface{}) *MockImportsSameAsPackage_C_Call {\n\treturn &MockImportsSameAsPackage_C_Call{Call: _e.mock.On(\"C\", c)}\n}\n\nfunc (_c *MockImportsSameAsPackage_C_Call) Run(run func(c C)) *MockImportsSameAsPackage_C_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 C\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(C)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockImportsSameAsPackage_C_Call) Return() *MockImportsSameAsPackage_C_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockImportsSameAsPackage_C_Call) RunAndReturn(run func(c C)) *MockImportsSameAsPackage_C_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockGenericInterface creates a new instance of MockGenericInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockGenericInterface[M any](t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockGenericInterface[M] {\n\tmock := &MockGenericInterface[M]{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockGenericInterface is an autogenerated mock type for the GenericInterface type\ntype MockGenericInterface[M any] struct {\n\tmock.Mock\n}\n\ntype MockGenericInterface_Expecter[M any] struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockGenericInterface[M]) EXPECT() *MockGenericInterface_Expecter[M] {\n\treturn &MockGenericInterface_Expecter[M]{mock: &_m.Mock}\n}\n\n// Func provides a mock function for the type MockGenericInterface\nfunc (_mock *MockGenericInterface[M]) Func(arg *M) int {\n\tret := _mock.Called(arg)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Func\")\n\t}\n\n\tvar r0 int\n\tif returnFunc, ok := ret.Get(0).(func(*M) int); ok {\n\t\tr0 = returnFunc(arg)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\treturn r0\n}\n\n// MockGenericInterface_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func'\ntype MockGenericInterface_Func_Call[M any] struct {\n\t*mock.Call\n}\n\n// Func is a helper method to define mock.On call\n// - arg *M\nfunc (_e *MockGenericInterface_Expecter[M]) Func(arg interface{}) *MockGenericInterface_Func_Call[M] {\n\treturn &MockGenericInterface_Func_Call[M]{Call: _e.mock.On(\"Func\", arg)}\n}\n\nfunc (_c *MockGenericInterface_Func_Call[M]) Run(run func(arg *M)) *MockGenericInterface_Func_Call[M] {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 *M\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(*M)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockGenericInterface_Func_Call[M]) Return(n int) *MockGenericInterface_Func_Call[M] {\n\t_c.Call.Return(n)\n\treturn _c\n}\n\nfunc (_c *MockGenericInterface_Func_Call[M]) RunAndReturn(run func(arg *M) int) *MockGenericInterface_Func_Call[M] {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockInstantiatedGenericInterface creates a new instance of MockInstantiatedGenericInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockInstantiatedGenericInterface(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockInstantiatedGenericInterface {\n\tmock := &MockInstantiatedGenericInterface{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockInstantiatedGenericInterface is an autogenerated mock type for the InstantiatedGenericInterface type\ntype MockInstantiatedGenericInterface struct {\n\tmock.Mock\n}\n\ntype MockInstantiatedGenericInterface_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockInstantiatedGenericInterface) EXPECT() *MockInstantiatedGenericInterface_Expecter {\n\treturn &MockInstantiatedGenericInterface_Expecter{mock: &_m.Mock}\n}\n\n// Func provides a mock function for the type MockInstantiatedGenericInterface\nfunc (_mock *MockInstantiatedGenericInterface) Func(arg *float32) int {\n\tret := _mock.Called(arg)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Func\")\n\t}\n\n\tvar r0 int\n\tif returnFunc, ok := ret.Get(0).(func(*float32) int); ok {\n\t\tr0 = returnFunc(arg)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\treturn r0\n}\n\n// MockInstantiatedGenericInterface_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func'\ntype MockInstantiatedGenericInterface_Func_Call struct {\n\t*mock.Call\n}\n\n// Func is a helper method to define mock.On call\n// - arg *float32\nfunc (_e *MockInstantiatedGenericInterface_Expecter) Func(arg interface{}) *MockInstantiatedGenericInterface_Func_Call {\n\treturn &MockInstantiatedGenericInterface_Func_Call{Call: _e.mock.On(\"Func\", arg)}\n}\n\nfunc (_c *MockInstantiatedGenericInterface_Func_Call) Run(run func(arg *float32)) *MockInstantiatedGenericInterface_Func_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 *float32\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(*float32)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockInstantiatedGenericInterface_Func_Call) Return(n int) *MockInstantiatedGenericInterface_Func_Call {\n\t_c.Call.Return(n)\n\treturn _c\n}\n\nfunc (_c *MockInstantiatedGenericInterface_Func_Call) RunAndReturn(run func(arg *float32) int) *MockInstantiatedGenericInterface_Func_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockMyReader creates a new instance of MockMyReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockMyReader(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockMyReader {\n\tmock := &MockMyReader{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockMyReader is an autogenerated mock type for the MyReader type\ntype MockMyReader struct {\n\tmock.Mock\n}\n\ntype MockMyReader_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockMyReader) EXPECT() *MockMyReader_Expecter {\n\treturn &MockMyReader_Expecter{mock: &_m.Mock}\n}\n\n// Read provides a mock function for the type MockMyReader\nfunc (_mock *MockMyReader) Read(p []byte) (int, error) {\n\tret := _mock.Called(p)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Read\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {\n\t\treturn returnFunc(p)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func([]byte) int); ok {\n\t\tr0 = returnFunc(p)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func([]byte) error); ok {\n\t\tr1 = returnFunc(p)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockMyReader_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'\ntype MockMyReader_Read_Call struct {\n\t*mock.Call\n}\n\n// Read is a helper method to define mock.On call\n// - p []byte\nfunc (_e *MockMyReader_Expecter) Read(p interface{}) *MockMyReader_Read_Call {\n\treturn &MockMyReader_Read_Call{Call: _e.mock.On(\"Read\", p)}\n}\n\nfunc (_c *MockMyReader_Read_Call) Run(run func(p []byte)) *MockMyReader_Read_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []byte\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].([]byte)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockMyReader_Read_Call) Return(n int, err error) *MockMyReader_Read_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockMyReader_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockMyReader_Read_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockIssue766 creates a new instance of MockIssue766. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockIssue766(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockIssue766 {\n\tmock := &MockIssue766{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockIssue766 is an autogenerated mock type for the Issue766 type\ntype MockIssue766 struct {\n\tmock.Mock\n}\n\ntype MockIssue766_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockIssue766) EXPECT() *MockIssue766_Expecter {\n\treturn &MockIssue766_Expecter{mock: &_m.Mock}\n}\n\n// FetchData provides a mock function for the type MockIssue766\nfunc (_mock *MockIssue766) FetchData(fetchFunc func(x ...int) ([]int, error)) ([]int, error) {\n\tret := _mock.Called(fetchFunc)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for FetchData\")\n\t}\n\n\tvar r0 []int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(func(x ...int) ([]int, error)) ([]int, error)); ok {\n\t\treturn returnFunc(fetchFunc)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(func(x ...int) ([]int, error)) []int); ok {\n\t\tr0 = returnFunc(fetchFunc)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).([]int)\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(func(x ...int) ([]int, error)) error); ok {\n\t\tr1 = returnFunc(fetchFunc)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockIssue766_FetchData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchData'\ntype MockIssue766_FetchData_Call struct {\n\t*mock.Call\n}\n\n// FetchData is a helper method to define mock.On call\n// - fetchFunc func(x ...int) ([]int, error)\nfunc (_e *MockIssue766_Expecter) FetchData(fetchFunc interface{}) *MockIssue766_FetchData_Call {\n\treturn &MockIssue766_FetchData_Call{Call: _e.mock.On(\"FetchData\", fetchFunc)}\n}\n\nfunc (_c *MockIssue766_FetchData_Call) Run(run func(fetchFunc func(x ...int) ([]int, error))) *MockIssue766_FetchData_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 func(x ...int) ([]int, error)\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(func(x ...int) ([]int, error))\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockIssue766_FetchData_Call) Return(ints []int, err error) *MockIssue766_FetchData_Call {\n\t_c.Call.Return(ints, err)\n\treturn _c\n}\n\nfunc (_c *MockIssue766_FetchData_Call) RunAndReturn(run func(fetchFunc func(x ...int) ([]int, error)) ([]int, error)) *MockIssue766_FetchData_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockMapToInterface creates a new instance of MockMapToInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockMapToInterface(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockMapToInterface {\n\tmock := &MockMapToInterface{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockMapToInterface is an autogenerated mock type for the MapToInterface type\ntype MockMapToInterface struct {\n\tmock.Mock\n}\n\ntype MockMapToInterface_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockMapToInterface) EXPECT() *MockMapToInterface_Expecter {\n\treturn &MockMapToInterface_Expecter{mock: &_m.Mock}\n}\n\n// Foo provides a mock function for the type MockMapToInterface\nfunc (_mock *MockMapToInterface) Foo(arg1 ...map[string]interface{}) {\n\tif len(arg1) > 0 {\n\t\t_mock.Called(arg1)\n\t} else {\n\t\t_mock.Called()\n\t}\n\n\treturn\n}\n\n// MockMapToInterface_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype MockMapToInterface_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\n// - arg1 ...map[string]interface{}\nfunc (_e *MockMapToInterface_Expecter) Foo(arg1 ...interface{}) *MockMapToInterface_Foo_Call {\n\treturn &MockMapToInterface_Foo_Call{Call: _e.mock.On(\"Foo\",\n\t\tappend([]interface{}{}, arg1...)...)}\n}\n\nfunc (_c *MockMapToInterface_Foo_Call) Run(run func(arg1 ...map[string]interface{})) *MockMapToInterface_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []map[string]interface{}\n\t\tvar variadicArgs []map[string]interface{}\n\t\tif len(args) > 0 {\n\t\t\tvariadicArgs = args[0].([]map[string]interface{})\n\t\t}\n\t\targ0 = variadicArgs\n\t\trun(\n\t\t\targ0...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockMapToInterface_Foo_Call) Return() *MockMapToInterface_Foo_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockMapToInterface_Foo_Call) RunAndReturn(run func(arg1 ...map[string]interface{})) *MockMapToInterface_Foo_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockSibling creates a new instance of MockSibling. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockSibling(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockSibling {\n\tmock := &MockSibling{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockSibling is an autogenerated mock type for the Sibling type\ntype MockSibling struct {\n\tmock.Mock\n}\n\ntype MockSibling_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockSibling) EXPECT() *MockSibling_Expecter {\n\treturn &MockSibling_Expecter{mock: &_m.Mock}\n}\n\n// DoSomething provides a mock function for the type MockSibling\nfunc (_mock *MockSibling) DoSomething() {\n\t_mock.Called()\n\treturn\n}\n\n// MockSibling_DoSomething_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomething'\ntype MockSibling_DoSomething_Call struct {\n\t*mock.Call\n}\n\n// DoSomething is a helper method to define mock.On call\nfunc (_e *MockSibling_Expecter) DoSomething() *MockSibling_DoSomething_Call {\n\treturn &MockSibling_DoSomething_Call{Call: _e.mock.On(\"DoSomething\")}\n}\n\nfunc (_c *MockSibling_DoSomething_Call) Run(run func()) *MockSibling_DoSomething_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockSibling_DoSomething_Call) Return() *MockSibling_DoSomething_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockSibling_DoSomething_Call) RunAndReturn(run func()) *MockSibling_DoSomething_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockUsesOtherPkgIface creates a new instance of MockUsesOtherPkgIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockUsesOtherPkgIface(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockUsesOtherPkgIface {\n\tmock := &MockUsesOtherPkgIface{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockUsesOtherPkgIface is an autogenerated mock type for the UsesOtherPkgIface type\ntype MockUsesOtherPkgIface struct {\n\tmock.Mock\n}\n\ntype MockUsesOtherPkgIface_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockUsesOtherPkgIface) EXPECT() *MockUsesOtherPkgIface_Expecter {\n\treturn &MockUsesOtherPkgIface_Expecter{mock: &_m.Mock}\n}\n\n// DoSomethingElse provides a mock function for the type MockUsesOtherPkgIface\nfunc (_mock *MockUsesOtherPkgIface) DoSomethingElse(obj Sibling) {\n\t_mock.Called(obj)\n\treturn\n}\n\n// MockUsesOtherPkgIface_DoSomethingElse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomethingElse'\ntype MockUsesOtherPkgIface_DoSomethingElse_Call struct {\n\t*mock.Call\n}\n\n// DoSomethingElse is a helper method to define mock.On call\n// - obj Sibling\nfunc (_e *MockUsesOtherPkgIface_Expecter) DoSomethingElse(obj interface{}) *MockUsesOtherPkgIface_DoSomethingElse_Call {\n\treturn &MockUsesOtherPkgIface_DoSomethingElse_Call{Call: _e.mock.On(\"DoSomethingElse\", obj)}\n}\n\nfunc (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) Run(run func(obj Sibling)) *MockUsesOtherPkgIface_DoSomethingElse_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 Sibling\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(Sibling)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) Return() *MockUsesOtherPkgIface_DoSomethingElse_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) RunAndReturn(run func(obj Sibling)) *MockUsesOtherPkgIface_DoSomethingElse_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockNilRun creates a new instance of MockNilRun. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockNilRun(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockNilRun {\n\tmock := &MockNilRun{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockNilRun is an autogenerated mock type for the NilRun type\ntype MockNilRun struct {\n\tmock.Mock\n}\n\ntype MockNilRun_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockNilRun) EXPECT() *MockNilRun_Expecter {\n\treturn &MockNilRun_Expecter{mock: &_m.Mock}\n}\n\n// Foo provides a mock function for the type MockNilRun\nfunc (_mock *MockNilRun) Foo(nilRun NilRun) {\n\t_mock.Called(nilRun)\n\treturn\n}\n\n// MockNilRun_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype MockNilRun_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\n// - nilRun NilRun\nfunc (_e *MockNilRun_Expecter) Foo(nilRun interface{}) *MockNilRun_Foo_Call {\n\treturn &MockNilRun_Foo_Call{Call: _e.mock.On(\"Foo\", nilRun)}\n}\n\nfunc (_c *MockNilRun_Foo_Call) Run(run func(nilRun NilRun)) *MockNilRun_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 NilRun\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(NilRun)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockNilRun_Foo_Call) Return() *MockNilRun_Foo_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockNilRun_Foo_Call) RunAndReturn(run func(nilRun NilRun)) *MockNilRun_Foo_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockPanicOnNoReturnValue creates a new instance of MockPanicOnNoReturnValue. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockPanicOnNoReturnValue(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockPanicOnNoReturnValue {\n\tmock := &MockPanicOnNoReturnValue{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockPanicOnNoReturnValue is an autogenerated mock type for the PanicOnNoReturnValue type\ntype MockPanicOnNoReturnValue struct {\n\tmock.Mock\n}\n\ntype MockPanicOnNoReturnValue_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockPanicOnNoReturnValue) EXPECT() *MockPanicOnNoReturnValue_Expecter {\n\treturn &MockPanicOnNoReturnValue_Expecter{mock: &_m.Mock}\n}\n\n// DoSomething provides a mock function for the type MockPanicOnNoReturnValue\nfunc (_mock *MockPanicOnNoReturnValue) DoSomething() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for DoSomething\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockPanicOnNoReturnValue_DoSomething_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomething'\ntype MockPanicOnNoReturnValue_DoSomething_Call struct {\n\t*mock.Call\n}\n\n// DoSomething is a helper method to define mock.On call\nfunc (_e *MockPanicOnNoReturnValue_Expecter) DoSomething() *MockPanicOnNoReturnValue_DoSomething_Call {\n\treturn &MockPanicOnNoReturnValue_DoSomething_Call{Call: _e.mock.On(\"DoSomething\")}\n}\n\nfunc (_c *MockPanicOnNoReturnValue_DoSomething_Call) Run(run func()) *MockPanicOnNoReturnValue_DoSomething_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockPanicOnNoReturnValue_DoSomething_Call) Return(s string) *MockPanicOnNoReturnValue_DoSomething_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockPanicOnNoReturnValue_DoSomething_Call) RunAndReturn(run func() string) *MockPanicOnNoReturnValue_DoSomething_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequester creates a new instance of MockRequester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequester(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequester {\n\tmock := &MockRequester{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequester is an autogenerated mock type for the Requester type\ntype MockRequester struct {\n\tmock.Mock\n}\n\ntype MockRequester_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequester) EXPECT() *MockRequester_Expecter {\n\treturn &MockRequester_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequester\nfunc (_mock *MockRequester) Get(path string) (string, error) {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok {\n\t\treturn returnFunc(path)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) string); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(path)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockRequester_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequester_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\nfunc (_e *MockRequester_Expecter) Get(path interface{}) *MockRequester_Get_Call {\n\treturn &MockRequester_Get_Call{Call: _e.mock.On(\"Get\", path)}\n}\n\nfunc (_c *MockRequester_Get_Call) Run(run func(path string)) *MockRequester_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequester_Get_Call) Return(s string, err error) *MockRequester_Get_Call {\n\t_c.Call.Return(s, err)\n\treturn _c\n}\n\nfunc (_c *MockRequester_Get_Call) RunAndReturn(run func(path string) (string, error)) *MockRequester_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequester2 creates a new instance of MockRequester2. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequester2(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequester2 {\n\tmock := &MockRequester2{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequester2 is an autogenerated mock type for the Requester2 type\ntype MockRequester2 struct {\n\tmock.Mock\n}\n\ntype MockRequester2_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequester2) EXPECT() *MockRequester2_Expecter {\n\treturn &MockRequester2_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequester2\nfunc (_mock *MockRequester2) Get(path string) error {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(string) error); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockRequester2_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequester2_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\nfunc (_e *MockRequester2_Expecter) Get(path interface{}) *MockRequester2_Get_Call {\n\treturn &MockRequester2_Get_Call{Call: _e.mock.On(\"Get\", path)}\n}\n\nfunc (_c *MockRequester2_Get_Call) Run(run func(path string)) *MockRequester2_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequester2_Get_Call) Return(err error) *MockRequester2_Get_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockRequester2_Get_Call) RunAndReturn(run func(path string) error) *MockRequester2_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequester3 creates a new instance of MockRequester3. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequester3(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequester3 {\n\tmock := &MockRequester3{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequester3 is an autogenerated mock type for the Requester3 type\ntype MockRequester3 struct {\n\tmock.Mock\n}\n\ntype MockRequester3_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequester3) EXPECT() *MockRequester3_Expecter {\n\treturn &MockRequester3_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequester3\nfunc (_mock *MockRequester3) Get() error {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func() error); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockRequester3_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequester3_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockRequester3_Expecter) Get() *MockRequester3_Get_Call {\n\treturn &MockRequester3_Get_Call{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockRequester3_Get_Call) Run(run func()) *MockRequester3_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequester3_Get_Call) Return(err error) *MockRequester3_Get_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockRequester3_Get_Call) RunAndReturn(run func() error) *MockRequester3_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequester4 creates a new instance of MockRequester4. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequester4(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequester4 {\n\tmock := &MockRequester4{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequester4 is an autogenerated mock type for the Requester4 type\ntype MockRequester4 struct {\n\tmock.Mock\n}\n\ntype MockRequester4_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequester4) EXPECT() *MockRequester4_Expecter {\n\treturn &MockRequester4_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequester4\nfunc (_mock *MockRequester4) Get() {\n\t_mock.Called()\n\treturn\n}\n\n// MockRequester4_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequester4_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockRequester4_Expecter) Get() *MockRequester4_Get_Call {\n\treturn &MockRequester4_Get_Call{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockRequester4_Get_Call) Run(run func()) *MockRequester4_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequester4_Get_Call) Return() *MockRequester4_Get_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockRequester4_Get_Call) RunAndReturn(run func()) *MockRequester4_Get_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockRequesterArgSameAsImport creates a new instance of MockRequesterArgSameAsImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterArgSameAsImport(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterArgSameAsImport {\n\tmock := &MockRequesterArgSameAsImport{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterArgSameAsImport is an autogenerated mock type for the RequesterArgSameAsImport type\ntype MockRequesterArgSameAsImport struct {\n\tmock.Mock\n}\n\ntype MockRequesterArgSameAsImport_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterArgSameAsImport) EXPECT() *MockRequesterArgSameAsImport_Expecter {\n\treturn &MockRequesterArgSameAsImport_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterArgSameAsImport\nfunc (_mock *MockRequesterArgSameAsImport) Get(json1 string) *json.RawMessage {\n\tret := _mock.Called(json1)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 *json.RawMessage\n\tif returnFunc, ok := ret.Get(0).(func(string) *json.RawMessage); ok {\n\t\tr0 = returnFunc(json1)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(*json.RawMessage)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockRequesterArgSameAsImport_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterArgSameAsImport_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - json1 string\nfunc (_e *MockRequesterArgSameAsImport_Expecter) Get(json1 interface{}) *MockRequesterArgSameAsImport_Get_Call {\n\treturn &MockRequesterArgSameAsImport_Get_Call{Call: _e.mock.On(\"Get\", json1)}\n}\n\nfunc (_c *MockRequesterArgSameAsImport_Get_Call) Run(run func(json1 string)) *MockRequesterArgSameAsImport_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterArgSameAsImport_Get_Call) Return(rawMessage *json.RawMessage) *MockRequesterArgSameAsImport_Get_Call {\n\t_c.Call.Return(rawMessage)\n\treturn _c\n}\n\nfunc (_c *MockRequesterArgSameAsImport_Get_Call) RunAndReturn(run func(json1 string) *json.RawMessage) *MockRequesterArgSameAsImport_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterArgSameAsNamedImport creates a new instance of MockRequesterArgSameAsNamedImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterArgSameAsNamedImport(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterArgSameAsNamedImport {\n\tmock := &MockRequesterArgSameAsNamedImport{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterArgSameAsNamedImport is an autogenerated mock type for the RequesterArgSameAsNamedImport type\ntype MockRequesterArgSameAsNamedImport struct {\n\tmock.Mock\n}\n\ntype MockRequesterArgSameAsNamedImport_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterArgSameAsNamedImport) EXPECT() *MockRequesterArgSameAsNamedImport_Expecter {\n\treturn &MockRequesterArgSameAsNamedImport_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterArgSameAsNamedImport\nfunc (_mock *MockRequesterArgSameAsNamedImport) Get(json1 string) *json.RawMessage {\n\tret := _mock.Called(json1)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 *json.RawMessage\n\tif returnFunc, ok := ret.Get(0).(func(string) *json.RawMessage); ok {\n\t\tr0 = returnFunc(json1)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(*json.RawMessage)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockRequesterArgSameAsNamedImport_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterArgSameAsNamedImport_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - json1 string\nfunc (_e *MockRequesterArgSameAsNamedImport_Expecter) Get(json1 interface{}) *MockRequesterArgSameAsNamedImport_Get_Call {\n\treturn &MockRequesterArgSameAsNamedImport_Get_Call{Call: _e.mock.On(\"Get\", json1)}\n}\n\nfunc (_c *MockRequesterArgSameAsNamedImport_Get_Call) Run(run func(json1 string)) *MockRequesterArgSameAsNamedImport_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterArgSameAsNamedImport_Get_Call) Return(rawMessage *json.RawMessage) *MockRequesterArgSameAsNamedImport_Get_Call {\n\t_c.Call.Return(rawMessage)\n\treturn _c\n}\n\nfunc (_c *MockRequesterArgSameAsNamedImport_Get_Call) RunAndReturn(run func(json1 string) *json.RawMessage) *MockRequesterArgSameAsNamedImport_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterArgSameAsPkg creates a new instance of MockRequesterArgSameAsPkg. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterArgSameAsPkg(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterArgSameAsPkg {\n\tmock := &MockRequesterArgSameAsPkg{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterArgSameAsPkg is an autogenerated mock type for the RequesterArgSameAsPkg type\ntype MockRequesterArgSameAsPkg struct {\n\tmock.Mock\n}\n\ntype MockRequesterArgSameAsPkg_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterArgSameAsPkg) EXPECT() *MockRequesterArgSameAsPkg_Expecter {\n\treturn &MockRequesterArgSameAsPkg_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterArgSameAsPkg\nfunc (_mock *MockRequesterArgSameAsPkg) Get(test1 string) {\n\t_mock.Called(test1)\n\treturn\n}\n\n// MockRequesterArgSameAsPkg_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterArgSameAsPkg_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - test1 string\nfunc (_e *MockRequesterArgSameAsPkg_Expecter) Get(test1 interface{}) *MockRequesterArgSameAsPkg_Get_Call {\n\treturn &MockRequesterArgSameAsPkg_Get_Call{Call: _e.mock.On(\"Get\", test1)}\n}\n\nfunc (_c *MockRequesterArgSameAsPkg_Get_Call) Run(run func(test1 string)) *MockRequesterArgSameAsPkg_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterArgSameAsPkg_Get_Call) Return() *MockRequesterArgSameAsPkg_Get_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockRequesterArgSameAsPkg_Get_Call) RunAndReturn(run func(test1 string)) *MockRequesterArgSameAsPkg_Get_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockRequesterArray creates a new instance of MockRequesterArray. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterArray(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterArray {\n\tmock := &MockRequesterArray{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterArray is an autogenerated mock type for the RequesterArray type\ntype MockRequesterArray struct {\n\tmock.Mock\n}\n\ntype MockRequesterArray_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterArray) EXPECT() *MockRequesterArray_Expecter {\n\treturn &MockRequesterArray_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterArray\nfunc (_mock *MockRequesterArray) Get(path string) ([2]string, error) {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 [2]string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) ([2]string, error)); ok {\n\t\treturn returnFunc(path)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) [2]string); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).([2]string)\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(path)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockRequesterArray_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterArray_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\nfunc (_e *MockRequesterArray_Expecter) Get(path interface{}) *MockRequesterArray_Get_Call {\n\treturn &MockRequesterArray_Get_Call{Call: _e.mock.On(\"Get\", path)}\n}\n\nfunc (_c *MockRequesterArray_Get_Call) Run(run func(path string)) *MockRequesterArray_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterArray_Get_Call) Return(strings [2]string, err error) *MockRequesterArray_Get_Call {\n\t_c.Call.Return(strings, err)\n\treturn _c\n}\n\nfunc (_c *MockRequesterArray_Get_Call) RunAndReturn(run func(path string) ([2]string, error)) *MockRequesterArray_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterElided creates a new instance of MockRequesterElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterElided(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterElided {\n\tmock := &MockRequesterElided{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterElided is an autogenerated mock type for the RequesterElided type\ntype MockRequesterElided struct {\n\tmock.Mock\n}\n\ntype MockRequesterElided_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterElided) EXPECT() *MockRequesterElided_Expecter {\n\treturn &MockRequesterElided_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterElided\nfunc (_mock *MockRequesterElided) Get(path string, url string) error {\n\tret := _mock.Called(path, url)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(string, string) error); ok {\n\t\tr0 = returnFunc(path, url)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockRequesterElided_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterElided_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\n// - url string\nfunc (_e *MockRequesterElided_Expecter) Get(path interface{}, url interface{}) *MockRequesterElided_Get_Call {\n\treturn &MockRequesterElided_Get_Call{Call: _e.mock.On(\"Get\", path, url)}\n}\n\nfunc (_c *MockRequesterElided_Get_Call) Run(run func(path string, url string)) *MockRequesterElided_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 string\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterElided_Get_Call) Return(err error) *MockRequesterElided_Get_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockRequesterElided_Get_Call) RunAndReturn(run func(path string, url string) error) *MockRequesterElided_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterIface creates a new instance of MockRequesterIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterIface(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterIface {\n\tmock := &MockRequesterIface{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterIface is an autogenerated mock type for the RequesterIface type\ntype MockRequesterIface struct {\n\tmock.Mock\n}\n\ntype MockRequesterIface_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterIface) EXPECT() *MockRequesterIface_Expecter {\n\treturn &MockRequesterIface_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterIface\nfunc (_mock *MockRequesterIface) Get() io.Reader {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 io.Reader\n\tif returnFunc, ok := ret.Get(0).(func() io.Reader); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(io.Reader)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockRequesterIface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterIface_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockRequesterIface_Expecter) Get() *MockRequesterIface_Get_Call {\n\treturn &MockRequesterIface_Get_Call{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockRequesterIface_Get_Call) Run(run func()) *MockRequesterIface_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterIface_Get_Call) Return(reader io.Reader) *MockRequesterIface_Get_Call {\n\t_c.Call.Return(reader)\n\treturn _c\n}\n\nfunc (_c *MockRequesterIface_Get_Call) RunAndReturn(run func() io.Reader) *MockRequesterIface_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterNS creates a new instance of MockRequesterNS. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterNS(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterNS {\n\tmock := &MockRequesterNS{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterNS is an autogenerated mock type for the RequesterNS type\ntype MockRequesterNS struct {\n\tmock.Mock\n}\n\ntype MockRequesterNS_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterNS) EXPECT() *MockRequesterNS_Expecter {\n\treturn &MockRequesterNS_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterNS\nfunc (_mock *MockRequesterNS) Get(path string) (http.Response, error) {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 http.Response\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) (http.Response, error)); ok {\n\t\treturn returnFunc(path)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) http.Response); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tr0 = ret.Get(0).(http.Response)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(path)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockRequesterNS_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterNS_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\nfunc (_e *MockRequesterNS_Expecter) Get(path interface{}) *MockRequesterNS_Get_Call {\n\treturn &MockRequesterNS_Get_Call{Call: _e.mock.On(\"Get\", path)}\n}\n\nfunc (_c *MockRequesterNS_Get_Call) Run(run func(path string)) *MockRequesterNS_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterNS_Get_Call) Return(response http.Response, err error) *MockRequesterNS_Get_Call {\n\t_c.Call.Return(response, err)\n\treturn _c\n}\n\nfunc (_c *MockRequesterNS_Get_Call) RunAndReturn(run func(path string) (http.Response, error)) *MockRequesterNS_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterPtr creates a new instance of MockRequesterPtr. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterPtr(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterPtr {\n\tmock := &MockRequesterPtr{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterPtr is an autogenerated mock type for the RequesterPtr type\ntype MockRequesterPtr struct {\n\tmock.Mock\n}\n\ntype MockRequesterPtr_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterPtr) EXPECT() *MockRequesterPtr_Expecter {\n\treturn &MockRequesterPtr_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterPtr\nfunc (_mock *MockRequesterPtr) Get(path string) (*string, error) {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 *string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) (*string, error)); ok {\n\t\treturn returnFunc(path)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) *string); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(*string)\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(path)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockRequesterPtr_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterPtr_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\nfunc (_e *MockRequesterPtr_Expecter) Get(path interface{}) *MockRequesterPtr_Get_Call {\n\treturn &MockRequesterPtr_Get_Call{Call: _e.mock.On(\"Get\", path)}\n}\n\nfunc (_c *MockRequesterPtr_Get_Call) Run(run func(path string)) *MockRequesterPtr_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterPtr_Get_Call) Return(s *string, err error) *MockRequesterPtr_Get_Call {\n\t_c.Call.Return(s, err)\n\treturn _c\n}\n\nfunc (_c *MockRequesterPtr_Get_Call) RunAndReturn(run func(path string) (*string, error)) *MockRequesterPtr_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterReturnElided creates a new instance of MockRequesterReturnElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterReturnElided(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterReturnElided {\n\tmock := &MockRequesterReturnElided{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterReturnElided is an autogenerated mock type for the RequesterReturnElided type\ntype MockRequesterReturnElided struct {\n\tmock.Mock\n}\n\ntype MockRequesterReturnElided_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterReturnElided) EXPECT() *MockRequesterReturnElided_Expecter {\n\treturn &MockRequesterReturnElided_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterReturnElided\nfunc (_mock *MockRequesterReturnElided) Get(path string) (int, int, int, error) {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 int\n\tvar r1 int\n\tvar r2 int\n\tvar r3 error\n\tif returnFunc, ok := ret.Get(0).(func(string) (int, int, int, error)); ok {\n\t\treturn returnFunc(path)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) int); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) int); ok {\n\t\tr1 = returnFunc(path)\n\t} else {\n\t\tr1 = ret.Get(1).(int)\n\t}\n\tif returnFunc, ok := ret.Get(2).(func(string) int); ok {\n\t\tr2 = returnFunc(path)\n\t} else {\n\t\tr2 = ret.Get(2).(int)\n\t}\n\tif returnFunc, ok := ret.Get(3).(func(string) error); ok {\n\t\tr3 = returnFunc(path)\n\t} else {\n\t\tr3 = ret.Error(3)\n\t}\n\treturn r0, r1, r2, r3\n}\n\n// MockRequesterReturnElided_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterReturnElided_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\nfunc (_e *MockRequesterReturnElided_Expecter) Get(path interface{}) *MockRequesterReturnElided_Get_Call {\n\treturn &MockRequesterReturnElided_Get_Call{Call: _e.mock.On(\"Get\", path)}\n}\n\nfunc (_c *MockRequesterReturnElided_Get_Call) Run(run func(path string)) *MockRequesterReturnElided_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterReturnElided_Get_Call) Return(a int, b int, c int, err error) *MockRequesterReturnElided_Get_Call {\n\t_c.Call.Return(a, b, c, err)\n\treturn _c\n}\n\nfunc (_c *MockRequesterReturnElided_Get_Call) RunAndReturn(run func(path string) (int, int, int, error)) *MockRequesterReturnElided_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Put provides a mock function for the type MockRequesterReturnElided\nfunc (_mock *MockRequesterReturnElided) Put(path string) (int, error) {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Put\")\n\t}\n\n\tvar r0 int\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) (int, error)); ok {\n\t\treturn returnFunc(path)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) int); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tr0 = ret.Get(0).(int)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(path)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockRequesterReturnElided_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put'\ntype MockRequesterReturnElided_Put_Call struct {\n\t*mock.Call\n}\n\n// Put is a helper method to define mock.On call\n// - path string\nfunc (_e *MockRequesterReturnElided_Expecter) Put(path interface{}) *MockRequesterReturnElided_Put_Call {\n\treturn &MockRequesterReturnElided_Put_Call{Call: _e.mock.On(\"Put\", path)}\n}\n\nfunc (_c *MockRequesterReturnElided_Put_Call) Run(run func(path string)) *MockRequesterReturnElided_Put_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterReturnElided_Put_Call) Return(n int, err error) *MockRequesterReturnElided_Put_Call {\n\t_c.Call.Return(n, err)\n\treturn _c\n}\n\nfunc (_c *MockRequesterReturnElided_Put_Call) RunAndReturn(run func(path string) (int, error)) *MockRequesterReturnElided_Put_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterSlice creates a new instance of MockRequesterSlice. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterSlice(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterSlice {\n\tmock := &MockRequesterSlice{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterSlice is an autogenerated mock type for the RequesterSlice type\ntype MockRequesterSlice struct {\n\tmock.Mock\n}\n\ntype MockRequesterSlice_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterSlice) EXPECT() *MockRequesterSlice_Expecter {\n\treturn &MockRequesterSlice_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterSlice\nfunc (_mock *MockRequesterSlice) Get(path string) ([]string, error) {\n\tret := _mock.Called(path)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 []string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string) ([]string, error)); ok {\n\t\treturn returnFunc(path)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string) []string); ok {\n\t\tr0 = returnFunc(path)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).([]string)\n\t\t}\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string) error); ok {\n\t\tr1 = returnFunc(path)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockRequesterSlice_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterSlice_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - path string\nfunc (_e *MockRequesterSlice_Expecter) Get(path interface{}) *MockRequesterSlice_Get_Call {\n\treturn &MockRequesterSlice_Get_Call{Call: _e.mock.On(\"Get\", path)}\n}\n\nfunc (_c *MockRequesterSlice_Get_Call) Run(run func(path string)) *MockRequesterSlice_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterSlice_Get_Call) Return(strings []string, err error) *MockRequesterSlice_Get_Call {\n\t_c.Call.Return(strings, err)\n\treturn _c\n}\n\nfunc (_c *MockRequesterSlice_Get_Call) RunAndReturn(run func(path string) ([]string, error)) *MockRequesterSlice_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// newMockrequesterUnexported creates a new instance of mockrequesterUnexported. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc newMockrequesterUnexported(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *mockrequesterUnexported {\n\tmock := &mockrequesterUnexported{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// mockrequesterUnexported is an autogenerated mock type for the requesterUnexported type\ntype mockrequesterUnexported struct {\n\tmock.Mock\n}\n\ntype mockrequesterUnexported_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *mockrequesterUnexported) EXPECT() *mockrequesterUnexported_Expecter {\n\treturn &mockrequesterUnexported_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type mockrequesterUnexported\nfunc (_mock *mockrequesterUnexported) Get() {\n\t_mock.Called()\n\treturn\n}\n\n// mockrequesterUnexported_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype mockrequesterUnexported_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *mockrequesterUnexported_Expecter) Get() *mockrequesterUnexported_Get_Call {\n\treturn &mockrequesterUnexported_Get_Call{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *mockrequesterUnexported_Get_Call) Run(run func()) *mockrequesterUnexported_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *mockrequesterUnexported_Get_Call) Return() *mockrequesterUnexported_Get_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *mockrequesterUnexported_Get_Call) RunAndReturn(run func()) *mockrequesterUnexported_Get_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockRequesterVariadicOneArgument creates a new instance of MockRequesterVariadicOneArgument. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterVariadicOneArgument(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterVariadicOneArgument {\n\tmock := &MockRequesterVariadicOneArgument{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterVariadicOneArgument is an autogenerated mock type for the RequesterVariadic type\ntype MockRequesterVariadicOneArgument struct {\n\tmock.Mock\n}\n\ntype MockRequesterVariadicOneArgument_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterVariadicOneArgument) EXPECT() *MockRequesterVariadicOneArgument_Expecter {\n\treturn &MockRequesterVariadicOneArgument_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterVariadicOneArgument\nfunc (_mock *MockRequesterVariadicOneArgument) Get(values ...string) bool {\n\tvar tmpRet mock.Arguments\n\tif len(values) > 0 {\n\t\ttmpRet = _mock.Called(values)\n\t} else {\n\t\ttmpRet = _mock.Called()\n\t}\n\tret := tmpRet\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 bool\n\tif returnFunc, ok := ret.Get(0).(func(...string) bool); ok {\n\t\tr0 = returnFunc(values...)\n\t} else {\n\t\tr0 = ret.Get(0).(bool)\n\t}\n\treturn r0\n}\n\n// MockRequesterVariadicOneArgument_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterVariadicOneArgument_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - values ...string\nfunc (_e *MockRequesterVariadicOneArgument_Expecter) Get(values ...interface{}) *MockRequesterVariadicOneArgument_Get_Call {\n\treturn &MockRequesterVariadicOneArgument_Get_Call{Call: _e.mock.On(\"Get\",\n\t\tappend([]interface{}{}, values...)...)}\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_Get_Call) Run(run func(values ...string)) *MockRequesterVariadicOneArgument_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []string\n\t\tvar variadicArgs []string\n\t\tif len(args) > 0 {\n\t\t\tvariadicArgs = args[0].([]string)\n\t\t}\n\t\targ0 = variadicArgs\n\t\trun(\n\t\t\targ0...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_Get_Call) Return(b bool) *MockRequesterVariadicOneArgument_Get_Call {\n\t_c.Call.Return(b)\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_Get_Call) RunAndReturn(run func(values ...string) bool) *MockRequesterVariadicOneArgument_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// MultiWriteToFile provides a mock function for the type MockRequesterVariadicOneArgument\nfunc (_mock *MockRequesterVariadicOneArgument) MultiWriteToFile(filename string, w ...io.Writer) string {\n\tvar tmpRet mock.Arguments\n\tif len(w) > 0 {\n\t\ttmpRet = _mock.Called(filename, w)\n\t} else {\n\t\ttmpRet = _mock.Called(filename)\n\t}\n\tret := tmpRet\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for MultiWriteToFile\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func(string, ...io.Writer) string); ok {\n\t\tr0 = returnFunc(filename, w...)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockRequesterVariadicOneArgument_MultiWriteToFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiWriteToFile'\ntype MockRequesterVariadicOneArgument_MultiWriteToFile_Call struct {\n\t*mock.Call\n}\n\n// MultiWriteToFile is a helper method to define mock.On call\n// - filename string\n// - w ...io.Writer\nfunc (_e *MockRequesterVariadicOneArgument_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call {\n\treturn &MockRequesterVariadicOneArgument_MultiWriteToFile_Call{Call: _e.mock.On(\"MultiWriteToFile\",\n\t\tappend([]interface{}{filename}, w...)...)}\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 []io.Writer\n\t\tvar variadicArgs []io.Writer\n\t\tif len(args) > 1 {\n\t\t\tvariadicArgs = args[1].([]io.Writer)\n\t\t}\n\t\targ1 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) Return(s string) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer) string) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// OneInterface provides a mock function for the type MockRequesterVariadicOneArgument\nfunc (_mock *MockRequesterVariadicOneArgument) OneInterface(a ...interface{}) bool {\n\tvar tmpRet mock.Arguments\n\tif len(a) > 0 {\n\t\ttmpRet = _mock.Called(a)\n\t} else {\n\t\ttmpRet = _mock.Called()\n\t}\n\tret := tmpRet\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for OneInterface\")\n\t}\n\n\tvar r0 bool\n\tif returnFunc, ok := ret.Get(0).(func(...interface{}) bool); ok {\n\t\tr0 = returnFunc(a...)\n\t} else {\n\t\tr0 = ret.Get(0).(bool)\n\t}\n\treturn r0\n}\n\n// MockRequesterVariadicOneArgument_OneInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OneInterface'\ntype MockRequesterVariadicOneArgument_OneInterface_Call struct {\n\t*mock.Call\n}\n\n// OneInterface is a helper method to define mock.On call\n// - a ...interface{}\nfunc (_e *MockRequesterVariadicOneArgument_Expecter) OneInterface(a ...interface{}) *MockRequesterVariadicOneArgument_OneInterface_Call {\n\treturn &MockRequesterVariadicOneArgument_OneInterface_Call{Call: _e.mock.On(\"OneInterface\",\n\t\tappend([]interface{}{}, a...)...)}\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_OneInterface_Call) Run(run func(a ...interface{})) *MockRequesterVariadicOneArgument_OneInterface_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []interface{}\n\t\tvar variadicArgs []interface{}\n\t\tif len(args) > 0 {\n\t\t\tvariadicArgs = args[0].([]interface{})\n\t\t}\n\t\targ0 = variadicArgs\n\t\trun(\n\t\t\targ0...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_OneInterface_Call) Return(b bool) *MockRequesterVariadicOneArgument_OneInterface_Call {\n\t_c.Call.Return(b)\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_OneInterface_Call) RunAndReturn(run func(a ...interface{}) bool) *MockRequesterVariadicOneArgument_OneInterface_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Sprintf provides a mock function for the type MockRequesterVariadicOneArgument\nfunc (_mock *MockRequesterVariadicOneArgument) Sprintf(format string, a ...interface{}) string {\n\tvar tmpRet mock.Arguments\n\tif len(a) > 0 {\n\t\ttmpRet = _mock.Called(format, a)\n\t} else {\n\t\ttmpRet = _mock.Called(format)\n\t}\n\tret := tmpRet\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Sprintf\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func(string, ...interface{}) string); ok {\n\t\tr0 = returnFunc(format, a...)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockRequesterVariadicOneArgument_Sprintf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sprintf'\ntype MockRequesterVariadicOneArgument_Sprintf_Call struct {\n\t*mock.Call\n}\n\n// Sprintf is a helper method to define mock.On call\n// - format string\n// - a ...interface{}\nfunc (_e *MockRequesterVariadicOneArgument_Expecter) Sprintf(format interface{}, a ...interface{}) *MockRequesterVariadicOneArgument_Sprintf_Call {\n\treturn &MockRequesterVariadicOneArgument_Sprintf_Call{Call: _e.mock.On(\"Sprintf\",\n\t\tappend([]interface{}{format}, a...)...)}\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_Sprintf_Call) Run(run func(format string, a ...interface{})) *MockRequesterVariadicOneArgument_Sprintf_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 []interface{}\n\t\tvar variadicArgs []interface{}\n\t\tif len(args) > 1 {\n\t\t\tvariadicArgs = args[1].([]interface{})\n\t\t}\n\t\targ1 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_Sprintf_Call) Return(s string) *MockRequesterVariadicOneArgument_Sprintf_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadicOneArgument_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{}) string) *MockRequesterVariadicOneArgument_Sprintf_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockRequesterVariadic creates a new instance of MockRequesterVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockRequesterVariadic(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockRequesterVariadic {\n\tmock := &MockRequesterVariadic{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockRequesterVariadic is an autogenerated mock type for the RequesterVariadic type\ntype MockRequesterVariadic struct {\n\tmock.Mock\n}\n\ntype MockRequesterVariadic_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockRequesterVariadic) EXPECT() *MockRequesterVariadic_Expecter {\n\treturn &MockRequesterVariadic_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockRequesterVariadic\nfunc (_mock *MockRequesterVariadic) Get(values ...string) bool {\n\t// string\n\t_va := make([]interface{}, len(values))\n\tfor _i := range values {\n\t\t_va[_i] = values[_i]\n\t}\n\tvar _ca []interface{}\n\t_ca = append(_ca, _va...)\n\tret := _mock.Called(_ca...)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 bool\n\tif returnFunc, ok := ret.Get(0).(func(...string) bool); ok {\n\t\tr0 = returnFunc(values...)\n\t} else {\n\t\tr0 = ret.Get(0).(bool)\n\t}\n\treturn r0\n}\n\n// MockRequesterVariadic_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockRequesterVariadic_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\n// - values ...string\nfunc (_e *MockRequesterVariadic_Expecter) Get(values ...interface{}) *MockRequesterVariadic_Get_Call {\n\treturn &MockRequesterVariadic_Get_Call{Call: _e.mock.On(\"Get\",\n\t\tappend([]interface{}{}, values...)...)}\n}\n\nfunc (_c *MockRequesterVariadic_Get_Call) Run(run func(values ...string)) *MockRequesterVariadic_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []string\n\t\tvariadicArgs := make([]string, len(args)-0)\n\t\tfor i, a := range args[0:] {\n\t\t\tif a != nil {\n\t\t\t\tvariadicArgs[i] = a.(string)\n\t\t\t}\n\t\t}\n\t\targ0 = variadicArgs\n\t\trun(\n\t\t\targ0...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadic_Get_Call) Return(b bool) *MockRequesterVariadic_Get_Call {\n\t_c.Call.Return(b)\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadic_Get_Call) RunAndReturn(run func(values ...string) bool) *MockRequesterVariadic_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// MultiWriteToFile provides a mock function for the type MockRequesterVariadic\nfunc (_mock *MockRequesterVariadic) MultiWriteToFile(filename string, w ...io.Writer) string {\n\t// io.Writer\n\t_va := make([]interface{}, len(w))\n\tfor _i := range w {\n\t\t_va[_i] = w[_i]\n\t}\n\tvar _ca []interface{}\n\t_ca = append(_ca, filename)\n\t_ca = append(_ca, _va...)\n\tret := _mock.Called(_ca...)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for MultiWriteToFile\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func(string, ...io.Writer) string); ok {\n\t\tr0 = returnFunc(filename, w...)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockRequesterVariadic_MultiWriteToFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiWriteToFile'\ntype MockRequesterVariadic_MultiWriteToFile_Call struct {\n\t*mock.Call\n}\n\n// MultiWriteToFile is a helper method to define mock.On call\n// - filename string\n// - w ...io.Writer\nfunc (_e *MockRequesterVariadic_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}) *MockRequesterVariadic_MultiWriteToFile_Call {\n\treturn &MockRequesterVariadic_MultiWriteToFile_Call{Call: _e.mock.On(\"MultiWriteToFile\",\n\t\tappend([]interface{}{filename}, w...)...)}\n}\n\nfunc (_c *MockRequesterVariadic_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *MockRequesterVariadic_MultiWriteToFile_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 []io.Writer\n\t\tvariadicArgs := make([]io.Writer, len(args)-1)\n\t\tfor i, a := range args[1:] {\n\t\t\tif a != nil {\n\t\t\t\tvariadicArgs[i] = a.(io.Writer)\n\t\t\t}\n\t\t}\n\t\targ1 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadic_MultiWriteToFile_Call) Return(s string) *MockRequesterVariadic_MultiWriteToFile_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadic_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer) string) *MockRequesterVariadic_MultiWriteToFile_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// OneInterface provides a mock function for the type MockRequesterVariadic\nfunc (_mock *MockRequesterVariadic) OneInterface(a ...interface{}) bool {\n\tvar _ca []interface{}\n\t_ca = append(_ca, a...)\n\tret := _mock.Called(_ca...)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for OneInterface\")\n\t}\n\n\tvar r0 bool\n\tif returnFunc, ok := ret.Get(0).(func(...interface{}) bool); ok {\n\t\tr0 = returnFunc(a...)\n\t} else {\n\t\tr0 = ret.Get(0).(bool)\n\t}\n\treturn r0\n}\n\n// MockRequesterVariadic_OneInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OneInterface'\ntype MockRequesterVariadic_OneInterface_Call struct {\n\t*mock.Call\n}\n\n// OneInterface is a helper method to define mock.On call\n// - a ...interface{}\nfunc (_e *MockRequesterVariadic_Expecter) OneInterface(a ...interface{}) *MockRequesterVariadic_OneInterface_Call {\n\treturn &MockRequesterVariadic_OneInterface_Call{Call: _e.mock.On(\"OneInterface\",\n\t\tappend([]interface{}{}, a...)...)}\n}\n\nfunc (_c *MockRequesterVariadic_OneInterface_Call) Run(run func(a ...interface{})) *MockRequesterVariadic_OneInterface_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 []interface{}\n\t\tvariadicArgs := make([]interface{}, len(args)-0)\n\t\tfor i, a := range args[0:] {\n\t\t\tif a != nil {\n\t\t\t\tvariadicArgs[i] = a.(interface{})\n\t\t\t}\n\t\t}\n\t\targ0 = variadicArgs\n\t\trun(\n\t\t\targ0...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadic_OneInterface_Call) Return(b bool) *MockRequesterVariadic_OneInterface_Call {\n\t_c.Call.Return(b)\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadic_OneInterface_Call) RunAndReturn(run func(a ...interface{}) bool) *MockRequesterVariadic_OneInterface_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// Sprintf provides a mock function for the type MockRequesterVariadic\nfunc (_mock *MockRequesterVariadic) Sprintf(format string, a ...interface{}) string {\n\tvar _ca []interface{}\n\t_ca = append(_ca, format)\n\t_ca = append(_ca, a...)\n\tret := _mock.Called(_ca...)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Sprintf\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func(string, ...interface{}) string); ok {\n\t\tr0 = returnFunc(format, a...)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockRequesterVariadic_Sprintf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sprintf'\ntype MockRequesterVariadic_Sprintf_Call struct {\n\t*mock.Call\n}\n\n// Sprintf is a helper method to define mock.On call\n// - format string\n// - a ...interface{}\nfunc (_e *MockRequesterVariadic_Expecter) Sprintf(format interface{}, a ...interface{}) *MockRequesterVariadic_Sprintf_Call {\n\treturn &MockRequesterVariadic_Sprintf_Call{Call: _e.mock.On(\"Sprintf\",\n\t\tappend([]interface{}{format}, a...)...)}\n}\n\nfunc (_c *MockRequesterVariadic_Sprintf_Call) Run(run func(format string, a ...interface{})) *MockRequesterVariadic_Sprintf_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 []interface{}\n\t\tvariadicArgs := make([]interface{}, len(args)-1)\n\t\tfor i, a := range args[1:] {\n\t\t\tif a != nil {\n\t\t\t\tvariadicArgs[i] = a.(interface{})\n\t\t\t}\n\t\t}\n\t\targ1 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadic_Sprintf_Call) Return(s string) *MockRequesterVariadic_Sprintf_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockRequesterVariadic_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{}) string) *MockRequesterVariadic_Sprintf_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockExample creates a new instance of MockExample. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockExample(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockExample {\n\tmock := &MockExample{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockExample is an autogenerated mock type for the Example type\ntype MockExample struct {\n\tmock.Mock\n}\n\ntype MockExample_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockExample) EXPECT() *MockExample_Expecter {\n\treturn &MockExample_Expecter{mock: &_m.Mock}\n}\n\n// A provides a mock function for the type MockExample\nfunc (_mock *MockExample) A() http.Flusher {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for A\")\n\t}\n\n\tvar r0 http.Flusher\n\tif returnFunc, ok := ret.Get(0).(func() http.Flusher); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(http.Flusher)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockExample_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'\ntype MockExample_A_Call struct {\n\t*mock.Call\n}\n\n// A is a helper method to define mock.On call\nfunc (_e *MockExample_Expecter) A() *MockExample_A_Call {\n\treturn &MockExample_A_Call{Call: _e.mock.On(\"A\")}\n}\n\nfunc (_c *MockExample_A_Call) Run(run func()) *MockExample_A_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExample_A_Call) Return(flusher http.Flusher) *MockExample_A_Call {\n\t_c.Call.Return(flusher)\n\treturn _c\n}\n\nfunc (_c *MockExample_A_Call) RunAndReturn(run func() http.Flusher) *MockExample_A_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// B provides a mock function for the type MockExample\nfunc (_mock *MockExample) B(fixtureshttp string) http0.MyStruct {\n\tret := _mock.Called(fixtureshttp)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for B\")\n\t}\n\n\tvar r0 http0.MyStruct\n\tif returnFunc, ok := ret.Get(0).(func(string) http0.MyStruct); ok {\n\t\tr0 = returnFunc(fixtureshttp)\n\t} else {\n\t\tr0 = ret.Get(0).(http0.MyStruct)\n\t}\n\treturn r0\n}\n\n// MockExample_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B'\ntype MockExample_B_Call struct {\n\t*mock.Call\n}\n\n// B is a helper method to define mock.On call\n// - fixtureshttp string\nfunc (_e *MockExample_Expecter) B(fixtureshttp interface{}) *MockExample_B_Call {\n\treturn &MockExample_B_Call{Call: _e.mock.On(\"B\", fixtureshttp)}\n}\n\nfunc (_c *MockExample_B_Call) Run(run func(fixtureshttp string)) *MockExample_B_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExample_B_Call) Return(myStruct http0.MyStruct) *MockExample_B_Call {\n\t_c.Call.Return(myStruct)\n\treturn _c\n}\n\nfunc (_c *MockExample_B_Call) RunAndReturn(run func(fixtureshttp string) http0.MyStruct) *MockExample_B_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// C provides a mock function for the type MockExample\nfunc (_mock *MockExample) C(fixtureshttp string) http1.MyStruct {\n\tret := _mock.Called(fixtureshttp)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for C\")\n\t}\n\n\tvar r0 http1.MyStruct\n\tif returnFunc, ok := ret.Get(0).(func(string) http1.MyStruct); ok {\n\t\tr0 = returnFunc(fixtureshttp)\n\t} else {\n\t\tr0 = ret.Get(0).(http1.MyStruct)\n\t}\n\treturn r0\n}\n\n// MockExample_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'\ntype MockExample_C_Call struct {\n\t*mock.Call\n}\n\n// C is a helper method to define mock.On call\n// - fixtureshttp string\nfunc (_e *MockExample_Expecter) C(fixtureshttp interface{}) *MockExample_C_Call {\n\treturn &MockExample_C_Call{Call: _e.mock.On(\"C\", fixtureshttp)}\n}\n\nfunc (_c *MockExample_C_Call) Run(run func(fixtureshttp string)) *MockExample_C_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockExample_C_Call) Return(myStruct http1.MyStruct) *MockExample_C_Call {\n\t_c.Call.Return(myStruct)\n\treturn _c\n}\n\nfunc (_c *MockExample_C_Call) RunAndReturn(run func(fixtureshttp string) http1.MyStruct) *MockExample_C_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockA creates a new instance of MockA. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockA(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockA {\n\tmock := &MockA{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockA is an autogenerated mock type for the A type\ntype MockA struct {\n\tmock.Mock\n}\n\ntype MockA_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockA) EXPECT() *MockA_Expecter {\n\treturn &MockA_Expecter{mock: &_m.Mock}\n}\n\n// Call provides a mock function for the type MockA\nfunc (_mock *MockA) Call() (B, error) {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Call\")\n\t}\n\n\tvar r0 B\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func() (B, error)); ok {\n\t\treturn returnFunc()\n\t}\n\tif returnFunc, ok := ret.Get(0).(func() B); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(B)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func() error); ok {\n\t\tr1 = returnFunc()\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockA_Call_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Call'\ntype MockA_Call_Call struct {\n\t*mock.Call\n}\n\n// Call is a helper method to define mock.On call\nfunc (_e *MockA_Expecter) Call() *MockA_Call_Call {\n\treturn &MockA_Call_Call{Call: _e.mock.On(\"Call\")}\n}\n\nfunc (_c *MockA_Call_Call) Run(run func()) *MockA_Call_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockA_Call_Call) Return(b B, err error) *MockA_Call_Call {\n\t_c.Call.Return(b, err)\n\treturn _c\n}\n\nfunc (_c *MockA_Call_Call) RunAndReturn(run func() (B, error)) *MockA_Call_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockStructWithTag creates a new instance of MockStructWithTag. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockStructWithTag(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockStructWithTag {\n\tmock := &MockStructWithTag{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockStructWithTag is an autogenerated mock type for the StructWithTag type\ntype MockStructWithTag struct {\n\tmock.Mock\n}\n\ntype MockStructWithTag_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockStructWithTag) EXPECT() *MockStructWithTag_Expecter {\n\treturn &MockStructWithTag_Expecter{mock: &_m.Mock}\n}\n\n// MethodA provides a mock function for the type MockStructWithTag\nfunc (_mock *MockStructWithTag) MethodA(v *struct {\n\tFieldA int \"json:\\\"field_a\\\"\"\n\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n}) *struct {\n\tFieldC int \"json:\\\"field_c\\\"\"\n\tFieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"\n} {\n\tret := _mock.Called(v)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for MethodA\")\n\t}\n\n\tvar r0 *struct {\n\t\tFieldC int \"json:\\\"field_c\\\"\"\n\t\tFieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(*struct {\n\t\tFieldA int \"json:\\\"field_a\\\"\"\n\t\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n\t}) *struct {\n\t\tFieldC int \"json:\\\"field_c\\\"\"\n\t\tFieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"\n\t}); ok {\n\t\tr0 = returnFunc(v)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(*struct {\n\t\t\t\tFieldC int \"json:\\\"field_c\\\"\"\n\t\t\t\tFieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"\n\t\t\t})\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockStructWithTag_MethodA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MethodA'\ntype MockStructWithTag_MethodA_Call struct {\n\t*mock.Call\n}\n\n// MethodA is a helper method to define mock.On call\n// - v *struct{FieldA int \"json:\\\"field_a\\\"\"; FieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"}\nfunc (_e *MockStructWithTag_Expecter) MethodA(v interface{}) *MockStructWithTag_MethodA_Call {\n\treturn &MockStructWithTag_MethodA_Call{Call: _e.mock.On(\"MethodA\", v)}\n}\n\nfunc (_c *MockStructWithTag_MethodA_Call) Run(run func(v *struct {\n\tFieldA int \"json:\\\"field_a\\\"\"\n\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n})) *MockStructWithTag_MethodA_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 *struct {\n\t\t\tFieldA int \"json:\\\"field_a\\\"\"\n\t\t\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n\t\t}\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(*struct {\n\t\t\t\tFieldA int \"json:\\\"field_a\\\"\"\n\t\t\t\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n\t\t\t})\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockStructWithTag_MethodA_Call) Return(val *struct {\n\tFieldC int \"json:\\\"field_c\\\"\"\n\tFieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"\n}) *MockStructWithTag_MethodA_Call {\n\t_c.Call.Return(val)\n\treturn _c\n}\n\nfunc (_c *MockStructWithTag_MethodA_Call) RunAndReturn(run func(v *struct {\n\tFieldA int \"json:\\\"field_a\\\"\"\n\tFieldB int \"json:\\\"field_b\\\" xml:\\\"field_b\\\"\"\n}) *struct {\n\tFieldC int \"json:\\\"field_c\\\"\"\n\tFieldD int \"json:\\\"field_d\\\" xml:\\\"field_d\\\"\"\n}) *MockStructWithTag_MethodA_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockUnsafeInterface creates a new instance of MockUnsafeInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockUnsafeInterface(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockUnsafeInterface {\n\tmock := &MockUnsafeInterface{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockUnsafeInterface is an autogenerated mock type for the UnsafeInterface type\ntype MockUnsafeInterface struct {\n\tmock.Mock\n}\n\ntype MockUnsafeInterface_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockUnsafeInterface) EXPECT() *MockUnsafeInterface_Expecter {\n\treturn &MockUnsafeInterface_Expecter{mock: &_m.Mock}\n}\n\n// Do provides a mock function for the type MockUnsafeInterface\nfunc (_mock *MockUnsafeInterface) Do(ptr *unsafe.Pointer) {\n\t_mock.Called(ptr)\n\treturn\n}\n\n// MockUnsafeInterface_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'\ntype MockUnsafeInterface_Do_Call struct {\n\t*mock.Call\n}\n\n// Do is a helper method to define mock.On call\n// - ptr *unsafe.Pointer\nfunc (_e *MockUnsafeInterface_Expecter) Do(ptr interface{}) *MockUnsafeInterface_Do_Call {\n\treturn &MockUnsafeInterface_Do_Call{Call: _e.mock.On(\"Do\", ptr)}\n}\n\nfunc (_c *MockUnsafeInterface_Do_Call) Run(run func(ptr *unsafe.Pointer)) *MockUnsafeInterface_Do_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 *unsafe.Pointer\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(*unsafe.Pointer)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockUnsafeInterface_Do_Call) Return() *MockUnsafeInterface_Do_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockUnsafeInterface_Do_Call) RunAndReturn(run func(ptr *unsafe.Pointer)) *MockUnsafeInterface_Do_Call {\n\t_c.Run(run)\n\treturn _c\n}\n\n// NewMockVariadic creates a new instance of MockVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockVariadic(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockVariadic {\n\tmock := &MockVariadic{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockVariadic is an autogenerated mock type for the Variadic type\ntype MockVariadic struct {\n\tmock.Mock\n}\n\ntype MockVariadic_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockVariadic) EXPECT() *MockVariadic_Expecter {\n\treturn &MockVariadic_Expecter{mock: &_m.Mock}\n}\n\n// VariadicFunction provides a mock function for the type MockVariadic\nfunc (_mock *MockVariadic) VariadicFunction(str string, vFunc VariadicFunction) error {\n\tret := _mock.Called(str, vFunc)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for VariadicFunction\")\n\t}\n\n\tvar r0 error\n\tif returnFunc, ok := ret.Get(0).(func(string, VariadicFunction) error); ok {\n\t\tr0 = returnFunc(str, vFunc)\n\t} else {\n\t\tr0 = ret.Error(0)\n\t}\n\treturn r0\n}\n\n// MockVariadic_VariadicFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicFunction'\ntype MockVariadic_VariadicFunction_Call struct {\n\t*mock.Call\n}\n\n// VariadicFunction is a helper method to define mock.On call\n// - str string\n// - vFunc VariadicFunction\nfunc (_e *MockVariadic_Expecter) VariadicFunction(str interface{}, vFunc interface{}) *MockVariadic_VariadicFunction_Call {\n\treturn &MockVariadic_VariadicFunction_Call{Call: _e.mock.On(\"VariadicFunction\", str, vFunc)}\n}\n\nfunc (_c *MockVariadic_VariadicFunction_Call) Run(run func(str string, vFunc VariadicFunction)) *MockVariadic_VariadicFunction_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 VariadicFunction\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(VariadicFunction)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockVariadic_VariadicFunction_Call) Return(err error) *MockVariadic_VariadicFunction_Call {\n\t_c.Call.Return(err)\n\treturn _c\n}\n\nfunc (_c *MockVariadic_VariadicFunction_Call) RunAndReturn(run func(str string, vFunc VariadicFunction) error) *MockVariadic_VariadicFunction_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockVariadicReturnFunc creates a new instance of MockVariadicReturnFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockVariadicReturnFunc(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockVariadicReturnFunc {\n\tmock := &MockVariadicReturnFunc{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockVariadicReturnFunc is an autogenerated mock type for the VariadicReturnFunc type\ntype MockVariadicReturnFunc struct {\n\tmock.Mock\n}\n\ntype MockVariadicReturnFunc_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockVariadicReturnFunc) EXPECT() *MockVariadicReturnFunc_Expecter {\n\treturn &MockVariadicReturnFunc_Expecter{mock: &_m.Mock}\n}\n\n// SampleMethod provides a mock function for the type MockVariadicReturnFunc\nfunc (_mock *MockVariadicReturnFunc) SampleMethod(str string) func(str string, arr []int, a ...interface{}) {\n\tret := _mock.Called(str)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for SampleMethod\")\n\t}\n\n\tvar r0 func(str string, arr []int, a ...interface{})\n\tif returnFunc, ok := ret.Get(0).(func(string) func(str string, arr []int, a ...interface{})); ok {\n\t\tr0 = returnFunc(str)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(func(str string, arr []int, a ...interface{}))\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockVariadicReturnFunc_SampleMethod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SampleMethod'\ntype MockVariadicReturnFunc_SampleMethod_Call struct {\n\t*mock.Call\n}\n\n// SampleMethod is a helper method to define mock.On call\n// - str string\nfunc (_e *MockVariadicReturnFunc_Expecter) SampleMethod(str interface{}) *MockVariadicReturnFunc_SampleMethod_Call {\n\treturn &MockVariadicReturnFunc_SampleMethod_Call{Call: _e.mock.On(\"SampleMethod\", str)}\n}\n\nfunc (_c *MockVariadicReturnFunc_SampleMethod_Call) Run(run func(str string)) *MockVariadicReturnFunc_SampleMethod_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockVariadicReturnFunc_SampleMethod_Call) Return(fn func(str string, arr []int, a ...interface{})) *MockVariadicReturnFunc_SampleMethod_Call {\n\t_c.Call.Return(fn)\n\treturn _c\n}\n\nfunc (_c *MockVariadicReturnFunc_SampleMethod_Call) RunAndReturn(run func(str string) func(str string, arr []int, a ...interface{})) *MockVariadicReturnFunc_SampleMethod_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockVariadicWithMultipleReturnsUnrollVariadic creates a new instance of MockVariadicWithMultipleReturnsUnrollVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockVariadicWithMultipleReturnsUnrollVariadic(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockVariadicWithMultipleReturnsUnrollVariadic {\n\tmock := &MockVariadicWithMultipleReturnsUnrollVariadic{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockVariadicWithMultipleReturnsUnrollVariadic is an autogenerated mock type for the VariadicWithMultipleReturns type\ntype MockVariadicWithMultipleReturnsUnrollVariadic struct {\n\tmock.Mock\n}\n\ntype MockVariadicWithMultipleReturnsUnrollVariadic_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockVariadicWithMultipleReturnsUnrollVariadic) EXPECT() *MockVariadicWithMultipleReturnsUnrollVariadic_Expecter {\n\treturn &MockVariadicWithMultipleReturnsUnrollVariadic_Expecter{mock: &_m.Mock}\n}\n\n// Foo provides a mock function for the type MockVariadicWithMultipleReturnsUnrollVariadic\nfunc (_mock *MockVariadicWithMultipleReturnsUnrollVariadic) Foo(one string, two ...string) (string, error) {\n\t// string\n\t_va := make([]interface{}, len(two))\n\tfor _i := range two {\n\t\t_va[_i] = two[_i]\n\t}\n\tvar _ca []interface{}\n\t_ca = append(_ca, one)\n\t_ca = append(_ca, _va...)\n\tret := _mock.Called(_ca...)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Foo\")\n\t}\n\n\tvar r0 string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string, ...string) (string, error)); ok {\n\t\treturn returnFunc(one, two...)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string, ...string) string); ok {\n\t\tr0 = returnFunc(one, two...)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string, ...string) error); ok {\n\t\tr1 = returnFunc(one, two...)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\n// - one string\n// - two ...string\nfunc (_e *MockVariadicWithMultipleReturnsUnrollVariadic_Expecter) Foo(one interface{}, two ...interface{}) *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call {\n\treturn &MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call{Call: _e.mock.On(\"Foo\",\n\t\tappend([]interface{}{one}, two...)...)}\n}\n\nfunc (_c *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call) Run(run func(one string, two ...string)) *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 []string\n\t\tvariadicArgs := make([]string, len(args)-1)\n\t\tfor i, a := range args[1:] {\n\t\t\tif a != nil {\n\t\t\t\tvariadicArgs[i] = a.(string)\n\t\t\t}\n\t\t}\n\t\targ1 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call) Return(result string, err error) *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call {\n\t_c.Call.Return(result, err)\n\treturn _c\n}\n\nfunc (_c *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call) RunAndReturn(run func(one string, two ...string) (string, error)) *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockVariadicWithMultipleReturns creates a new instance of MockVariadicWithMultipleReturns. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockVariadicWithMultipleReturns(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockVariadicWithMultipleReturns {\n\tmock := &MockVariadicWithMultipleReturns{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockVariadicWithMultipleReturns is an autogenerated mock type for the VariadicWithMultipleReturns type\ntype MockVariadicWithMultipleReturns struct {\n\tmock.Mock\n}\n\ntype MockVariadicWithMultipleReturns_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockVariadicWithMultipleReturns) EXPECT() *MockVariadicWithMultipleReturns_Expecter {\n\treturn &MockVariadicWithMultipleReturns_Expecter{mock: &_m.Mock}\n}\n\n// Foo provides a mock function for the type MockVariadicWithMultipleReturns\nfunc (_mock *MockVariadicWithMultipleReturns) Foo(one string, two ...string) (string, error) {\n\tvar tmpRet mock.Arguments\n\tif len(two) > 0 {\n\t\ttmpRet = _mock.Called(one, two)\n\t} else {\n\t\ttmpRet = _mock.Called(one)\n\t}\n\tret := tmpRet\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Foo\")\n\t}\n\n\tvar r0 string\n\tvar r1 error\n\tif returnFunc, ok := ret.Get(0).(func(string, ...string) (string, error)); ok {\n\t\treturn returnFunc(one, two...)\n\t}\n\tif returnFunc, ok := ret.Get(0).(func(string, ...string) string); ok {\n\t\tr0 = returnFunc(one, two...)\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\tif returnFunc, ok := ret.Get(1).(func(string, ...string) error); ok {\n\t\tr1 = returnFunc(one, two...)\n\t} else {\n\t\tr1 = ret.Error(1)\n\t}\n\treturn r0, r1\n}\n\n// MockVariadicWithMultipleReturns_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype MockVariadicWithMultipleReturns_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\n// - one string\n// - two ...string\nfunc (_e *MockVariadicWithMultipleReturns_Expecter) Foo(one interface{}, two ...interface{}) *MockVariadicWithMultipleReturns_Foo_Call {\n\treturn &MockVariadicWithMultipleReturns_Foo_Call{Call: _e.mock.On(\"Foo\",\n\t\tappend([]interface{}{one}, two...)...)}\n}\n\nfunc (_c *MockVariadicWithMultipleReturns_Foo_Call) Run(run func(one string, two ...string)) *MockVariadicWithMultipleReturns_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 []string\n\t\tvar variadicArgs []string\n\t\tif len(args) > 1 {\n\t\t\tvariadicArgs = args[1].([]string)\n\t\t}\n\t\targ1 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockVariadicWithMultipleReturns_Foo_Call) Return(result string, err error) *MockVariadicWithMultipleReturns_Foo_Call {\n\t_c.Call.Return(result, err)\n\treturn _c\n}\n\nfunc (_c *MockVariadicWithMultipleReturns_Foo_Call) RunAndReturn(run func(one string, two ...string) (string, error)) *MockVariadicWithMultipleReturns_Foo_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockVariadicWithNoReturns creates a new instance of MockVariadicWithNoReturns. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockVariadicWithNoReturns(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockVariadicWithNoReturns {\n\tmock := &MockVariadicWithNoReturns{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockVariadicWithNoReturns is an autogenerated mock type for the VariadicWithNoReturns type\ntype MockVariadicWithNoReturns struct {\n\tmock.Mock\n}\n\ntype MockVariadicWithNoReturns_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockVariadicWithNoReturns) EXPECT() *MockVariadicWithNoReturns_Expecter {\n\treturn &MockVariadicWithNoReturns_Expecter{mock: &_m.Mock}\n}\n\n// Foo provides a mock function for the type MockVariadicWithNoReturns\nfunc (_mock *MockVariadicWithNoReturns) Foo(one string, two ...string) {\n\t// string\n\t_va := make([]interface{}, len(two))\n\tfor _i := range two {\n\t\t_va[_i] = two[_i]\n\t}\n\tvar _ca []interface{}\n\t_ca = append(_ca, one)\n\t_ca = append(_ca, _va...)\n\t_mock.Called(_ca...)\n\treturn\n}\n\n// MockVariadicWithNoReturns_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype MockVariadicWithNoReturns_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\n// - one string\n// - two ...string\nfunc (_e *MockVariadicWithNoReturns_Expecter) Foo(one interface{}, two ...interface{}) *MockVariadicWithNoReturns_Foo_Call {\n\treturn &MockVariadicWithNoReturns_Foo_Call{Call: _e.mock.On(\"Foo\",\n\t\tappend([]interface{}{one}, two...)...)}\n}\n\nfunc (_c *MockVariadicWithNoReturns_Foo_Call) Run(run func(one string, two ...string)) *MockVariadicWithNoReturns_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 string\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(string)\n\t\t}\n\t\tvar arg1 []string\n\t\tvariadicArgs := make([]string, len(args)-1)\n\t\tfor i, a := range args[1:] {\n\t\t\tif a != nil {\n\t\t\t\tvariadicArgs[i] = a.(string)\n\t\t\t}\n\t\t}\n\t\targ1 = variadicArgs\n\t\trun(\n\t\t\targ0,\n\t\t\targ1...,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockVariadicWithNoReturns_Foo_Call) Return() *MockVariadicWithNoReturns_Foo_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockVariadicWithNoReturns_Foo_Call) RunAndReturn(run func(one string, two ...string)) *MockVariadicWithNoReturns_Foo_Call {\n\t_c.Run(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/multi_template/README.md", "content": "This package tests that mockery can render different templates for the same interface." }, { "path": "internal/fixtures/multi_template/interface.go", "content": "package multitemplate\n\ntype Foo interface {\n\tBar() string\n}\n" }, { "path": "internal/fixtures/multi_template/interface_test.go", "content": "package multitemplate\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestFoo(t *testing.T) {\n\ttestifyMock := NewMockTestifyFoo(t)\n\ttestifyMock.EXPECT().Bar().Return(\"bar\")\n\tassert.Equal(t, \"bar\", testifyMock.Bar())\n\n\tmatryerMock := MockMatryerFoo{\n\t\tBarFunc: func() string {\n\t\t\treturn \"bar\"\n\t\t},\n\t}\n\tassert.Equal(t, \"bar\", matryerMock.Bar())\n}\n" }, { "path": "internal/fixtures/multi_template/mocks_matryer_multitemplate_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: matryer\n\npackage multitemplate\n\nimport (\n\t\"sync\"\n)\n\n// Ensure that MockMatryerFoo does implement Foo.\n// If this is not the case, regenerate this file with mockery.\nvar _ Foo = &MockMatryerFoo{}\n\n// MockMatryerFoo is a mock implementation of Foo.\n//\n//\tfunc TestSomethingThatUsesFoo(t *testing.T) {\n//\n//\t\t// make and configure a mocked Foo\n//\t\tmockedFoo := &MockMatryerFoo{\n//\t\t\tBarFunc: func() string {\n//\t\t\t\tpanic(\"mock out the Bar method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedFoo in code that requires Foo\n//\t\t// and then make assertions.\n//\n//\t}\ntype MockMatryerFoo struct {\n\t// BarFunc mocks the Bar method.\n\tBarFunc func() string\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Bar holds details about calls to the Bar method.\n\t\tBar []struct {\n\t\t}\n\t}\n\tlockBar sync.RWMutex\n}\n\n// Bar calls BarFunc.\nfunc (mock *MockMatryerFoo) Bar() string {\n\tif mock.BarFunc == nil {\n\t\tpanic(\"MockMatryerFoo.BarFunc: method is nil but Foo.Bar was just called\")\n\t}\n\tcallInfo := struct {\n\t}{}\n\tmock.lockBar.Lock()\n\tmock.calls.Bar = append(mock.calls.Bar, callInfo)\n\tmock.lockBar.Unlock()\n\treturn mock.BarFunc()\n}\n\n// BarCalls gets all the calls that were made to Bar.\n// Check the length with:\n//\n//\tlen(mockedFoo.BarCalls())\nfunc (mock *MockMatryerFoo) BarCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockBar.RLock()\n\tcalls = mock.calls.Bar\n\tmock.lockBar.RUnlock()\n\treturn calls\n}\n" }, { "path": "internal/fixtures/multi_template/mocks_testify_multitemplate_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage multitemplate\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockTestifyFoo creates a new instance of MockTestifyFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockTestifyFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockTestifyFoo {\n\tmock := &MockTestifyFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockTestifyFoo is an autogenerated mock type for the Foo type\ntype MockTestifyFoo struct {\n\tmock.Mock\n}\n\ntype MockTestifyFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockTestifyFoo) EXPECT() *MockTestifyFoo_Expecter {\n\treturn &MockTestifyFoo_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type MockTestifyFoo\nfunc (_mock *MockTestifyFoo) Bar() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Bar\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockTestifyFoo_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype MockTestifyFoo_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\nfunc (_e *MockTestifyFoo_Expecter) Bar() *MockTestifyFoo_Bar_Call {\n\treturn &MockTestifyFoo_Bar_Call{Call: _e.mock.On(\"Bar\")}\n}\n\nfunc (_c *MockTestifyFoo_Bar_Call) Run(run func()) *MockTestifyFoo_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockTestifyFoo_Bar_Call) Return(s string) *MockTestifyFoo_Bar_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockTestifyFoo_Bar_Call) RunAndReturn(run func() string) *MockTestifyFoo_Bar_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/nil_run.go", "content": "package test\n\ntype NilRun interface {\n\tFoo(NilRun)\n}\n" }, { "path": "internal/fixtures/nil_run_test.go", "content": "package test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/mock\"\n)\n\nfunc TestDoer(t *testing.T) {\n\td := NewMockNilRun(t)\n\td.EXPECT().Foo(mock.Anything).Run(func(_ NilRun) {})\n\td.Foo(nil)\n}\n" }, { "path": "internal/fixtures/output_dir/interface.go", "content": "package output_dir\n\ntype OutputDirWithDifferentPkgName interface {\n\tFoo() string\n}\n\ntype OutputDirWithSamePkgNameAsSrc interface {\n\tBar() string\n}\n\ntype OutputDirWithinSrcPkg interface {\n\tBaz() string\n}\n" }, { "path": "internal/fixtures/output_dir/interface_test.go", "content": "package output_dir_test\n\nimport (\n\t\"os\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestOutputSourceImport(t *testing.T) {\n\tconst expectedImport = \"github.com/vektra/mockery/v3/internal/fixtures/output_dir\"\n\n\ttests := []struct {\n\t\tname string\n\t\tfilepath string\n\t\texpected bool\n\t}{\n\t\t{\n\t\t\tname: \"Different package name -outside source package\",\n\t\t\tfilepath: \"./mock/mocks_matryer_output_dir_test.go\",\n\t\t\texpected: true,\n\t\t},\n\t\t{\n\t\t\tname: \"Same package name -outside source package\",\n\t\t\tfilepath: \"./output_dir/mocks_matryer_output_dir_test.go\",\n\t\t\texpected: true,\n\t\t},\n\t\t{\n\t\t\tname: \"Same package name -within source package\",\n\t\t\tfilepath: \"./mocks_matryer_output_dir_test.go\",\n\t\t\texpected: false,\n\t\t},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.name, func(t *testing.T) {\n\t\t\tb, err := os.ReadFile(tt.filepath)\n\t\t\trequire.NoError(t, err)\n\t\t\tassert.Equal(t, tt.expected, strings.Contains(string(b), expectedImport))\n\t\t})\n\t}\n}\n\nfunc TestOutputEnsureCheck(t *testing.T) {\n\ttests := []struct {\n\t\tname string\n\t\tfilepath string\n\t\texpected string\n\t}{\n\t\t{\n\t\t\tname: \"Different package name -outside source package\",\n\t\t\tfilepath: \"./mock/mocks_matryer_output_dir_test.go\",\n\t\t\texpected: \"var _ output_dir.OutputDirWithDifferentPkgName = &MoqOutputDirWithDifferentPkgName{}\",\n\t\t},\n\t\t{\n\t\t\tname: \"Same package name -outside source package\",\n\t\t\tfilepath: \"./output_dir/mocks_matryer_output_dir_test.go\",\n\t\t\texpected: \"var _ output_dir.OutputDirWithSamePkgNameAsSrc = &MoqOutputDirWithSamePkgNameAsSrc{}\",\n\t\t},\n\t\t{\n\t\t\tname: \"Same package name -within source package\",\n\t\t\tfilepath: \"./mocks_matryer_output_dir_test.go\",\n\t\t\texpected: \"var _ OutputDirWithinSrcPkg = &MoqOutputDirWithinSrcPkg{}\",\n\t\t},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.name, func(t *testing.T) {\n\t\t\tb, err := os.ReadFile(tt.filepath)\n\t\t\trequire.NoError(t, err)\n\t\t\tassert.Contains(t, string(b), tt.expected)\n\t\t})\n\t}\n}\n" }, { "path": "internal/fixtures/output_dir/mock/mocks_matryer_output_dir_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: matryer\n\npackage mock\n\nimport (\n\t\"sync\"\n\n\t\"github.com/vektra/mockery/v3/internal/fixtures/output_dir\"\n)\n\n// Ensure that MoqOutputDirWithDifferentPkgName does implement output_dir.OutputDirWithDifferentPkgName.\n// If this is not the case, regenerate this file with mockery.\nvar _ output_dir.OutputDirWithDifferentPkgName = &MoqOutputDirWithDifferentPkgName{}\n\n// MoqOutputDirWithDifferentPkgName is a mock implementation of output_dir.OutputDirWithDifferentPkgName.\n//\n//\tfunc TestSomethingThatUsesOutputDirWithDifferentPkgName(t *testing.T) {\n//\n//\t\t// make and configure a mocked output_dir.OutputDirWithDifferentPkgName\n//\t\tmockedOutputDirWithDifferentPkgName := &MoqOutputDirWithDifferentPkgName{\n//\t\t\tFooFunc: func() string {\n//\t\t\t\tpanic(\"mock out the Foo method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedOutputDirWithDifferentPkgName in code that requires output_dir.OutputDirWithDifferentPkgName\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqOutputDirWithDifferentPkgName struct {\n\t// FooFunc mocks the Foo method.\n\tFooFunc func() string\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Foo holds details about calls to the Foo method.\n\t\tFoo []struct {\n\t\t}\n\t}\n\tlockFoo sync.RWMutex\n}\n\n// Foo calls FooFunc.\nfunc (mock *MoqOutputDirWithDifferentPkgName) Foo() string {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = append(mock.calls.Foo, callInfo)\n\tmock.lockFoo.Unlock()\n\tif mock.FooFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t)\n\t\treturn s\n\t}\n\treturn mock.FooFunc()\n}\n\n// FooCalls gets all the calls that were made to Foo.\n// Check the length with:\n//\n//\tlen(mockedOutputDirWithDifferentPkgName.FooCalls())\nfunc (mock *MoqOutputDirWithDifferentPkgName) FooCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockFoo.RLock()\n\tcalls = mock.calls.Foo\n\tmock.lockFoo.RUnlock()\n\treturn calls\n}\n\n// ResetFooCalls reset all the calls that were made to Foo.\nfunc (mock *MoqOutputDirWithDifferentPkgName) ResetFooCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqOutputDirWithDifferentPkgName) ResetCalls() {\n\tmock.lockFoo.Lock()\n\tmock.calls.Foo = nil\n\tmock.lockFoo.Unlock()\n}\n" }, { "path": "internal/fixtures/output_dir/mocks_matryer_output_dir_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: matryer\n\npackage output_dir\n\nimport (\n\t\"sync\"\n)\n\n// Ensure that MoqOutputDirWithinSrcPkg does implement OutputDirWithinSrcPkg.\n// If this is not the case, regenerate this file with mockery.\nvar _ OutputDirWithinSrcPkg = &MoqOutputDirWithinSrcPkg{}\n\n// MoqOutputDirWithinSrcPkg is a mock implementation of OutputDirWithinSrcPkg.\n//\n//\tfunc TestSomethingThatUsesOutputDirWithinSrcPkg(t *testing.T) {\n//\n//\t\t// make and configure a mocked OutputDirWithinSrcPkg\n//\t\tmockedOutputDirWithinSrcPkg := &MoqOutputDirWithinSrcPkg{\n//\t\t\tBazFunc: func() string {\n//\t\t\t\tpanic(\"mock out the Baz method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedOutputDirWithinSrcPkg in code that requires OutputDirWithinSrcPkg\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqOutputDirWithinSrcPkg struct {\n\t// BazFunc mocks the Baz method.\n\tBazFunc func() string\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Baz holds details about calls to the Baz method.\n\t\tBaz []struct {\n\t\t}\n\t}\n\tlockBaz sync.RWMutex\n}\n\n// Baz calls BazFunc.\nfunc (mock *MoqOutputDirWithinSrcPkg) Baz() string {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockBaz.Lock()\n\tmock.calls.Baz = append(mock.calls.Baz, callInfo)\n\tmock.lockBaz.Unlock()\n\tif mock.BazFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t)\n\t\treturn s\n\t}\n\treturn mock.BazFunc()\n}\n\n// BazCalls gets all the calls that were made to Baz.\n// Check the length with:\n//\n//\tlen(mockedOutputDirWithinSrcPkg.BazCalls())\nfunc (mock *MoqOutputDirWithinSrcPkg) BazCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockBaz.RLock()\n\tcalls = mock.calls.Baz\n\tmock.lockBaz.RUnlock()\n\treturn calls\n}\n\n// ResetBazCalls reset all the calls that were made to Baz.\nfunc (mock *MoqOutputDirWithinSrcPkg) ResetBazCalls() {\n\tmock.lockBaz.Lock()\n\tmock.calls.Baz = nil\n\tmock.lockBaz.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqOutputDirWithinSrcPkg) ResetCalls() {\n\tmock.lockBaz.Lock()\n\tmock.calls.Baz = nil\n\tmock.lockBaz.Unlock()\n}\n" }, { "path": "internal/fixtures/output_dir/output_dir/mocks_matryer_output_dir_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: matryer\n\npackage output_dir\n\nimport (\n\t\"sync\"\n\n\t\"github.com/vektra/mockery/v3/internal/fixtures/output_dir\"\n)\n\n// Ensure that MoqOutputDirWithSamePkgNameAsSrc does implement output_dir.OutputDirWithSamePkgNameAsSrc.\n// If this is not the case, regenerate this file with mockery.\nvar _ output_dir.OutputDirWithSamePkgNameAsSrc = &MoqOutputDirWithSamePkgNameAsSrc{}\n\n// MoqOutputDirWithSamePkgNameAsSrc is a mock implementation of output_dir.OutputDirWithSamePkgNameAsSrc.\n//\n//\tfunc TestSomethingThatUsesOutputDirWithSamePkgNameAsSrc(t *testing.T) {\n//\n//\t\t// make and configure a mocked output_dir.OutputDirWithSamePkgNameAsSrc\n//\t\tmockedOutputDirWithSamePkgNameAsSrc := &MoqOutputDirWithSamePkgNameAsSrc{\n//\t\t\tBarFunc: func() string {\n//\t\t\t\tpanic(\"mock out the Bar method\")\n//\t\t\t},\n//\t\t}\n//\n//\t\t// use mockedOutputDirWithSamePkgNameAsSrc in code that requires output_dir.OutputDirWithSamePkgNameAsSrc\n//\t\t// and then make assertions.\n//\n//\t}\ntype MoqOutputDirWithSamePkgNameAsSrc struct {\n\t// BarFunc mocks the Bar method.\n\tBarFunc func() string\n\n\t// calls tracks calls to the methods.\n\tcalls struct {\n\t\t// Bar holds details about calls to the Bar method.\n\t\tBar []struct {\n\t\t}\n\t}\n\tlockBar sync.RWMutex\n}\n\n// Bar calls BarFunc.\nfunc (mock *MoqOutputDirWithSamePkgNameAsSrc) Bar() string {\n\tcallInfo := struct {\n\t}{}\n\tmock.lockBar.Lock()\n\tmock.calls.Bar = append(mock.calls.Bar, callInfo)\n\tmock.lockBar.Unlock()\n\tif mock.BarFunc == nil {\n\t\tvar (\n\t\t\ts string\n\t\t)\n\t\treturn s\n\t}\n\treturn mock.BarFunc()\n}\n\n// BarCalls gets all the calls that were made to Bar.\n// Check the length with:\n//\n//\tlen(mockedOutputDirWithSamePkgNameAsSrc.BarCalls())\nfunc (mock *MoqOutputDirWithSamePkgNameAsSrc) BarCalls() []struct {\n} {\n\tvar calls []struct {\n\t}\n\tmock.lockBar.RLock()\n\tcalls = mock.calls.Bar\n\tmock.lockBar.RUnlock()\n\treturn calls\n}\n\n// ResetBarCalls reset all the calls that were made to Bar.\nfunc (mock *MoqOutputDirWithSamePkgNameAsSrc) ResetBarCalls() {\n\tmock.lockBar.Lock()\n\tmock.calls.Bar = nil\n\tmock.lockBar.Unlock()\n}\n\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *MoqOutputDirWithSamePkgNameAsSrc) ResetCalls() {\n\tmock.lockBar.Lock()\n\tmock.calls.Bar = nil\n\tmock.lockBar.Unlock()\n}\n" }, { "path": "internal/fixtures/panic_err.go", "content": "package test\n\ntype PanicOnNoReturnValue interface {\n\tDoSomething() string\n}\n" }, { "path": "internal/fixtures/panic_err_test.go", "content": "package test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestPanicOnNoReturnValue(t *testing.T) {\n\tm := NewMockPanicOnNoReturnValue(t)\n\tm.EXPECT().DoSomething()\n\n\tvar panicOccurred bool\n\tdefer func() {\n\t\tassert.True(t, panicOccurred)\n\t}()\n\tdefer func() {\n\t\tpanicOccurred = true\n\n\t\tr := recover()\n\t\trequire.NotNil(t, r)\n\t\tassert.Equal(t, \"no return value specified for DoSomething\", r.(string))\n\t}()\n\n\tm.DoSomething()\n}\n" }, { "path": "internal/fixtures/pkg_with_no_files/subpkg/foo.go", "content": "package foo\n" }, { "path": "internal/fixtures/recursive_generation/foo.go", "content": "package recursive_generation\n\ntype Foo interface {\n\tGet() string\n}\n" }, { "path": "internal/fixtures/recursive_generation/mocks_testify_recursive_generation_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage recursive_generation\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Get() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockFoo_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockFoo_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Get() *MockFoo_Get_Call {\n\treturn &MockFoo_Get_Call{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockFoo_Get_Call) Run(run func()) *MockFoo_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Get_Call) Return(s string) *MockFoo_Get_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Get_Call) RunAndReturn(run func() string) *MockFoo_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/recursive_generation/subpkg1/foo.go", "content": "package subpkg1\n\ntype Foo interface {\n\tGet() string\n}\n" }, { "path": "internal/fixtures/recursive_generation/subpkg1/mocks_testify_subpkg1_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage subpkg1\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Get() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockFoo_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockFoo_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Get() *MockFoo_Get_Call {\n\treturn &MockFoo_Get_Call{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockFoo_Get_Call) Run(run func()) *MockFoo_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Get_Call) Return(s string) *MockFoo_Get_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Get_Call) RunAndReturn(run func() string) *MockFoo_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/recursive_generation/subpkg2/foo.go", "content": "package subpkg2\n\ntype Foo interface {\n\tGet() string\n}\n" }, { "path": "internal/fixtures/recursive_generation/subpkg2/mocks_testify_subpkg2_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage subpkg2\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Get provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Get() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Get\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockFoo_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'\ntype MockFoo_Get_Call struct {\n\t*mock.Call\n}\n\n// Get is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Get() *MockFoo_Get_Call {\n\treturn &MockFoo_Get_Call{Call: _e.mock.On(\"Get\")}\n}\n\nfunc (_c *MockFoo_Get_Call) Run(run func()) *MockFoo_Get_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Get_Call) Return(s string) *MockFoo_Get_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Get_Call) RunAndReturn(run func() string) *MockFoo_Get_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/recursive_generation/subpkg_with_only_autogenerated_files/foo.go", "content": "// Code generated by an arbitrary code generator thingy. DO NOT EDIT.\npackage subpkg_with_only_autogenerated_files\n\ntype Foo interface {\n\tGet() string\n}\n" }, { "path": "internal/fixtures/recursive_generation_with_subpkg_exclude/foo.go", "content": "package recursivegenerationwithsubpkgexclude\n\ntype Foo interface {\n\tBar() string\n}\n" }, { "path": "internal/fixtures/recursive_generation_with_subpkg_exclude/foo_test.go", "content": "package recursivegenerationwithsubpkgexclude_test\n\nimport (\n\t\"os\"\n\t\"path\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n\t\"github.com/vektra/mockery/v3/internal/file\"\n)\n\nfunc TestSubpkg2NotExist(t *testing.T) {\n\twd, err := os.Getwd()\n\trequire.NoError(t, err)\n\tsubpkg2MockFile := path.Join(wd, \"subpkg2\", \"mocks.go\")\n\texists, err := file.Exists(subpkg2MockFile)\n\trequire.NoError(t, err)\n\tassert.False(t, exists, \"subpkg2 mocks.go file exists when it shouldn't\")\n}\n\nfunc TestSubpkg1Exists(t *testing.T) {\n\twd, err := os.Getwd()\n\trequire.NoError(t, err)\n\tsubpkg2MockFile := path.Join(wd, \"subpkg1\", \"mocks.go\")\n\texists, err := file.Exists(subpkg2MockFile)\n\trequire.NoError(t, err)\n\tassert.True(t, exists, \"subpkg1 mocks.go file doesn't exist when it should\")\n}\n" }, { "path": "internal/fixtures/recursive_generation_with_subpkg_exclude/mocks.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage recursivegenerationwithsubpkgexclude\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Bar() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Bar\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockFoo_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype MockFoo_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Bar() *MockFoo_Bar_Call {\n\treturn &MockFoo_Bar_Call{Call: _e.mock.On(\"Bar\")}\n}\n\nfunc (_c *MockFoo_Bar_Call) Run(run func()) *MockFoo_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) Return(s string) *MockFoo_Bar_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) RunAndReturn(run func() string) *MockFoo_Bar_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/recursive_generation_with_subpkg_exclude/subpkg1/foo.go", "content": "package subpkg1\n\ntype Foo interface {\n\tBar() string\n}\n" }, { "path": "internal/fixtures/recursive_generation_with_subpkg_exclude/subpkg1/mocks.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage subpkg1\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockFoo creates a new instance of MockFoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockFoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockFoo {\n\tmock := &MockFoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockFoo is an autogenerated mock type for the Foo type\ntype MockFoo struct {\n\tmock.Mock\n}\n\ntype MockFoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockFoo) EXPECT() *MockFoo_Expecter {\n\treturn &MockFoo_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type MockFoo\nfunc (_mock *MockFoo) Bar() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Bar\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockFoo_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype MockFoo_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\nfunc (_e *MockFoo_Expecter) Bar() *MockFoo_Bar_Call {\n\treturn &MockFoo_Bar_Call{Call: _e.mock.On(\"Bar\")}\n}\n\nfunc (_c *MockFoo_Bar_Call) Run(run func()) *MockFoo_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) Return(s string) *MockFoo_Bar_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockFoo_Bar_Call) RunAndReturn(run func() string) *MockFoo_Bar_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/recursive_generation_with_subpkg_exclude/subpkg2/foo.go", "content": "package subpkg2\n\ntype Foo interface {\n\tBar() string\n}\n" }, { "path": "internal/fixtures/redefined_type_b/redefined_type_b.go", "content": "package test\n\n// This is testing imports of the \"B\" type, which is also defined in\n// pkg/fixtures\n\ntype B int\n" }, { "path": "internal/fixtures/replace_type_pointers/interface.go", "content": "package replace_type_pointers\n\ntype (\n\tFoo int\n\tBar int\n)\n\ntype InterfaceWithPointers interface {\n\tFooFunc(*Foo) *Foo\n\tBarFunc(Bar) Bar\n}\n" }, { "path": "internal/fixtures/replace_type_pointers/interface_test.go", "content": "package replace_type_pointers\n\nimport (\n\t\"os\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestReplaceTypePointers(t *testing.T) {\n\t// The config file has been written to replace all instances of the Foo type\n\t// with Bar. We check whether the function signatures indeed have *Foo\n\t// replaced with *Bar in both the argument and return value parameters.\n\tmockFile := \"mocks_testify_replace_type_pointers_test.go\"\n\tmockFileBytes, err := os.ReadFile(mockFile)\n\trequire.NoError(t, err)\n\tassert.Contains(t, string(mockFileBytes), \"FooFunc(foo *Bar) *Bar\")\n}\n" }, { "path": "internal/fixtures/replace_type_pointers/mocks_testify_replace_type_pointers_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage replace_type_pointers\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// NewMockInterfaceWithPointers creates a new instance of MockInterfaceWithPointers. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockInterfaceWithPointers(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockInterfaceWithPointers {\n\tmock := &MockInterfaceWithPointers{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockInterfaceWithPointers is an autogenerated mock type for the InterfaceWithPointers type\ntype MockInterfaceWithPointers struct {\n\tmock.Mock\n}\n\ntype MockInterfaceWithPointers_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockInterfaceWithPointers) EXPECT() *MockInterfaceWithPointers_Expecter {\n\treturn &MockInterfaceWithPointers_Expecter{mock: &_m.Mock}\n}\n\n// BarFunc provides a mock function for the type MockInterfaceWithPointers\nfunc (_mock *MockInterfaceWithPointers) BarFunc(bar Bar) Bar {\n\tret := _mock.Called(bar)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for BarFunc\")\n\t}\n\n\tvar r0 Bar\n\tif returnFunc, ok := ret.Get(0).(func(Bar) Bar); ok {\n\t\tr0 = returnFunc(bar)\n\t} else {\n\t\tr0 = ret.Get(0).(Bar)\n\t}\n\treturn r0\n}\n\n// MockInterfaceWithPointers_BarFunc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BarFunc'\ntype MockInterfaceWithPointers_BarFunc_Call struct {\n\t*mock.Call\n}\n\n// BarFunc is a helper method to define mock.On call\n// - bar Bar\nfunc (_e *MockInterfaceWithPointers_Expecter) BarFunc(bar interface{}) *MockInterfaceWithPointers_BarFunc_Call {\n\treturn &MockInterfaceWithPointers_BarFunc_Call{Call: _e.mock.On(\"BarFunc\", bar)}\n}\n\nfunc (_c *MockInterfaceWithPointers_BarFunc_Call) Run(run func(bar Bar)) *MockInterfaceWithPointers_BarFunc_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 Bar\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(Bar)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockInterfaceWithPointers_BarFunc_Call) Return(bar1 Bar) *MockInterfaceWithPointers_BarFunc_Call {\n\t_c.Call.Return(bar1)\n\treturn _c\n}\n\nfunc (_c *MockInterfaceWithPointers_BarFunc_Call) RunAndReturn(run func(bar Bar) Bar) *MockInterfaceWithPointers_BarFunc_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// FooFunc provides a mock function for the type MockInterfaceWithPointers\nfunc (_mock *MockInterfaceWithPointers) FooFunc(foo *Bar) *Bar {\n\tret := _mock.Called(foo)\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for FooFunc\")\n\t}\n\n\tvar r0 *Bar\n\tif returnFunc, ok := ret.Get(0).(func(*Bar) *Bar); ok {\n\t\tr0 = returnFunc(foo)\n\t} else {\n\t\tif ret.Get(0) != nil {\n\t\t\tr0 = ret.Get(0).(*Bar)\n\t\t}\n\t}\n\treturn r0\n}\n\n// MockInterfaceWithPointers_FooFunc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FooFunc'\ntype MockInterfaceWithPointers_FooFunc_Call struct {\n\t*mock.Call\n}\n\n// FooFunc is a helper method to define mock.On call\n// - foo *Bar\nfunc (_e *MockInterfaceWithPointers_Expecter) FooFunc(foo interface{}) *MockInterfaceWithPointers_FooFunc_Call {\n\treturn &MockInterfaceWithPointers_FooFunc_Call{Call: _e.mock.On(\"FooFunc\", foo)}\n}\n\nfunc (_c *MockInterfaceWithPointers_FooFunc_Call) Run(run func(foo *Bar)) *MockInterfaceWithPointers_FooFunc_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 *Bar\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(*Bar)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockInterfaceWithPointers_FooFunc_Call) Return(foo1 *Bar) *MockInterfaceWithPointers_FooFunc_Call {\n\t_c.Call.Return(foo1)\n\treturn _c\n}\n\nfunc (_c *MockInterfaceWithPointers_FooFunc_Call) RunAndReturn(run func(foo *Bar) *Bar) *MockInterfaceWithPointers_FooFunc_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/requester.go", "content": "package test\n\ntype Requester interface {\n\tGet(path string) (string, error)\n}\n" }, { "path": "internal/fixtures/requester2.go", "content": "package test\n\ntype Requester2 interface {\n\tGet(path string) error\n}\n" }, { "path": "internal/fixtures/requester3.go", "content": "package test\n\ntype Requester3 interface {\n\tGet() error\n}\n" }, { "path": "internal/fixtures/requester4.go", "content": "package test\n\ntype Requester4 interface {\n\tGet()\n}\n" }, { "path": "internal/fixtures/requester_arg_same_as_import.go", "content": "package test\n\nimport \"encoding/json\"\n\ntype RequesterArgSameAsImport interface {\n\tGet(json string) *json.RawMessage\n}\n" }, { "path": "internal/fixtures/requester_arg_same_as_named_import.go", "content": "package test\n\nimport \"encoding/json\"\n\ntype RequesterArgSameAsNamedImport interface {\n\tGet(json string) *json.RawMessage\n}\n" }, { "path": "internal/fixtures/requester_arg_same_as_pkg.go", "content": "package test\n\ntype RequesterArgSameAsPkg interface {\n\tGet(test string)\n}\n" }, { "path": "internal/fixtures/requester_array.go", "content": "package test\n\ntype RequesterArray interface {\n\tGet(path string) ([2]string, error)\n}\n" }, { "path": "internal/fixtures/requester_elided.go", "content": "package test\n\ntype RequesterElided interface {\n\tGet(path, url string) error\n}\n" }, { "path": "internal/fixtures/requester_iface.go", "content": "package test\n\nimport \"io\"\n\ntype RequesterIface interface {\n\tGet() io.Reader\n}\n" }, { "path": "internal/fixtures/requester_ns.go", "content": "package test\n\nimport \"net/http\"\n\ntype RequesterNS interface {\n\tGet(path string) (http.Response, error)\n}\n" }, { "path": "internal/fixtures/requester_ptr.go", "content": "package test\n\ntype RequesterPtr interface {\n\tGet(path string) (*string, error)\n}\n" }, { "path": "internal/fixtures/requester_ret_elided.go", "content": "package test\n\ntype RequesterReturnElided interface {\n\tGet(path string) (a, b, c int, err error)\n\tPut(path string) (_ int, err error)\n}\n" }, { "path": "internal/fixtures/requester_slice.go", "content": "package test\n\ntype RequesterSlice interface {\n\tGet(path string) ([]string, error)\n}\n" }, { "path": "internal/fixtures/requester_test.go", "content": "package test\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\nfunc TestRequesterMock(t *testing.T) {\n\tm := NewMockRequester(t)\n\tm.EXPECT().Get(\"foo\").Return(\"bar\", nil).Once()\n\tretString, err := m.Get(\"foo\")\n\tassert.NoError(t, err)\n\tassert.Equal(t, \"bar\", retString)\n}\n\nfunc TestRequesterMockRunAndReturn(t *testing.T) {\n\tm := NewMockRequester(t)\n\tm.EXPECT().Get(mock.Anything).RunAndReturn(func(path string) (string, error) {\n\t\treturn path + \" world\", nil\n\t})\n\tretString, err := m.Get(\"hello\")\n\tassert.NoError(t, err)\n\tassert.Equal(t, \"hello world\", retString)\n}\n\nfunc TestRequesterMockRun(t *testing.T) {\n\tm := NewMockRequester(t)\n\tm.EXPECT().Get(mock.Anything).Return(\"\", nil)\n\tm.EXPECT().Get(mock.Anything).Run(func(path string) {\n\t\tfmt.Printf(\"Side effect! Argument is: %s\", path)\n\t})\n\tretString, err := m.Get(\"hello\")\n\tassert.NoError(t, err)\n\tassert.Equal(t, \"\", retString)\n}\n\n//nolint:errcheck\nfunc TestRequesterMockTestifyEmbed(t *testing.T) {\n\tm := NewMockRequester(t)\n\tm.EXPECT().Get(mock.Anything).Return(\"\", nil).Twice()\n\tm.Get(\"hello\")\n\tm.Get(\"world\")\n\tassert.Len(t, m.Mock.Calls, 2)\n}\n\nfunc TestRequesterMoq(t *testing.T) {\n\tm := &MoqRequester{\n\t\tGetFunc: func(path string) (string, error) {\n\t\t\tfmt.Printf(\"Go path: %s\\n\", path)\n\t\t\treturn path + \"/foo\", nil\n\t\t},\n\t}\n\tresult, err := m.Get(\"/path\")\n\tassert.NoError(t, err)\n\tassert.Equal(t, \"/path/foo\", result)\n}\n\nfunc TestRequesterMatryerStub(t *testing.T) {\n\tm := &StubMatyerRequester{}\n\t// The returned values should be the zero-values even though a GetFunc was\n\t// not defined. If stub-impl is not true, this should panic.\n\tstr, err := m.Get(\"foo\")\n\tassert.Equal(t, \"\", str)\n\tassert.Equal(t, nil, err)\n}\n" }, { "path": "internal/fixtures/requester_unexported.go", "content": "package test\n\ntype requesterUnexported interface {\n\tGet()\n}\n" }, { "path": "internal/fixtures/requester_variadic.go", "content": "package test\n\nimport \"io\"\n\ntype RequesterVariadic interface {\n\t// cases: only variadic argument, w/ and w/out interface type\n\tGet(values ...string) bool\n\tOneInterface(a ...interface{}) bool\n\n\t// cases: normal argument + variadic argument, w/ and w/o interface type\n\tSprintf(format string, a ...interface{}) string\n\tMultiWriteToFile(filename string, w ...io.Writer) string\n}\n" }, { "path": "internal/fixtures/same_name_imports.go", "content": "package test\n\nimport (\n\t\"net/http\"\n\n\tnumber_dir_http \"github.com/vektra/mockery/v3/internal/fixtures/12345678/http\"\n\tmy_http \"github.com/vektra/mockery/v3/internal/fixtures/http\"\n)\n\n// Example is an example\ntype Example interface {\n\tA() http.Flusher\n\tB(fixtureshttp string) my_http.MyStruct\n\tC(fixtureshttp string) number_dir_http.MyStruct\n}\n" }, { "path": "internal/fixtures/struct_value.go", "content": "package test\n\ntype B struct{}\n\ntype A interface {\n\tCall() (B, error)\n}\n" }, { "path": "internal/fixtures/struct_with_tag.go", "content": "package test\n\ntype StructWithTag interface {\n\tMethodA(v *struct {\n\t\tFieldA int `json:\"field_a\"`\n\t\tFieldB int `json:\"field_b\" xml:\"field_b\"`\n\t}) *struct {\n\t\tFieldC int `json:\"field_c\"`\n\t\tFieldD int `json:\"field_d\" xml:\"field_d\"`\n\t}\n}\n" }, { "path": "internal/fixtures/template_exercise/exercise.go", "content": "package templateexercise\n\nimport (\n\t\"context\"\n\n\t\"golang.org/x/exp/constraints\"\n)\n\n// GenDecl comments\ntype (\n\t// Exercise is an interface that is used to render a template that exercises\n\t// all parts of the template data passed to the template.\n\tExercise[T any, Ordered constraints.Ordered] interface {\n\t\t// Foo is a foo\n\t\tFoo(ctx context.Context, typeParam T, ordered Ordered) error\n\t} // This is a line comment\n)\n" }, { "path": "internal/fixtures/type_alias/interface.go", "content": "package type_alias\n\nimport \"github.com/vektra/mockery/v3/internal/fixtures/type_alias/subpkg\"\n\ntype (\n\tType = int\n\tS = subpkg.S\n\tAliasToInterface3 = subpkg.Interface3\n)\n\ntype Interface1 interface {\n\tFoo() Type\n}\n\ntype Interface2 interface {\n\tF(Type, S, subpkg.S)\n}\n" }, { "path": "internal/fixtures/type_alias/interface_test.go", "content": "package type_alias_test\n\nimport (\n\t\"os\"\n\t\"regexp\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/type_alias\"\n)\n\nfunc TestTypeAliasInMethodReturn(t *testing.T) {\n\tfor _, tt := range []struct {\n\t\tname string\n\t\tfilepath string\n\t\texpectedRegex string\n\t}{\n\t\t{\n\t\t\tname: \"With alias unresolved\",\n\t\t\tfilepath: \"./mocks_testify_type_alias_test.go\",\n\t\t\texpectedRegex: `func \\(_mock \\*MockInterface1\\) Foo\\(\\) Type {`,\n\t\t},\n\t} {\n\t\tt.Run(tt.name, func(t *testing.T) {\n\t\t\tregex, err := regexp.Compile(tt.expectedRegex)\n\t\t\trequire.NoError(t, err)\n\t\t\tbytes, err := os.ReadFile(tt.filepath)\n\t\t\trequire.NoError(t, err)\n\n\t\t\tassert.True(t, regex.Match(bytes), \"expected regex was not found in file\")\n\t\t})\n\t}\n}\n\nfunc TestTypeAliasMock(t *testing.T) {\n\tm := type_alias.NewMockAliasToInterface3(t)\n\tm.EXPECT().Foo().Return(\"foo\")\n\tassert.Equal(t, \"foo\", m.Foo())\n}\n" }, { "path": "internal/fixtures/type_alias/mocks_testify_type_alias_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage type_alias\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n\t\"github.com/vektra/mockery/v3/internal/fixtures/type_alias/subpkg\"\n)\n\n// NewMockAliasToInterface3 creates a new instance of MockAliasToInterface3. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockAliasToInterface3(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockAliasToInterface3 {\n\tmock := &MockAliasToInterface3{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockAliasToInterface3 is an autogenerated mock type for the AliasToInterface3 type\ntype MockAliasToInterface3 struct {\n\tmock.Mock\n}\n\ntype MockAliasToInterface3_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockAliasToInterface3) EXPECT() *MockAliasToInterface3_Expecter {\n\treturn &MockAliasToInterface3_Expecter{mock: &_m.Mock}\n}\n\n// Foo provides a mock function for the type MockAliasToInterface3\nfunc (_mock *MockAliasToInterface3) Foo() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Foo\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// MockAliasToInterface3_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype MockAliasToInterface3_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\nfunc (_e *MockAliasToInterface3_Expecter) Foo() *MockAliasToInterface3_Foo_Call {\n\treturn &MockAliasToInterface3_Foo_Call{Call: _e.mock.On(\"Foo\")}\n}\n\nfunc (_c *MockAliasToInterface3_Foo_Call) Run(run func()) *MockAliasToInterface3_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockAliasToInterface3_Foo_Call) Return(s string) *MockAliasToInterface3_Foo_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *MockAliasToInterface3_Foo_Call) RunAndReturn(run func() string) *MockAliasToInterface3_Foo_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockInterface1 creates a new instance of MockInterface1. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockInterface1(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockInterface1 {\n\tmock := &MockInterface1{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockInterface1 is an autogenerated mock type for the Interface1 type\ntype MockInterface1 struct {\n\tmock.Mock\n}\n\ntype MockInterface1_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockInterface1) EXPECT() *MockInterface1_Expecter {\n\treturn &MockInterface1_Expecter{mock: &_m.Mock}\n}\n\n// Foo provides a mock function for the type MockInterface1\nfunc (_mock *MockInterface1) Foo() Type {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Foo\")\n\t}\n\n\tvar r0 Type\n\tif returnFunc, ok := ret.Get(0).(func() Type); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(Type)\n\t}\n\treturn r0\n}\n\n// MockInterface1_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'\ntype MockInterface1_Foo_Call struct {\n\t*mock.Call\n}\n\n// Foo is a helper method to define mock.On call\nfunc (_e *MockInterface1_Expecter) Foo() *MockInterface1_Foo_Call {\n\treturn &MockInterface1_Foo_Call{Call: _e.mock.On(\"Foo\")}\n}\n\nfunc (_c *MockInterface1_Foo_Call) Run(run func()) *MockInterface1_Foo_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *MockInterface1_Foo_Call) Return(v Type) *MockInterface1_Foo_Call {\n\t_c.Call.Return(v)\n\treturn _c\n}\n\nfunc (_c *MockInterface1_Foo_Call) RunAndReturn(run func() Type) *MockInterface1_Foo_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n\n// NewMockInterface2 creates a new instance of MockInterface2. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc NewMockInterface2(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *MockInterface2 {\n\tmock := &MockInterface2{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// MockInterface2 is an autogenerated mock type for the Interface2 type\ntype MockInterface2 struct {\n\tmock.Mock\n}\n\ntype MockInterface2_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *MockInterface2) EXPECT() *MockInterface2_Expecter {\n\treturn &MockInterface2_Expecter{mock: &_m.Mock}\n}\n\n// F provides a mock function for the type MockInterface2\nfunc (_mock *MockInterface2) F(v Type, v1 S, s subpkg.S) {\n\t_mock.Called(v, v1, s)\n\treturn\n}\n\n// MockInterface2_F_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'F'\ntype MockInterface2_F_Call struct {\n\t*mock.Call\n}\n\n// F is a helper method to define mock.On call\n// - v Type\n// - v1 S\n// - s subpkg.S\nfunc (_e *MockInterface2_Expecter) F(v interface{}, v1 interface{}, s interface{}) *MockInterface2_F_Call {\n\treturn &MockInterface2_F_Call{Call: _e.mock.On(\"F\", v, v1, s)}\n}\n\nfunc (_c *MockInterface2_F_Call) Run(run func(v Type, v1 S, s subpkg.S)) *MockInterface2_F_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\tvar arg0 Type\n\t\tif args[0] != nil {\n\t\t\targ0 = args[0].(Type)\n\t\t}\n\t\tvar arg1 S\n\t\tif args[1] != nil {\n\t\t\targ1 = args[1].(S)\n\t\t}\n\t\tvar arg2 subpkg.S\n\t\tif args[2] != nil {\n\t\t\targ2 = args[2].(subpkg.S)\n\t\t}\n\t\trun(\n\t\t\targ0,\n\t\t\targ1,\n\t\t\targ2,\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *MockInterface2_F_Call) Return() *MockInterface2_F_Call {\n\t_c.Call.Return()\n\treturn _c\n}\n\nfunc (_c *MockInterface2_F_Call) RunAndReturn(run func(v Type, v1 S, s subpkg.S)) *MockInterface2_F_Call {\n\t_c.Run(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/type_alias/subpkg/interface.go", "content": "package subpkg\n\ntype S struct {\n\tA int\n}\n\ntype Interface3 interface {\n\tFoo() string\n}\n" }, { "path": "internal/fixtures/unexported/interface.go", "content": "package unexported\n\ntype foo interface {\n\tBar() string\n}\n" }, { "path": "internal/fixtures/unexported/interface_test.go", "content": "package unexported\n\nimport (\n\t\"os\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestUnexportedConstructorName(t *testing.T) {\n\tmockFile := \"./mocks_testify_unexported_test.go\"\n\tb, err := os.ReadFile(mockFile)\n\trequire.NoError(t, err)\n\tassert.True(t, strings.Contains(string(b), \"func newMockfoo(\"))\n}\n" }, { "path": "internal/fixtures/unexported/mocks_testify_unexported_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage unexported\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// newMockfoo creates a new instance of mockfoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc newMockfoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *mockfoo {\n\tmock := &mockfoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// mockfoo is an autogenerated mock type for the foo type\ntype mockfoo struct {\n\tmock.Mock\n}\n\ntype mockfoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *mockfoo) EXPECT() *mockfoo_Expecter {\n\treturn &mockfoo_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type mockfoo\nfunc (_mock *mockfoo) Bar() string {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Bar\")\n\t}\n\n\tvar r0 string\n\tif returnFunc, ok := ret.Get(0).(func() string); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(string)\n\t}\n\treturn r0\n}\n\n// mockfoo_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype mockfoo_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\nfunc (_e *mockfoo_Expecter) Bar() *mockfoo_Bar_Call {\n\treturn &mockfoo_Bar_Call{Call: _e.mock.On(\"Bar\")}\n}\n\nfunc (_c *mockfoo_Bar_Call) Run(run func()) *mockfoo_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *mockfoo_Bar_Call) Return(s string) *mockfoo_Bar_Call {\n\t_c.Call.Return(s)\n\treturn _c\n}\n\nfunc (_c *mockfoo_Bar_Call) RunAndReturn(run func() string) *mockfoo_Bar_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "internal/fixtures/unsafe.go", "content": "package test\n\nimport \"unsafe\"\n\ntype UnsafeInterface interface {\n\tDo(ptr *unsafe.Pointer)\n}\n" }, { "path": "internal/fixtures/variadic.go", "content": "package test\n\ntype VariadicFunction = func(args1 string, args2 ...interface{}) interface{}\n\ntype Variadic interface {\n\tVariadicFunction(str string, vFunc VariadicFunction) error\n}\n" }, { "path": "internal/fixtures/variadic_return_func.go", "content": "package test\n\ntype VariadicReturnFunc interface {\n\tSampleMethod(str string) func(str string, arr []int, a ...interface{})\n}\n" }, { "path": "internal/fixtures/variadic_return_func_test.go", "content": "package test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestVariadicReturnFunc(t *testing.T) {\n\tm := NewMockVariadicReturnFunc(t)\n\tm.EXPECT().SampleMethod(\"\").Return(func(s string, l []int, a ...any) {\n\t\tassert.Equal(t, \"foo\", s)\n\t\tassert.Equal(t, []int{1, 2, 3}, l)\n\t\tassert.Equal(t, []any{\"one\", \"two\", \"three\"}, a)\n\t})\n\tm.SampleMethod(\"\")(\"foo\", []int{1, 2, 3}, \"one\", \"two\", \"three\")\n}\n" }, { "path": "internal/fixtures/variadic_with_multiple_returns.go", "content": "package test\n\ntype VariadicWithMultipleReturns interface {\n\tFoo(one string, two ...string) (result string, err error)\n}\n" }, { "path": "internal/fixtures/variadic_with_multiple_returns_test.go", "content": "package test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/mock\"\n)\n\nfunc TestNoUnrollVariadic(t *testing.T) {\n\tm := NewMockVariadicWithMultipleReturns(t)\n\tm.EXPECT().Foo(mock.Anything, mock.Anything).RunAndReturn(\n\t\tfunc(one string, two ...string) (string, error) {\n\t\t\tvar s string = one\n\t\t\tfor _, t := range two {\n\t\t\t\ts += t\n\t\t\t}\n\t\t\treturn s, nil\n\t\t},\n\t)\n\tret, err := m.Foo(\"one\", \"two\", \"three\")\n\tassert.NoError(t, err)\n\tassert.Equal(t, \"onetwothree\", ret)\n}\n\nfunc TestUnrollVariadic(t *testing.T) {\n\tm := NewMockVariadicWithMultipleReturnsUnrollVariadic(t)\n\tm.EXPECT().Foo(mock.Anything, mock.Anything, mock.Anything).RunAndReturn(\n\t\tfunc(one string, two ...string) (string, error) {\n\t\t\tvar s string = one\n\t\t\tfor _, t := range two {\n\t\t\t\ts += t\n\t\t\t}\n\t\t\treturn s, nil\n\t\t},\n\t)\n\tret, err := m.Foo(\"one\", \"two\", \"three\")\n\tassert.NoError(t, err)\n\tassert.Equal(t, \"onetwothree\", ret)\n}\n\nfunc TestUnrollVariadicRun(t *testing.T) {\n\tvar ran bool\n\n\tm := NewMockVariadicWithMultipleReturnsUnrollVariadic(t)\n\tm.EXPECT().Foo(mock.Anything, mock.Anything, mock.Anything).Run(\n\t\tfunc(one string, two ...string) {\n\t\t\tran = true\n\t\t},\n\t).Return(\"\", nil)\n\t//nolint: errcheck\n\tm.Foo(\"\", \"\")\n\tassert.True(t, ran)\n}\n\nfunc TestNoUnrollVariadicRun(t *testing.T) {\n\tvar ran bool\n\n\tm := NewMockVariadicWithMultipleReturns(t)\n\tm.EXPECT().Foo(mock.Anything, mock.Anything).Run(\n\t\tfunc(one string, two ...string) {\n\t\t\tran = true\n\t\t},\n\t).Return(\"\", nil)\n\t//nolint: errcheck\n\tm.Foo(\"\", \"\")\n\tassert.True(t, ran)\n}\n\nfunc TestNoUnrollVariadicWithNoVariadicArgument(t *testing.T) {\n\tvar ran bool\n\n\tm := NewMockVariadicWithMultipleReturns(t)\n\tm.EXPECT().Foo(mock.Anything, mock.Anything).Run(\n\t\tfunc(one string, two ...string) {\n\t\t\tran = true\n\t\t},\n\t).Return(\"\", nil)\n\t//nolint: errcheck\n\tm.Foo(\"\")\n\tassert.True(t, ran)\n}\n" }, { "path": "internal/fixtures/variadic_with_no_returns.go", "content": "package test\n\ntype VariadicWithNoReturns interface {\n\tFoo(one string, two ...string)\n}\n" }, { "path": "internal/interface.go", "content": "package internal\n\nimport (\n\t\"go/ast\"\n\n\t\"github.com/vektra/mockery/v3/config\"\n\t\"golang.org/x/tools/go/packages\"\n)\n\ntype Interface struct {\n\tName string // Name of the type to be mocked.\n\tTypeSpec *ast.TypeSpec\n\tGenDecl *ast.GenDecl\n\tFilePath string\n\tFileSyntax *ast.File\n\tPkg *packages.Package\n\tConfig *config.Config\n}\n\nfunc NewInterface(\n\tname string,\n\ttypeSpec *ast.TypeSpec,\n\tgenDecl *ast.GenDecl,\n\tfilepath string,\n\tfileSyntax *ast.File,\n\tpkg *packages.Package,\n\tconfig *config.Config,\n) *Interface {\n\treturn &Interface{\n\t\tName: name,\n\t\tTypeSpec: typeSpec,\n\t\tGenDecl: genDecl,\n\t\tFilePath: filepath,\n\t\tFileSyntax: fileSyntax,\n\t\tPkg: pkg,\n\t\tConfig: config,\n\t}\n}\n" }, { "path": "internal/logging/logging.go", "content": "package logging\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"os\"\n\t\"runtime/debug\"\n\t\"strings\"\n\t\"time\"\n\n\t\"github.com/rs/zerolog\"\n\t\"github.com/vektra/mockery/v3/internal/stackerr\"\n\t\"golang.org/x/term\"\n)\n\nconst (\n\tLogKeyBaseDir = \"base-dir\"\n\tLogKeyDir = \"dir\"\n\tLogKeyDocsURL = \"docs-url\"\n\tLogKeyFile = \"file\"\n\tLogKeyInterface = \"interface\"\n\tLogKeyImport = \"import\"\n\tLogKeyPath = \"path\"\n\tLogKeyQualifiedName = \"qualified-name\"\n\tLogKeyPackageName = \"package-name\"\n\tLogKeyPackagePath = \"package-path\"\n\n\tdefaultSemVer = \"v0.0.0-dev\"\n)\n\n// SemVer is the version of mockery at build time.\nvar SemVer = \"\"\n\nvar ErrPkgNotExist = errors.New(\"package does not exist\")\n\nfunc GetSemverInfo() string {\n\tif SemVer != \"\" {\n\t\treturn SemVer\n\t}\n\tversion, ok := debug.ReadBuildInfo()\n\tif ok && version.Main.Version != \"(devel)\" && version.Main.Version != \"\" {\n\t\treturn version.Main.Version\n\t}\n\treturn defaultSemVer\n}\n\nfunc getMinorSemver(semver string) string {\n\tsplit := strings.Split(semver, \".\")\n\treturn strings.Join(split[0:2], \".\")\n}\n\n// GetMinorSemver returns the semantic version up to and including the minor version.\nfunc GetMinorSemver() string {\n\treturn getMinorSemver(GetSemverInfo())\n}\n\nfunc DocsURL(relativePath string) string {\n\tif string(relativePath[0]) != \"/\" {\n\t\trelativePath = \"/\" + relativePath\n\t}\n\treturn fmt.Sprintf(\"https://vektra.github.io/mockery/%s%s\", GetMinorSemver(), relativePath)\n}\n\ntype timeHook struct{}\n\nfunc (t timeHook) Run(e *zerolog.Event, level zerolog.Level, msg string) {\n\te.Time(\"time\", time.Now())\n}\n\nfunc GetLogger(levelStr string) (zerolog.Logger, error) {\n\tlevel, err := zerolog.ParseLevel(levelStr)\n\tif err != nil {\n\t\treturn zerolog.Logger{}, stackerr.NewStackErrf(err, \"Couldn't parse log level\")\n\t}\n\tout := os.Stderr\n\t// This is essentially RFC3339Nano, but we don't truncate trailing zeros so\n\t// that the log fields are somewhat aligned.\n\ttimeFormat := \"2006-01-02T15:04:05.000000000Z07:00\"\n\twriter := zerolog.ConsoleWriter{\n\t\tOut: out,\n\t\tTimeFormat: timeFormat,\n\t}\n\tzerolog.TimeFieldFormat = timeFormat\n\tif !term.IsTerminal(int(out.Fd())) || os.Getenv(\"TERM\") == \"dumb\" { //nolint:gosec\n\t\twriter.NoColor = true\n\t}\n\tlog := zerolog.New(writer).\n\t\tHook(timeHook{}).\n\t\tLevel(level).\n\t\tWith().\n\t\tStr(\"version\", GetSemverInfo()).\n\t\tLogger()\n\n\treturn log, nil\n}\n\nfunc Warn(ctx context.Context, prefix string, message string, fields map[string]any) {\n\tlog := zerolog.Ctx(ctx)\n\tevent := log.Warn()\n\tif fields != nil {\n\t\tevent = event.Fields(fields)\n\t}\n\tevent.Msgf(\"%s: %s\", prefix, message)\n}\n\nfunc Info(ctx context.Context, prefix string, message string, fields map[string]any) {\n\tlog := zerolog.Ctx(ctx)\n\tevent := log.Info()\n\tif fields != nil {\n\t\tevent = event.Fields(fields)\n\t}\n\tevent.Msgf(\"%s: %s\", prefix, message)\n}\n\nfunc WarnDeprecated(ctx context.Context, message string, fields map[string]any) {\n\tWarn(ctx, \"DEPRECATION\", message, fields)\n}\n" }, { "path": "internal/logging/logging_test.go", "content": "package logging\n\nimport (\n\t\"testing\"\n)\n\nfunc Test_getMinorSemver(t *testing.T) {\n\ttests := []struct {\n\t\tname string\n\t\targ string\n\t\twant string\n\t}{\n\t\t{\n\t\t\tname: \"default semver\",\n\t\t\targ: \"v0.0.0-dev\",\n\t\t\twant: \"v0.0\",\n\t\t},\n\t\t{\n\t\t\tname: \"example semver\",\n\t\t\targ: \"v2.0.1\",\n\t\t\twant: \"v2.0\",\n\t\t},\n\t\t{\n\t\t\tname: \"example semver with alpha notation\",\n\t\t\targ: \"v3.0.0-alpha.0\",\n\t\t\twant: \"v3.0\",\n\t\t},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.name, func(t *testing.T) {\n\t\t\tif got := getMinorSemver(tt.arg); got != tt.want {\n\t\t\t\tt.Errorf(\"getMinorSemver() = %v, want %v\", got, tt.want)\n\t\t\t}\n\t\t})\n\t}\n}\n\nfunc TestDocsURL(t *testing.T) {\n\ttests := []struct {\n\t\tname string\n\t\targ string\n\t\twant string\n\t}{\n\t\t{\n\t\t\tname: \"url with no leading slash\",\n\t\t\targ: \"features\",\n\t\t\twant: \"https://vektra.github.io/mockery/v0.0/features\",\n\t\t},\n\t\t{\n\t\t\tname: \"url with leading slash\",\n\t\t\targ: \"/features\",\n\t\t\twant: \"https://vektra.github.io/mockery/v0.0/features\",\n\t\t},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.name, func(t *testing.T) {\n\t\t\tif got := DocsURL(tt.arg); got != tt.want {\n\t\t\t\tt.Errorf(\"DocsURL() = %v, want %v\", got, tt.want)\n\t\t\t}\n\t\t})\n\t}\n}\n" }, { "path": "internal/mock_matryer.templ", "content": "{{- if (index .TemplateData \"boilerplate-file\") }}\n{{ index .TemplateData \"boilerplate-file\" | readFile }}\n{{- end }}\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: matryer\n{{- if (index .TemplateData \"mock-build-tags\") }}\n\n//go:build {{ index .TemplateData \"mock-build-tags\" }}\n{{- end }}\n\npackage {{.PkgName}}\n\n{{- if .Interfaces.ImplementsSomeMethod }}\n\t{{- $_ := .Registry.AddImport \"sync\" \"sync\" }}\n{{- end }}\n\n{{$srcPkgQualifier := $.SrcPkgQualifier}}\n{{- if not (index .TemplateData \"skip-ensure\") }}\n\t{{- $_ := $.Registry.AddImport $.Registry.SrcPkgName $.Registry.SrcPkg.PkgPath }}\n{{- end }}\n\nimport (\n{{- range .Imports}}\n\t{{ .ImportStatement }}\n\n\t{{- if eq .Path $.Registry.SrcPkg.PkgPath }}\n\t\t{{- $srcPkgQualifier = (printf \"%s.\" .Qualifier) }}\n\t{{- end }}\n{{- end}}\n)\n\n{{range $i, $mock := .Interfaces -}}\n\n{{- if not (index $mock.TemplateData \"skip-ensure\") -}}\n// Ensure that {{.StructName}} does implement {{$srcPkgQualifier}}{{.Name}}.\n// If this is not the case, regenerate this file with mockery.\nvar _ {{$srcPkgQualifier}}{{.Name -}}\n\t{{- if .TypeParams }}[\n\t\t{{- range $index, $param := .TypeParams}}\n\t\t\t{{- if $index}}, {{end -}}\n\t\t\t{{if $param.Constraint}}{{$param.Constraint.String}}{{else}}{{$param.TypeString}}{{end}}\n\t\t{{- end -}}\n\t\t]\n\t{{- end }} = &{{.StructName}}\n\t {{- if .TypeParams }}[\n\t\t{{- range $index, $param := .TypeParams}}\n\t\t\t{{- if $index}}, {{end -}}\n\t\t\t{{if $param.Constraint}}{{$param.Constraint.String}}{{else}}{{$param.TypeString}}{{end}}\n\t\t{{- end -}}\n\t\t]\n\t{{- end -}}\n{}\n{{- end}}\n\n// {{.StructName}} is a mock implementation of {{$srcPkgQualifier}}{{.Name}}.\n//\n//\tfunc TestSomethingThatUses{{.Name}}(t *testing.T) {\n//\n//\t\t// make and configure a mocked {{$srcPkgQualifier}}{{.Name}}\n//\t\tmocked{{.Name}} := &{{.StructName}}{\n\t\t\t{{- range .Methods}}\n//\t\t\t{{.Name}}Func: func({{.ArgList}}) {{.ReturnArgTypeList}} {\n//\t\t\t\tpanic(\"mock out the {{.Name}} method\")\n//\t\t\t},\n\t\t\t{{- end}}\n//\t\t}\n//\n//\t\t// use mocked{{.Name}} in code that requires {{$srcPkgQualifier}}{{.Name}}\n//\t\t// and then make assertions.\n//\n//\t}\ntype {{.StructName}}\n{{- if .TypeParams -}}\n\t[{{- range $index, $param := .TypeParams}}\n\t\t\t{{- if $index}}, {{end}}{{$param.Name | exported}} {{$param.TypeString}}\n\t{{- end -}}]\n{{- end }} struct {\n{{- range .Methods}}\n\t// {{.Name}}Func mocks the {{.Name}} method.\n\t{{.Name}}Func func({{.ArgList}}) {{.ReturnArgTypeList}}\n{{end}}\n\t// calls tracks calls to the methods.\n\tcalls struct {\n{{- range .Methods}}\n\t\t// {{.Name}} holds details about calls to the {{.Name}} method.\n\t\t{{.Name}} []struct {\n\t\t\t{{- range .Params}}\n\t\t\t// {{.Name | exported}} is the {{.Name}} argument value.\n\t\t\t{{.Name | exported}} {{.TypeString}}\n\t\t\t{{- end}}\n\t\t}\n{{- end}}\n\t}\n{{- range $i, $method := .Methods}}\n\tlock{{ $method.Name }} {{ $.Imports.PkgQualifier \"sync\" }}.RWMutex\n{{- end}}\n}\n{{range .Methods}}\n// {{.Name}} calls {{.Name}}Func.\nfunc (mock *{{$mock.StructName}}{{ $mock.TypeInstantiation }}) {{.Name}}({{.ArgList}}) {{.ReturnArgTypeList}} {\n{{- if not (index $mock.TemplateData \"stub-impl\") }}\n\tif mock.{{.Name}}Func == nil {\n\t\tpanic(\"{{$mock.StructName}}.{{.Name}}Func: method is nil but {{$mock.Name}}.{{.Name}} was just called\")\n\t}\n{{- end}}\n\tcallInfo := struct {\n\t\t{{- range .Params}}\n\t\t{{.Name | exported}} {{.TypeString}}\n\t\t{{- end}}\n\t}{\n\t\t{{- range .Params}}\n\t\t{{.Name | exported}}: {{.Name}},\n\t\t{{- end}}\n\t}\n\tmock.lock{{.Name}}.Lock()\n\tmock.calls.{{.Name}} = append(mock.calls.{{.Name}}, callInfo)\n\tmock.lock{{.Name}}.Unlock()\n{{- if .Returns}}\n\t{{- if (index $mock.TemplateData \"stub-impl\") }}\n\tif mock.{{.Name}}Func == nil {\n\t\tvar (\n\t\t{{- range .Returns}}\n\t\t\t{{.Name}} {{.TypeString}}\n\t\t{{- end}}\n\t\t)\n\t\treturn {{.ReturnArgNameList}}\n\t}\n\t{{- end}}\n\treturn mock.{{.Name}}Func({{.ArgCallList}})\n{{- else}}\n\t{{- if (index $mock.TemplateData \"stub-impl\") }}\n\tif mock.{{.Name}}Func == nil {\n\t\treturn\n\t}\n\t{{- end}}\n\tmock.{{.Name}}Func({{.ArgCallList}})\n{{- end}}\n}\n\n// {{.Name}}Calls gets all the calls that were made to {{.Name}}.\n// Check the length with:\n//\n//\tlen(mocked{{$mock.Name}}.{{.Name}}Calls())\nfunc (mock *{{$mock.StructName}}{{ $mock.TypeInstantiation }}) {{.Name}}Calls() []struct {\n\t\t{{- range .Params}}\n\t\t{{.Name | exported}} {{.TypeString}}\n\t\t{{- end}}\n\t} {\n\tvar calls []struct {\n\t\t{{- range .Params}}\n\t\t{{.Name | exported}} {{.TypeString}}\n\t\t{{- end}}\n\t}\n\tmock.lock{{.Name}}.RLock()\n\tcalls = mock.calls.{{.Name}}\n\tmock.lock{{.Name}}.RUnlock()\n\treturn calls\n}\n{{- if index $.TemplateData \"with-resets\" }}\n// Reset{{.Name}}Calls reset all the calls that were made to {{.Name}}.\nfunc (mock *{{$mock.StructName}}{{ $mock.TypeInstantiation }}) Reset{{.Name}}Calls() {\n\tmock.lock{{.Name}}.Lock()\n\tmock.calls.{{.Name}} = nil\n\tmock.lock{{.Name}}.Unlock()\n}\n{{end}}\n{{end -}}\n{{- if index $.TemplateData \"with-resets\" }}\n// ResetCalls reset all the calls that were made to all mocked methods.\nfunc (mock *{{$mock.StructName}}{{ $mock.TypeInstantiation }}) ResetCalls() {\n\t{{- range .Methods}}\n\tmock.lock{{.Name}}.Lock()\n\tmock.calls.{{.Name}} = nil\n\tmock.lock{{.Name}}.Unlock()\n\t{{end -}}\n}\n{{end -}}\n{{end -}}" }, { "path": "internal/mock_matryer.templ.schema.json", "content": "{\n \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n \"title\": \"vektra/mockery matryer mock\",\n \"type\": \"object\",\n \"additionalProperties\": false,\n \"properties\": {\n \"boilerplate-file\": {\n \"type\": \"string\"\n },\n \"mock-build-tags\": {\n \"type\": \"string\"\n },\n \"skip-ensure\": {\n \"type\": \"boolean\"\n },\n \"stub-impl\": {\n \"type\": \"boolean\"\n },\n \"with-resets\": {\n \"type\": \"boolean\"\n }\n },\n \"required\": []\n }" }, { "path": "internal/mock_testify.templ", "content": "{{- if (index .TemplateData \"boilerplate-file\") }}\n{{ index .TemplateData \"boilerplate-file\" | readFile }}\n{{- end }}\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n{{- if (index .TemplateData \"mock-build-tags\") }}\n\n//go:build {{ index .TemplateData \"mock-build-tags\" }}\n{{- end }}\n\npackage {{.PkgName}}\n\nimport (\n{{- range .Imports}}\n\t{{ .ImportStatement }}\n{{- end}}\n mock \"github.com/stretchr/testify/mock\"\n)\n\n{{/* CREATE CONSTRUCTOR */}}\n\n{{- range $i, $mock := .Interfaces }} {{/* START MOCK RANGE */}}\n{{ $new := \"New\" }}\n{{ if firstIsLower .StructName }}\n{{ $new = \"new\" }}\n{{- end }}\n{{- $constructorName := printf \"%s%s\" $new (.StructName | firstUpper) }}\n\n// {{ $constructorName }} creates a new instance of {{ .StructName }}. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc {{ $constructorName }}{{ $mock.TypeConstraint }} (t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *{{ .StructName }}{{ $mock.TypeInstantiation }} {\n\tmock := &{{ .StructName }}{{ $mock.TypeInstantiation }}{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n\n// {{ .StructName }} is an autogenerated mock type for the {{ .Name }} type\ntype {{ .StructName }}{{ $mock.TypeConstraint }} struct {\n\tmock.Mock\n}\n\ntype {{.StructName}}_Expecter{{ $mock.TypeConstraint }} struct {\n\tmock *mock.Mock\n}\n\n{{- $expecterNameInstantiated := printf \"%s_Expecter%s\" .StructName ($mock.TypeInstantiation) }}\n\nfunc (_m *{{.StructName}}{{ $mock.TypeInstantiation }}) EXPECT() *{{ $expecterNameInstantiated }} {\n\treturn &{{ $expecterNameInstantiated }}{mock: &_m.Mock}\n}\n\n{{/* RANGE OVER ALL METHODS */}}\n{{- range $methodIdx, $method := .Methods }} {{/* START METHOD RANGE */}}\n\n// {{ $method.Name }} provides a mock function for the type {{ $mock.StructName }}\nfunc (_mock *{{$mock.StructName}}{{ $mock.TypeInstantiation }}) {{$method.Name}}({{$method.ArgList}}) {{$method.ReturnArgTypeList}} {\n\t{{- $calledString := \"\" }}\n{{- if or\n\t(eq (len $method.ArgList) 0)\n\t(not $method.IsVariadic)\n\t(not (index $mock.TemplateData \"unroll-variadic\"))\n}} {{/* START PREAMBLE */}}\n\t{{- if and\n\t\t($method.IsVariadic)\n\t\t(not (index $mock.TemplateData \"unroll-variadic\"))\n\t}}\n\n\t{{- if ne (len $method.Returns) 0}}\n\tvar tmpRet mock.Arguments\n\t{{- $calledString = \"tmpRet\" }}\n\t{{- else }}\n\t{{- $calledString = \"\" }}\n\t{{- end }}\n\n\t{{- $lastParam := index $method.Params (len $method.Params | add -1 )}}\n\tif len({{ $lastParam.Var.Name }}) > 0 {\n\t\t{{- if ne (len $method.Returns) 0}}tmpRet = {{ end }}_mock.Called({{- if (index $mock.TemplateData \"unroll-variadic\") }}{{ $method.ArgCallList }}{{- else }}{{ $method.ArgCallListNoEllipsis }}{{- end }})\n\t} else {\n\t\t{{- if ne (len $method.Returns) 0}}tmpRet = {{ end }}_mock.Called({{- if (index $mock.TemplateData \"unroll-variadic\") }}{{ $method.ArgCallListSlice 0 (len $method.Params | add -1 )}}{{- else }}{{ $method.ArgCallListSliceNoEllipsis 0 (len $method.Params | add -1 )}}{{- end }})\n\t}\n\t{{- else }}\n\t{{- $calledString = printf \"_mock.Called(%s)\" $method.ArgCallList }}\n\t{{- end }}\n{{- else }}\n\t{{- $lastParam := (index $method.Params (len $method.Params | add -1)) }}\n\t{{- $variadicArgsName := $lastParam.Var.Name }}\n\t{{- $strippedTypeString := trimPrefix \"...\" $lastParam.TypeStringEllipsis }}\n\n\t{{- if and (ne $strippedTypeString \"interface{}\") (ne $strippedTypeString \"any\") }}\n\t// {{ $strippedTypeString }}\n\t_va := make([]interface{}, len({{- $lastParam.Var.Name }}))\n\tfor _i := range {{ $lastParam.Var.Name }} {\n\t\t_va[_i] = {{ $lastParam.Var.Name }}[_i]\n\t}\n\t\t{{- $variadicArgsName = \"_va\" }}\n\t{{- end }}\n\tvar _ca []interface{}\n\t{{- if gt (len $method.Params) 1 }}\n\t_ca = append(_ca, {{ $method.ArgCallListSlice 0 (len $method.Params | add -1) }})\n\t{{- end }}\n\t_ca = append(_ca, {{ $variadicArgsName }}...)\n\t{{- $calledString = \"_mock.Called(_ca...)\" }}\n{{- end }} {{/* END PREAMBLE */}}\n\t{{- if eq (len $method.Returns) 0 }}\n\t{{ $calledString }}\n\t{{- else }}\n\t{{- $retArgs := $method.Scope.AllocateName \"ret\" }}\n\t{{ $retArgs }} := {{ $calledString }}\n\n\tif len({{ $retArgs }}) == 0 {\n\t\tpanic(\"no return value specified for {{$method.Name}}\")\n\t}\n\n\t\t{{ range $retIdx, $ret := $method.Returns }}\n\tvar r{{ $retIdx }} {{ (index $method.Returns $retIdx).TypeString }}\n\t\t{{- end }}\n\n\t\t{{- if gt (len $method.Returns) 1 }}\n\tif returnFunc, ok := {{ $retArgs }}.Get(0).(func{{ $method.SignatureNoName }}); ok {\n\t\treturn returnFunc({{ $method.ArgCallList }})\n\t}\n\t\t{{- end }}\n\n\t\t{{- range $retIdx, $ret := $method.Returns }} {{/* START RETURN RANGE */}}\n\tif returnFunc, ok := {{ $retArgs }}.Get({{ $retIdx }}).(func({{$method.ArgTypeListEllipsis }}) {{ (index $method.Returns $retIdx).TypeString }}); ok {\n\t\tr{{ $retIdx }} = returnFunc({{ $method.ArgCallList }})\n\t} else {\n\t\t{{- if eq \"error\" (index $method.Returns $retIdx).TypeString }}\n\t\tr{{ $retIdx }} = {{ $retArgs }}.Error({{ $retIdx }})\n\t\t{{- else if (index $method.Returns $retIdx).Var.Nillable }}\n\t\tif {{ $retArgs }}.Get({{ $retIdx }}) != nil {\n\t\t\tr{{ $retIdx }} = {{ $retArgs }}.Get({{ $retIdx }}).({{ (index $method.Returns $retIdx).TypeString }})\n\t\t}\n\t\t{{- else }}\n\t\tr{{ $retIdx }} = {{ $retArgs }}.Get({{ $retIdx }}).({{ (index $method.Returns $retIdx).TypeString }})\n\t\t{{- end }}\n\t}\n\t\t{{- end }} {{/* END RETURN RANGE */}}\n\t{{- end }}\n\treturn {{ range $retIdx, $ret := $method.Returns }}r{{ $retIdx }}{{ if ne $retIdx (len $method.Returns | add -1) }}, {{ end }}{{ end }}\n}\n\n{{/* CREATE EXPECTER METHOD */}}\n{{- $ExpecterCallNameInstantiated := printf \"%s_%s_Call%s\" $mock.StructName $method.Name ($mock.TypeInstantiation) }}\n{{- $ExpecterCallNameConstraint := printf \"%s_%s_Call%s\" $mock.StructName $method.Name ($mock.TypeConstraint) }}\n\n// {{ $mock.StructName }}_{{ $method.Name }}_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method '{{ $method.Name }}'\ntype {{ $ExpecterCallNameConstraint }} struct {\n\t*mock.Call\n}\n\n\n// {{ $method.Name }} is a helper method to define mock.On call\n{{- range $method.Params }}\n// - {{.Var.Name}} {{.TypeStringEllipsis}}\n{{- end}}\nfunc (_e *{{ $expecterNameInstantiated }}) {{ $method.Name }}({{ range $method.Params }}{{ .Var.Name }} {{ if .Variadic }}...{{end}}interface{}, {{ end }}) *{{ $ExpecterCallNameInstantiated }} {\n\treturn &{{ $ExpecterCallNameInstantiated }}{Call: _e.mock.On(\"{{$method.Name}}\",\n\t\t\t{{- if not $method.IsVariadic }}\n\t\t\t\t{{- range $method.Params}}{{.Var.Name}},{{end}}\n\t\t\t{{- else }}\n\t\t\t\tappend([]interface{}{\n\t\t\t\t\t{{- range $i, $param := $method.Params }}\n\t\t\t\t\t\t{{- if (lt $i (len $method.Params | add -1 ))}} {{ $param.Var.Name }},\n\t\t\t\t\t\t{{- else }} }, {{ $param.Var.Name }}...\n\t\t\t\t\t\t{{- end }}\n\t\t\t\t\t{{- end}} )...\n\t\t\t{{- end }} )}\n}\n\nfunc (_c *{{ $ExpecterCallNameInstantiated }}) Run(run func({{ $method.ArgList }})) *{{ $ExpecterCallNameInstantiated }} {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t{{- range $i, $param := $method.Params }}\n\t\tvar arg{{ $i }} {{ $param.TypeString }}\n\t\t{{- if and $method.IsVariadic (eq ($i) (len $method.Params | add -1))}}\n\n\t\t\t{{- $variadicParam := index $method.Params (len $method.Params | add -1) }}\n\t\t\t{{- $nonVariadicParams := slice $method.Params 0 (len $method.Params | add -1 )}}\n\n\t\t\t{{- if index $mock.TemplateData \"unroll-variadic\" }}\n\t\tvariadicArgs := make([]{{ $variadicParam.TypeStringVariadicUnderlying }}, len(args) - {{len $nonVariadicParams}})\n\t\tfor i, a := range args[{{len $nonVariadicParams}}:] {\n\t\t\tif a != nil {\n\t\t\t\tvariadicArgs[i] = a.({{ $variadicParam.TypeStringVariadicUnderlying }})\n\t\t\t}\n\t\t}\n\t\t\t{{- else }}\n\t\tvar variadicArgs {{ $variadicParam.TypeString }}\n\t\tif len(args) > {{ len $nonVariadicParams }} {\n\t\t\tvariadicArgs = args[{{ len $nonVariadicParams }}].({{ $variadicParam.TypeString }})\n\t\t}\n\t\t\t{{- end }}\n\t\targ{{ $i }} = variadicArgs\n\t\t{{- else }}\n\t\tif args[{{ $i }}] != nil {\n\t\t\targ{{ $i }} = args[{{ $i }}].({{ $param.TypeString }})\n\t\t}\n\t\t{{- end }}\n\t{{- end }}\n\t\trun(\n\t\t\t{{- range $i, $param := $method.Params }}\n\t\t\t{{- if and ($method.IsVariadic) (eq $i (len $method.Params | add -1 )) }}\n\t\t\targ{{ $i }}...,\n\t\t\t{{- else }}\n\t\t\targ{{ $i }},\n\t\t\t{{- end }}\n\t\t\t{{- end }}\n\t\t)\n\t})\n\treturn _c\n}\n\nfunc (_c *{{ $ExpecterCallNameInstantiated }}) Return({{ $method.ReturnArgList }}) *{{ $ExpecterCallNameInstantiated }} {\n\t_c.Call.Return({{ $method.ReturnArgNameList }})\n\treturn _c\n}\n\nfunc (_c *{{ $ExpecterCallNameInstantiated }}) RunAndReturn(run func({{ $method.ArgList }}){{ $method.ReturnArgTypeList }}) *{{ $ExpecterCallNameInstantiated }} {\n{{- if eq (len $method.Returns) 0 }}\n\t_c.Run(run)\n{{- else}}\n\t_c.Call.Return(run)\n{{- end}}\n\treturn _c\n}\n{{/* END TODO EXPECTER */}}\n{{- end }} {{/* END METHOD RANGE */}}\n{{- end }} {{/* END MOCK RANGE */}}\n\n" }, { "path": "internal/mock_testify.templ.schema.json", "content": "{\n \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n \"title\": \"vektra/mockery testify mock\",\n \"type\": \"object\",\n \"additionalProperties\": false,\n \"properties\": {\n \"boilerplate-file\": {\n \"type\": \"string\"\n },\n \"mock-build-tags\": {\n \"type\": \"string\"\n },\n \"unroll-variadic\": {\n \"type\": \"boolean\"\n }\n },\n \"required\": []\n }" }, { "path": "internal/mockery_test.go", "content": "package internal_test\n\nimport (\n\t\"path/filepath\"\n\t\"runtime\"\n)\n\nvar rootPath, testFile, testFile2 string\n\nfunc init() {\n\t_, file, _, ok := runtime.Caller(0)\n\tif !ok {\n\t\tpanic(\"failed to determine current file path\")\n\t}\n\n\trootPath = filepath.Dir(filepath.Dir(file))\n\n\ttestFile = getFixturePath(\"requester.go\")\n\ttestFile2 = getFixturePath(\"requester2.go\")\n}\n\n// getFixturePath returns an absolute path to a fixture sub-directory or file.\n//\n// getFixturePath(\"src.go\") returns \"/path/to/pkg/fixtures/src.go\"\n// getFixturePath(\"a\", \"b\", \"c\", \"src.go\") returns \"/path/to/pkg/fixtures/a/b/c/src.go\"\nfunc getFixturePath(subdirOrBasename ...string) string {\n\treturn filepath.Join(append([]string{rootPath, \"pkg\", \"fixtures\"}, subdirOrBasename...)...)\n}\n" }, { "path": "internal/node_visitor.go", "content": "package internal\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"go/ast\"\n\n\t\"github.com/rs/zerolog\"\n)\n\ntype declaredInterface struct {\n\ttypeSpec *ast.TypeSpec\n\tgenDecl *ast.GenDecl\n}\n\ntype NodeVisitor struct {\n\tdeclaredInterfaces []declaredInterface\n\tctx context.Context\n\tlastSeenGenDecl *ast.GenDecl\n}\n\nfunc NewNodeVisitor(ctx context.Context) *NodeVisitor {\n\treturn &NodeVisitor{\n\t\tdeclaredInterfaces: make([]declaredInterface, 0),\n\t\tctx: ctx,\n\t}\n}\n\nfunc (nv *NodeVisitor) DeclaredInterfaces() []declaredInterface {\n\treturn nv.declaredInterfaces\n}\n\nfunc (nv *NodeVisitor) Visit(node ast.Node) ast.Visitor {\n\tlog := zerolog.Ctx(nv.ctx)\n\n\tswitch n := node.(type) {\n\tcase *ast.GenDecl:\n\t\t// If the next node in the AST is an *ast.TypeSpec, we can rely on this\n\t\t// being its parent GenDecl because the walk is done depth-first.\n\t\tnv.lastSeenGenDecl = n\n\tcase *ast.TypeSpec:\n\t\tlog := log.With().\n\t\t\tStr(\"node-name\", n.Name.Name).\n\t\t\tStr(\"node-type\", fmt.Sprintf(\"%T\", n.Type)).\n\t\t\tLogger()\n\n\t\tswitch n.Type.(type) {\n\t\tcase *ast.InterfaceType, *ast.IndexExpr, *ast.IndexListExpr, *ast.SelectorExpr, *ast.Ident:\n\t\t\tlog.Debug().Msg(\"found node with acceptable type for mocking.\")\n\t\t\tnv.declaredInterfaces = append(nv.declaredInterfaces, declaredInterface{\n\t\t\t\ttypeSpec: n,\n\t\t\t\tgenDecl: nv.lastSeenGenDecl,\n\t\t\t})\n\t\tdefault:\n\t\t\tlog.Debug().Msg(\"found node with unacceptable type for mocking. Rejecting.\")\n\t\t}\n\t}\n\treturn nv\n}\n" }, { "path": "internal/parse.go", "content": "package internal\n\nimport (\n\t\"bufio\"\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"go/ast\"\n\t\"go/types\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"regexp\"\n\t\"strings\"\n\n\t\"github.com/rs/zerolog\"\n\t\"github.com/vektra/mockery/v3/config\"\n\t\"github.com/vektra/mockery/v3/internal/logging\"\n\t\"github.com/vektra/mockery/v3/internal/stackerr\"\n\t\"golang.org/x/tools/go/packages\"\n)\n\nvar autoGeneratedRegex = regexp.MustCompile(`^\\/\\/ Code generated by .* DO NOT EDIT(\\.?)( )*$`)\n\ntype Parser struct {\n\tparserPackages []*types.Package\n\tconf packages.Config\n\tmockeryConfig config.RootConfig\n}\n\nfunc NewParser(buildTags []string, mockeryConfig config.RootConfig) *Parser {\n\tvar conf packages.Config\n\tconf.Mode = packages.NeedTypes |\n\t\tpackages.NeedTypesSizes |\n\t\tpackages.NeedSyntax |\n\t\tpackages.NeedTypesInfo |\n\t\tpackages.NeedImports |\n\t\tpackages.NeedName |\n\t\tpackages.NeedFiles |\n\t\tpackages.NeedCompiledGoFiles\n\n\tif len(buildTags) > 0 {\n\t\tconf.BuildFlags = []string{\"-tags\", strings.Join(buildTags, \",\")}\n\t}\n\tp := &Parser{\n\t\tparserPackages: make([]*types.Package, 0),\n\t\tconf: conf,\n\t\tmockeryConfig: mockeryConfig,\n\t}\n\treturn p\n}\n\nfunc (p *Parser) ParsePackages(ctx context.Context, packageNames []string) ([]*Interface, error) {\n\tlog := zerolog.Ctx(ctx)\n\tinterfaces := []*Interface{}\n\n\tpackages, err := packages.Load(&p.conf, packageNames...)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tfor _, pkg := range packages {\n\t\tpkgLog := log.With().Str(\"package\", pkg.PkgPath).Logger()\n\t\tpkgCtx := pkgLog.WithContext(ctx)\n\t\tpkgConfig, err := p.mockeryConfig.GetPackageConfig(ctx, pkg.PkgPath)\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"getting package-level config: %w\", err)\n\t\t}\n\n\t\tif len(pkg.GoFiles) == 0 {\n\t\t\tcontinue\n\t\t}\n\t\tfor _, err := range pkg.Errors {\n\t\t\tlog.Err(err).Msg(\"encountered error when loading package\")\n\t\t}\n\t\tif len(pkg.Errors) != 0 {\n\t\t\treturn nil, errors.New(\"error occurred when loading packages\")\n\t\t}\n\t\tfor fileIdx, filePath := range pkg.GoFiles {\n\t\t\tfilePath = filepath.ToSlash(filePath)\n\t\t\tfileLog := pkgLog.With().Str(\"file\", filePath).Logger()\n\t\t\tfileLog.Debug().Msg(\"found file\")\n\n\t\t\tif *pkgConfig.Config.IncludeAutoGenerated == false {\n\t\t\t\tisGenerated, err := isAutoGenerated(filePath)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn nil, fmt.Errorf(\"determining if file is auto-generated: %w\", err)\n\t\t\t\t}\n\t\t\t\tif isGenerated {\n\t\t\t\t\tfileLog.Debug().Str(\"docs-url\", logging.DocsURL(\"/include-auto-generated\")).Msg(\"file is auto-generated, skipping.\")\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfileLog.Debug().Msg(\"file is not auto-generated.\")\n\n\t\t\tfileCtx := fileLog.WithContext(pkgCtx)\n\n\t\t\tfileSyntax := pkg.Syntax[fileIdx]\n\t\t\tnv := NewNodeVisitor(fileCtx)\n\t\t\tast.Walk(nv, fileSyntax)\n\n\t\t\tscope := pkg.Types.Scope()\n\t\t\tfor _, declaredInterface := range nv.declaredInterfaces {\n\t\t\t\tifaceLog := fileLog.With().Str(\"interface\", declaredInterface.typeSpec.Name.Name).Logger()\n\n\t\t\t\tobj := scope.Lookup(declaredInterface.typeSpec.Name.Name)\n\t\t\t\tif obj == nil {\n\t\t\t\t\tlog.Debug().Str(\"identifier-name\", declaredInterface.typeSpec.Name.Name).Msg(\"obj was nil\")\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\n\t\t\t\tvar typ *types.Named\n\t\t\t\tvar name string\n\t\t\t\tttyp := obj.Type()\n\n\t\t\t\tif talias, ok := obj.Type().(*types.Alias); ok {\n\t\t\t\t\tname = talias.Obj().Name()\n\t\t\t\t\tttyp = types.Unalias(obj.Type())\n\t\t\t\t}\n\n\t\t\t\ttyp, ok := ttyp.(*types.Named)\n\t\t\t\tif !ok {\n\t\t\t\t\tifaceLog.Debug().Msg(\"interface is not named, skipping\")\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\n\t\t\t\tif name == \"\" {\n\t\t\t\t\tname = typ.Obj().Name()\n\t\t\t\t}\n\n\t\t\t\tif typ.Obj().Pkg() == nil {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\n\t\t\t\tif !types.IsInterface(typ.Underlying()) {\n\t\t\t\t\tifaceLog.Debug().Msg(\"type is not an interface, skipping\")\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\n\t\t\t\tif isConstraint(declaredInterface.typeSpec, packages) {\n\t\t\t\t\tifaceLog.Debug().Msg(\"interface is a constraint, skipping\")\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\n\t\t\t\tinterfaces = append(interfaces, NewInterface(\n\t\t\t\t\tname,\n\t\t\t\t\tdeclaredInterface.typeSpec,\n\t\t\t\t\tdeclaredInterface.genDecl,\n\t\t\t\t\tfilePath,\n\t\t\t\t\tfileSyntax,\n\t\t\t\t\tpkg,\n\t\t\t\t\t// Leave the config nil because we don't yet know if\n\t\t\t\t\t// the interface should even be generated in the first\n\t\t\t\t\t// place.\n\t\t\t\t\tnil,\n\t\t\t\t))\n\t\t\t}\n\t\t}\n\t}\n\treturn interfaces, nil\n}\n\nfunc isAutoGenerated(pathName string) (bool, error) {\n\tfile, err := os.Open(pathName)\n\tif err != nil {\n\t\treturn false, stackerr.NewStackErr(err)\n\t}\n\tdefer file.Close()\n\tscanner := bufio.NewScanner(file)\n\tfor scanner.Scan() {\n\t\ttext := scanner.Text()\n\t\tif autoGeneratedRegex.MatchString(text) {\n\t\t\treturn true, nil\n\t\t} else if strings.HasPrefix(text, \"package \") {\n\t\t\tbreak\n\t\t}\n\t}\n\treturn false, nil\n}\n\nfunc isConstraint(s *ast.TypeSpec, pkgs []*packages.Package) bool {\n\tswitch typ := s.Type.(type) {\n\tcase *ast.Ident:\n\t\treturn isConstraintIdent(typ, pkgs)\n\tcase *ast.SelectorExpr:\n\t\treturn isConstraintSelector(typ, pkgs)\n\tcase *ast.InterfaceType:\n\t\tfor _, item := range typ.Methods.List {\n\t\t\tswitch expr := item.Type.(type) {\n\t\t\tcase *ast.UnaryExpr, *ast.BinaryExpr:\n\t\t\t\treturn true\n\t\t\tcase *ast.SelectorExpr:\n\t\t\t\treturn isConstraintSelector(expr, pkgs)\n\t\t\tcase *ast.Ident:\n\t\t\t\treturn isConstraintIdent(expr, pkgs)\n\t\t\t}\n\t\t}\n\t}\n\n\treturn false\n}\n\nfunc isConstraintSelector(sel *ast.SelectorExpr, pkgs []*packages.Package) bool {\n\tfor _, pkg := range pkgs {\n\t\tif tv, ok := pkg.TypesInfo.Types[sel]; ok {\n\t\t\tif iface, ok := tv.Type.Underlying().(*types.Interface); ok {\n\t\t\t\treturn isConstraintInterface(iface)\n\t\t\t}\n\t\t}\n\t}\n\n\treturn false\n}\n\nfunc isConstraintIdent(id *ast.Ident, pkgs []*packages.Package) bool {\n\tfor _, pkg := range pkgs {\n\t\tif obj := pkg.TypesInfo.Uses[id]; obj != nil {\n\t\t\tif iface, ok := obj.Type().Underlying().(*types.Interface); ok {\n\t\t\t\treturn isConstraintInterface(iface)\n\t\t\t}\n\t\t}\n\t}\n\n\treturn false\n}\n\nfunc isConstraintInterface(iface *types.Interface) bool {\n\tif iface.NumMethods() > 0 {\n\t\treturn false\n\t}\n\n\tif iface.NumEmbeddeds() > 0 {\n\t\treturn true\n\t}\n\n\treturn false\n}\n" }, { "path": "internal/remote_template.go", "content": "package internal\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\t\"os\"\n\t\"strings\"\n\n\t\"github.com/rs/zerolog\"\n\t\"github.com/xeipuuv/gojsonschema\"\n)\n\nfunc httpsGet(ctx context.Context, url string) (string, error) {\n\tlog := zerolog.Ctx(ctx)\n\t//nolint: gosec\n\tresponse, err := http.Get(url)\n\tif err != nil {\n\t\tlog.Err(err).Msg(\"failed to download file\")\n\t\treturn \"\", fmt.Errorf(\"downloading file: %w\", err)\n\t}\n\tdefer response.Body.Close()\n\tbody, err := io.ReadAll(response.Body)\n\tif err != nil {\n\t\tlog.Err(err).Msg(\"failed to read response body\")\n\t\treturn \"\", fmt.Errorf(\"reading response body: %w\", err)\n\t}\n\tif response.StatusCode != 200 {\n\t\tlog.Debug().Int(\"status-code\", response.StatusCode).Msg(\"got non-200 response when downloading file. Logging response body:\")\n\t\tlog.Debug().Msg(string(body))\n\t\treturn \"\", fmt.Errorf(\"got http code %d: %w\", response.StatusCode, errBadHTTPStatus)\n\t}\n\treturn string(body), nil\n}\n\nfunc download(ctx context.Context, url string) (string, error) {\n\tif strings.HasPrefix(url, \"file://\") {\n\t\ttemplatePath := strings.SplitAfterN(url, \"file://\", 2)[1]\n\t\tb, err := os.ReadFile(templatePath)\n\t\tif err != nil {\n\t\t\treturn \"\", err\n\t\t}\n\t\treturn string(b), nil\n\t}\n\tif strings.HasPrefix(url, \"https://\") || strings.HasPrefix(url, \"http://\") {\n\t\ttemplateString, err := httpsGet(ctx, url)\n\t\tif err != nil {\n\t\t\treturn \"\", fmt.Errorf(\"downloading url: %w\", err)\n\t\t}\n\t\treturn templateString, nil\n\t}\n\treturn \"\", fmt.Errorf(\"unsupported protocol specifier in %s\", url)\n}\n\ntype RemoteTemplate struct {\n\ttemplateURL string\n\ttemplateString string\n\ttemplateDownloaded bool\n\n\tschemaURL string\n\tschema *gojsonschema.Schema\n\tschemaDownloaded bool\n\n\trequireSchemaExists bool\n}\n\nfunc NewRemoteTemplate(templateURL string, schemaURL string) *RemoteTemplate {\n\treturn &RemoteTemplate{\n\t\ttemplateURL: templateURL,\n\t\tschemaURL: schemaURL,\n\t}\n}\n\n// Template will return the template string. It downloads the remote template once\n// and caches the result for future calls.\nfunc (r *RemoteTemplate) Template(ctx context.Context) (string, error) {\n\tvar err error\n\tif !r.templateDownloaded {\n\t\tr.templateDownloaded = true\n\t\tr.templateString, err = download(ctx, r.templateURL)\n\t\tif err != nil {\n\t\t\treturn \"\", fmt.Errorf(\"downloading template: %w\", err)\n\t\t}\n\t}\n\treturn r.templateString, nil\n}\n\n// Schema returns the JSON Schema as a string. It downloads the remote schema once\n// and caches the result for future calls.\nfunc (r *RemoteTemplate) Schema(ctx context.Context) (*gojsonschema.Schema, error) {\n\tlog := zerolog.Ctx(ctx)\n\tlog.UpdateContext(func(c zerolog.Context) zerolog.Context {\n\t\treturn c.Str(\"remote-template\", r.templateURL)\n\t})\n\tif !r.schemaDownloaded {\n\t\tlog.Debug().Msg(\"schema not downloaded before\")\n\t\tr.schemaDownloaded = true\n\t\tschemaString, err := download(ctx, r.schemaURL)\n\t\tif err != nil {\n\t\t\tlog.Debug().Err(err).Msg(\"schema download encountered error\")\n\t\t\treturn nil, fmt.Errorf(\"downloading schema: %w\", err)\n\t\t}\n\t\tr.schema, err = gojsonschema.NewSchema(gojsonschema.NewStringLoader(schemaString))\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"creating JSON schema: %w\", err)\n\t\t}\n\t}\n\treturn r.schema, nil\n}\n" }, { "path": "internal/stackerr/stackerr.go", "content": "package stackerr\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"runtime/debug\"\n)\n\ntype StackErr struct {\n\tcause error\n\tstack []byte\n}\n\nfunc NewStackErr(cause error) error {\n\treturn StackErr{\n\t\tcause: cause,\n\t\tstack: debug.Stack(),\n\t}\n}\n\nfunc NewStackErrf(cause error, f string, args ...any) error {\n\tmsg := fmt.Sprintf(f, args...)\n\tcause = fmt.Errorf(msg+\": %w\", cause)\n\treturn NewStackErr(cause)\n}\n\nfunc (se StackErr) Error() string {\n\treturn se.cause.Error()\n}\n\nfunc (se StackErr) Unwrap() error {\n\treturn se.cause\n}\n\nfunc (se StackErr) Stack() []byte {\n\treturn se.stack\n}\n\nfunc GetStack(err error) ([]byte, bool) {\n\tvar s interface {\n\t\tStack() []byte\n\t}\n\tif errors.As(err, &s) {\n\t\treturn s.Stack(), true\n\t}\n\treturn nil, false\n}\n" }, { "path": "internal/stackerr/stackerr_test.go", "content": "package stackerr\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestStackErr(t *testing.T) {\n\terr := assert.AnError\n\n\ts, ok := GetStack(err)\n\tassert.False(t, ok)\n\tassert.Empty(t, s)\n\n\terr = NewStackErr(err)\n\tassert.Equal(t, assert.AnError.Error(), err.Error())\n\n\ts, ok = GetStack(err)\n\tassert.True(t, ok)\n\tassert.NotEmpty(t, s)\n\n\terr = NewStackErr(fmt.Errorf(\"wrapped error can still get stack: %w\", err))\n\ts, ok = GetStack(err)\n\tassert.True(t, ok)\n\tassert.NotEmpty(t, s)\n}\n\nfunc TestStackErrf(t *testing.T) {\n\terr := assert.AnError\n\n\ts, ok := GetStack(err)\n\tassert.False(t, ok)\n\tassert.Empty(t, s)\n\n\terr = NewStackErrf(err, \"error message %d %s\", 1, \"a\")\n\tassert.Equal(t, \"error message 1 a: \"+assert.AnError.Error(), err.Error())\n\n\ts, ok = GetStack(err)\n\tassert.True(t, ok)\n\tassert.NotEmpty(t, s)\n}\n" }, { "path": "internal/template_generator.go", "content": "package internal\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"context\"\n\t_ \"embed\"\n\t\"errors\"\n\t\"fmt\"\n\t\"go/format\"\n\t\"go/token\"\n\t\"go/types\"\n\t\"path/filepath\"\n\t\"strings\"\n\n\t\"github.com/rs/zerolog\"\n\t\"github.com/vektra/mockery/v3/config\"\n\t\"github.com/vektra/mockery/v3/internal/file\"\n\t\"github.com/vektra/mockery/v3/internal/stackerr\"\n\t\"github.com/vektra/mockery/v3/template\"\n\t\"github.com/xeipuuv/gojsonschema\"\n\t\"golang.org/x/tools/go/packages\"\n\t\"golang.org/x/tools/imports\"\n)\n\ntype Formatter string\n\nconst (\n\tFormatGofmt Formatter = \"gofmt\"\n\tFormatGoImports Formatter = \"goimports\"\n\tFormatNoop Formatter = \"noop\"\n)\n\nvar (\n\t//go:embed mock_matryer.templ\n\ttemplateMatryer string\n\t//go:embed mock_matryer.templ.schema.json\n\ttemplateMatryerJSONSchema string\n\t//go:embed mock_testify.templ\n\ttemplateTestify string\n\t//go:embed mock_testify.templ.schema.json\n\ttemplateTestifyJSONSchema string\n)\n\nvar errBadHTTPStatus = errors.New(\"failed to download file\")\n\nvar styleTemplates = map[string]string{\n\t\"matryer\": templateMatryer,\n\t\"testify\": templateTestify,\n}\n\nvar jsonSchemas = map[string]string{\n\t\"matryer\": templateMatryerJSONSchema,\n\t\"testify\": templateTestifyJSONSchema,\n}\n\n// findPkgPath returns the fully-qualified go import path of a given dir. The\n// dir must be relative to a go.mod file. In the case it isn't, an error is returned.\nfunc findPkgPath(dirPath string) (string, error) {\n\tdirPath, err := file.CleanPath(dirPath)\n\tif err != nil {\n\t\treturn \"\", stackerr.NewStackErr(err)\n\t}\n\tgoModFile, content, err := file.FindInHierarchy(dirPath, []string{\"go.mod\"})\n\tif err != nil {\n\t\treturn \"\", stackerr.NewStackErr(err)\n\t}\n\tdirRelative, err := filepath.Rel(filepath.FromSlash(filepath.Dir(goModFile)), filepath.FromSlash(dirPath))\n\tif err != nil {\n\t\treturn \"\", stackerr.NewStackErr(err)\n\t}\n\tscanner := bufio.NewScanner(bytes.NewReader(content))\n\t// Iterate over each line\n\tfor scanner.Scan() {\n\t\tif !strings.HasPrefix(scanner.Text(), \"module\") {\n\t\t\tcontinue\n\t\t}\n\t\tmoduleName := strings.Split(scanner.Text(), \"module \")[1]\n\t\treturn filepath.ToSlash(filepath.Clean(filepath.Join(moduleName, dirRelative))), nil\n\t}\n\treturn \"\", stackerr.NewStackErr(ErrGoModInvalid)\n}\n\ntype TemplateGenerator struct {\n\tformatter Formatter\n\tinPackage bool\n\trequireSchemaExists bool\n\tregistry *template.Registry\n\ttemplateName string\n\ttemplateSchema string\n\tpkgConfig *config.Config\n\tpkgName string\n\tremoteTemplateCache map[string]*RemoteTemplate\n}\n\nfunc NewTemplateGenerator(\n\tctx context.Context,\n\tsrcPkg *packages.Package,\n\toutPkgFSPath string,\n\ttemplateName string,\n\ttemplateSchema string,\n\trequireSchemaExists bool,\n\tremoteTemplateCache map[string]*RemoteTemplate,\n\tformatter Formatter,\n\tpkgConfig *config.Config,\n\tpkgName string,\n\tforceInPackage *bool,\n) (*TemplateGenerator, error) {\n\tlog := *zerolog.Ctx(ctx)\n\tvar err error\n\n\tsrcPkgFSPath := filepath.Dir(srcPkg.GoFiles[0])\n\tif !filepath.IsAbs(outPkgFSPath) {\n\t\toutPkgFSPath, err = filepath.Abs(outPkgFSPath)\n\t\tif err != nil {\n\t\t\tlog.Err(err).Msg(\"failed to make absolute path\")\n\t\t\treturn nil, stackerr.NewStackErr(err)\n\t\t}\n\t}\n\tif !filepath.IsAbs(srcPkgFSPath) {\n\t\tsrcPkgFSPath, err = filepath.Abs(srcPkgFSPath)\n\t\tif err != nil {\n\t\t\tlog.Err(err).Msg(\"failed to make absolute path\")\n\t\t\treturn nil, stackerr.NewStackErr(err)\n\t\t}\n\t}\n\tsrcPkgFSPath = filepath.ToSlash(filepath.Clean(srcPkgFSPath))\n\toutPkgFSPath = filepath.ToSlash(filepath.Clean(outPkgFSPath))\n\n\tnewLogger := zerolog.Ctx(ctx).With().\n\t\tStr(\"srcPkgFSPath\", srcPkgFSPath).\n\t\tStr(\"outPkgFSPath\", outPkgFSPath).\n\t\tStr(\"src-pkg-name\", srcPkg.Name).\n\t\tStr(\"out-pkg-name\", pkgName).\n\t\tLogger()\n\tlog = newLogger\n\n\toutPkgPath, err := findPkgPath(outPkgFSPath)\n\tif err != nil {\n\t\tlog.Err(err).Msg(\"failed to find output package path\")\n\t\treturn nil, err\n\t}\n\tlog = log.With().Str(\"outPkgPath\", outPkgPath).Logger()\n\n\tvar inPackage bool\n\tif forceInPackage != nil {\n\t\tlog.Debug().Bool(\"inpackage\", *forceInPackage).Msg(\"inpackage value provided, forcing to value\")\n\t\tinPackage = *forceInPackage\n\t} else {\n\t\t// Note: Technically, go allows test files to have a different package name\n\t\t// than non-test files. In this case, the test files have to import the source\n\t\t// package just as if it were in a different directory.\n\t\tif pkgName == srcPkg.Name && srcPkgFSPath == outPkgFSPath {\n\t\t\tlog.Debug().Msg(\"output package detected to be in-package of original package\")\n\t\t\tinPackage = true\n\t\t} else {\n\t\t\tlog.Debug().Msg(\"output package detected to not be in-package of original package\")\n\t\t}\n\t}\n\n\treg, err := template.NewRegistry(srcPkg, outPkgPath, inPackage)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"creating new registry: %w\", err)\n\t}\n\n\treturn &TemplateGenerator{\n\t\ttemplateName: templateName,\n\t\ttemplateSchema: templateSchema,\n\t\trequireSchemaExists: requireSchemaExists,\n\t\tregistry: reg,\n\t\tformatter: formatter,\n\t\tinPackage: inPackage,\n\t\tpkgConfig: pkgConfig,\n\t\tpkgName: pkgName,\n\t\tremoteTemplateCache: remoteTemplateCache,\n\t}, nil\n}\n\nfunc (g *TemplateGenerator) format(src []byte) ([]byte, error) {\n\tswitch g.formatter {\n\tcase FormatGoImports:\n\t\treturn goimports(src, g.pkgConfig.FormatterOptions.GoImports)\n\tcase FormatGofmt:\n\t\treturn gofmt(src)\n\tcase FormatNoop:\n\t\treturn src, nil\n\t}\n\n\treturn nil, fmt.Errorf(\"unknown formatter type: %s\", g.formatter)\n}\n\nfunc getTypePath(t types.Type) (paramPkgPath string, paramObjName string) {\n\tswitch t := t.(type) {\n\tcase *types.Named:\n\t\tpkg := t.Obj().Pkg()\n\t\tif pkg != nil {\n\t\t\tparamPkgPath = pkg.Path()\n\t\t}\n\t\tparamObjName = t.Obj().Name()\n\tcase *types.Alias:\n\t\tpkg := t.Obj().Pkg()\n\t\tif pkg != nil {\n\t\t\tparamPkgPath = pkg.Path()\n\t\t}\n\t\tparamObjName = t.Obj().Name()\n\tcase *types.Pointer:\n\t\tparamPkgPath, paramObjName = getTypePath(t.Elem())\n\t}\n\treturn paramPkgPath, paramObjName\n}\n\nfunc (g *TemplateGenerator) methodData(ctx context.Context, method *types.Func, ifaceConfig *config.Config) (template.Method, error) {\n\tlog := zerolog.Ctx(ctx)\n\n\tmethodScope := g.registry.MethodScope()\n\n\tsignature := method.Type().(*types.Signature)\n\tparams := make([]template.Param, signature.Params().Len())\n\n\tfor j := 0; j < signature.Params().Len(); j++ {\n\t\tparam := signature.Params().At(j)\n\t\tlog.Debug().Str(\"param-string\", param.String()).Msg(\"found parameter\")\n\t\tfor _, imprt := range g.registry.Imports() {\n\t\t\tlog.Debug().Str(\"import\", imprt.Path()).Str(\"import-qualifier\", imprt.Qualifier()).Msg(\"existing imports\")\n\t\t}\n\n\t\tparamPkgPath, paramObjName := getTypePath(param.Type())\n\n\t\treplacement := ifaceConfig.GetReplacement(paramPkgPath, paramObjName)\n\t\tif replacement != nil {\n\t\t\tlog.Debug().Str(\"replace-to-pkg-path\", replacement.PkgPath).Str(\"replace-to-type-name\", replacement.TypeName).Msg(\"found replacement\")\n\t\t} else {\n\t\t\tlog.Debug().Str(\"param-pkg-path\", paramPkgPath).Msg(\"replacement not found\")\n\t\t}\n\t\tv, err := methodScope.AddVar(ctx, param, \"\", replacement)\n\t\tif err != nil {\n\t\t\treturn template.Method{}, err\n\t\t}\n\t\tparams[j] = template.Param{\n\t\t\tVar: v,\n\t\t\tVariadic: signature.Variadic() && j == signature.Params().Len()-1,\n\t\t}\n\t}\n\n\treturns := make([]template.Param, signature.Results().Len())\n\tfor j := 0; j < signature.Results().Len(); j++ {\n\t\tparam := signature.Results().At(j)\n\n\t\tparamLog := log.With().Str(\"param-string\", param.String()).Logger()\n\t\tparamCtx := paramLog.WithContext(ctx)\n\t\tparamLog.Debug().Msg(\"found return\")\n\n\t\tparamPkgPath, paramObjName := getTypePath(param.Type())\n\n\t\treplacement := ifaceConfig.GetReplacement(paramPkgPath, paramObjName)\n\t\tif replacement != nil {\n\t\t\tlog.Debug().Str(\"replace-to-pkg-path\", replacement.PkgPath).Str(\"replace-to-type-name\", replacement.TypeName).Msg(\"found replacement\")\n\t\t} else {\n\t\t\tlog.Debug().Str(\"param-pkg-path\", paramPkgPath).Msg(\"replacement not found\")\n\t\t}\n\t\tv, err := methodScope.AddVar(paramCtx, param, \"\", replacement)\n\t\tif err != nil {\n\t\t\treturn template.Method{}, err\n\t\t}\n\t\treturns[j] = template.Param{\n\t\t\tVar: v,\n\t\t\tVariadic: false,\n\t\t}\n\t}\n\treturn template.Method{\n\t\tName: method.Name(),\n\t\tParams: params,\n\t\tReturns: returns,\n\t\tScope: methodScope,\n\t}, nil\n}\n\nfunc explicitConstraintType(typeParam *types.Var) (t types.Type) {\n\tunderlying := typeParam.Type().Underlying().(*types.Interface)\n\t// check if any of the embedded types is either a basic type or a union,\n\t// because the generic type has to be an alias for one of those types then\n\tfor j := 0; j < underlying.NumEmbeddeds(); j++ {\n\t\tt := underlying.EmbeddedType(j)\n\t\tswitch t := t.(type) {\n\t\tcase *types.Basic:\n\t\t\treturn t\n\t\tcase *types.Union: // only unions of basic types are allowed, so just take the first one as a valid type constraint\n\t\t\treturn t.Term(0).Type()\n\t\t}\n\t}\n\treturn nil\n}\n\nfunc (g *TemplateGenerator) typeParams(ctx context.Context, tparams *types.TypeParamList) ([]template.TypeParam, error) {\n\tvar tpd []template.TypeParam\n\tif tparams == nil {\n\t\treturn tpd, nil\n\t}\n\n\ttpd = make([]template.TypeParam, tparams.Len())\n\n\tscope := g.registry.MethodScope()\n\tfor i := 0; i < len(tpd); i++ {\n\t\ttp := tparams.At(i)\n\t\ttypeParam := types.NewParam(token.Pos(i), tp.Obj().Pkg(), tp.Obj().Name(), tp.Constraint())\n\t\tv, err := scope.AddVar(ctx, typeParam, \"\", nil)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\ttpd[i] = template.TypeParam{\n\t\t\tParam: template.Param{Var: v},\n\t\t\tConstraint: explicitConstraintType(typeParam),\n\t\t}\n\t}\n\n\treturn tpd, nil\n}\n\n// getTemplate returns the requested template and associated schema (if available).\nfunc (g *TemplateGenerator) getTemplate(ctx context.Context) (string, *gojsonschema.Schema, error) {\n\tlog := zerolog.Ctx(ctx).With().Str(\"template\", g.templateName).Str(\"schema\", g.templateSchema).Logger()\n\tctx = log.WithContext(ctx)\n\n\tfor _, protocol := range []string{\"file://\", \"https://\", \"http://\"} {\n\t\tvar schema *gojsonschema.Schema\n\t\tvar err error\n\n\t\tif !strings.HasPrefix(g.templateName, protocol) {\n\t\t\tcontinue\n\t\t}\n\t\tvar remoteTemplate *RemoteTemplate\n\t\tif cachedRemoteTemplate, ok := g.remoteTemplateCache[g.templateName]; !ok {\n\t\t\tremoteTemplate = NewRemoteTemplate(g.templateName, g.templateSchema)\n\t\t\tg.remoteTemplateCache[g.templateName] = remoteTemplate\n\t\t} else {\n\t\t\tremoteTemplate = cachedRemoteTemplate\n\t\t}\n\n\t\ttemplateString, err := remoteTemplate.Template(ctx)\n\t\tif err != nil {\n\t\t\tlog.Error().Msg(\"could not download template\")\n\t\t\treturn \"\", nil, fmt.Errorf(\"downloading template: %w\", err)\n\t\t}\n\t\tif g.requireSchemaExists {\n\t\t\tschema, err = remoteTemplate.Schema(ctx)\n\t\t\tif err != nil {\n\t\t\t\tlog.Error().Msg(\"could not get JSON schema\")\n\t\t\t\treturn \"\", nil, fmt.Errorf(\"downloading schema: %w\", err)\n\t\t\t}\n\t\t}\n\n\t\treturn templateString, schema, nil\n\t}\n\n\t// Embedded templates\n\tvar styleExists bool\n\ttemplateString, styleExists := styleTemplates[g.templateName]\n\tif !styleExists {\n\t\treturn \"\", nil, fmt.Errorf(\"template '%s' does not exist\", g.templateName)\n\t}\n\tschema, err := gojsonschema.NewSchema(gojsonschema.NewStringLoader(jsonSchemas[g.templateName]))\n\tif err != nil {\n\t\treturn \"\", nil, fmt.Errorf(\"generating schema: %w\", err)\n\t}\n\treturn templateString, schema, nil\n}\n\nfunc validateSchema(ctx context.Context, data template.Data, schema *gojsonschema.Schema) error {\n\tif schema == nil {\n\t\treturn errors.New(\"jschema argument can't be nil\")\n\t}\n\tif err := data.TemplateData.VerifyJSONSchema(ctx, schema); err != nil {\n\t\treturn fmt.Errorf(\"validating template-data\")\n\t}\n\tfor _, intf := range data.Interfaces {\n\t\tif err := intf.TemplateData.VerifyJSONSchema(ctx, schema); err != nil {\n\t\t\treturn fmt.Errorf(\"verifying template-data for %s: %w\", intf.Name, err)\n\t\t}\n\t}\n\treturn nil\n}\n\nfunc (g *TemplateGenerator) Generate(\n\tctx context.Context,\n\tinterfaces []*Interface,\n) ([]byte, error) {\n\tlog := zerolog.Ctx(ctx)\n\tlog.UpdateContext(func(c zerolog.Context) zerolog.Context {\n\t\treturn c.Str(\"template\", g.templateName).Str(\"schema\", g.templateSchema)\n\t})\n\n\tmockData := []template.Interface{}\n\tfor _, ifaceMock := range interfaces {\n\t\tifaceLog := log.With().\n\t\t\tStr(\"interface-name\", ifaceMock.Name).\n\t\t\tStr(\"package-path\", ifaceMock.Pkg.PkgPath).\n\t\t\tStr(\"mock-name\", *ifaceMock.Config.StructName).\n\t\t\tLogger()\n\t\tctx := ifaceLog.WithContext(ctx)\n\n\t\tifaceLog.Debug().Msg(\"looking up interface in registry\")\n\t\tiface, tparams, err := g.registry.LookupInterface(ifaceMock.Name)\n\t\tif err != nil {\n\t\t\tlog.Err(err).Msg(\"error looking up interface\")\n\t\t\treturn []byte{}, err\n\t\t}\n\t\tifaceLog.Debug().Msg(\"found interface\")\n\n\t\tmethods := make([]template.Method, iface.NumMethods())\n\t\tfor i := 0; i < iface.NumMethods(); i++ {\n\t\t\tmethodData, err := g.methodData(ctx, iface.Method(i), ifaceMock.Config)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t\tmethods[i] = methodData\n\t\t}\n\t\t// Now that all methods have been generated, we need to resolve naming\n\t\t// conflicts that arise between variable names and package qualifiers.\n\t\tfor _, method := range methods {\n\t\t\tmethod.Scope.ResolveVariableNameCollisions(\n\t\t\t\tzerolog.\n\t\t\t\t\tCtx(ctx).\n\t\t\t\t\tWith().\n\t\t\t\t\tStr(\"method-name\", method.Name).\n\t\t\t\t\tLogger().\n\t\t\t\t\tWithContext(ctx))\n\t\t}\n\n\t\tifaceLog.Debug().Str(\"template-data\", fmt.Sprintf(\"%v\", ifaceMock.Config.TemplateData)).Msg(\"printing template data\")\n\t\ttParams, err := g.typeParams(ctx, tparams)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tmockData = append(mockData, template.NewInterface(\n\t\t\tifaceMock.Name,\n\t\t\t*ifaceMock.Config.StructName,\n\t\t\ttParams,\n\t\t\tmethods,\n\t\t\tifaceMock.Config.TemplateData,\n\t\t\ttemplate.NewComments(ifaceMock.TypeSpec, ifaceMock.GenDecl),\n\t\t))\n\t}\n\n\tdata := template.NewData(\n\t\tg.pkgName, \"\", template.Packages{}, mockData, g.pkgConfig.TemplateData, g.registry,\n\t)\n\tif !g.inPackage {\n\t\tdata.SrcPkgQualifier = g.registry.SrcPkgName() + \".\"\n\t}\n\n\ttemplateString, schema, err := g.getTemplate(ctx)\n\tif err != nil {\n\t\tlog.Error().Msg(\"could not get template\")\n\t\treturn nil, fmt.Errorf(\"getting template: %w\", err)\n\t}\n\tif schema != nil {\n\t\tif err := validateSchema(ctx, data, schema); err != nil {\n\t\t\tlog.Error().Msg(\"failed to validate schema\")\n\t\t\treturn nil, fmt.Errorf(\"validating schema: %w\", err)\n\t\t}\n\t}\n\n\ttempl, err := template.New(templateString, g.templateName)\n\tif err != nil {\n\t\treturn []byte{}, fmt.Errorf(\"creating new template: %w\", err)\n\t}\n\n\tvar buf bytes.Buffer\n\tlog.Debug().Msg(\"executing template\")\n\tif err := templ.Execute(&buf, data); err != nil {\n\t\tlog.Error().Msg(\"failed to execute template\")\n\t\treturn []byte{}, fmt.Errorf(\"executing template: %w\", err)\n\t}\n\n\tlog.Debug().Msg(\"formatting file in-memory\")\n\tformatted, err := g.format(buf.Bytes())\n\tif err != nil {\n\t\tscanner := bufio.NewScanner(strings.NewReader(buf.String()))\n\t\tfor i := 1; scanner.Scan(); i++ {\n\t\t\tfmt.Printf(\"%d:\\t%s\\n\", i, scanner.Text())\n\t\t}\n\t\tlog.Err(err).Msg(\"can't format mock file in-memory\")\n\t\treturn []byte{}, fmt.Errorf(\"formatting mock file: %w\", err)\n\t}\n\treturn formatted, nil\n}\n\nfunc goimports(src []byte, opts *config.GoImports) ([]byte, error) {\n\tvar localPrefix string\n\tvar importsOpts *imports.Options\n\tif opts != nil {\n\t\tlocalPrefix = opts.GetLocalPrefix()\n\t\timportsOpts = opts.Options()\n\n\t}\n\n\timports.LocalPrefix = localPrefix\n\tformatted, err := imports.Process(\"/\", src, importsOpts)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"goimports: %s\", err)\n\t}\n\n\treturn formatted, nil\n}\n\nfunc gofmt(src []byte) ([]byte, error) {\n\tformatted, err := format.Source(src)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"go/format: %s\", err)\n\t}\n\n\treturn formatted, nil\n}\n" }, { "path": "internal/template_generator_test.go", "content": "package internal\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestFindPkgPath(t *testing.T) {\n\tpkgPath, err := findPkgPath(\"./fixtures\")\n\trequire.NoError(t, err)\n\tassert.NotEqual(t, \"\", pkgPath)\n}\n" }, { "path": "main.go", "content": "package main\n\nimport (\n\t\"github.com/vektra/mockery/v3/internal/cmd\"\n)\n\nfunc main() {\n\tcmd.Execute()\n}\n" }, { "path": "mkdocs.yml", "content": "site_name: mockery\nsite_url: https://vektra.github.io/mockery/\nsite_description: >-\n Create mock implementations of your Golang interfaces using mockery and testify.\n\nrepo_name: vektra/mockery\nrepo_url: https://github.com/vektra/mockery\nedit_uri: edit/v3/docs\n\ntheme:\n name: material\n icon:\n logo: fontawesome/brands/golang\n palette:\n # Palette toggle for light mode\n - media: \"(prefers-color-scheme: light)\"\n scheme: default\n primary: green\n toggle:\n icon: material/brightness-7\n name: Switch to dark mode\n # Palette toggle for dark mode\n - media: \"(prefers-color-scheme: dark)\"\n scheme: slate\n primary: green\n toggle:\n icon: material/brightness-4\n name: Switch to light mode\n features:\n - content.action.edit\n - content.action.view\n - content.code.annotate\n - content.code.copy\n - content.footnote.tooltips\n - navigation.indexes\n - navigation.path\n - navigation.sections\n - navigation.tracking\n - toc.follow\nmarkdown_extensions:\n - admonition\n - attr_list\n - footnotes\n - md_in_html\n - pymdownx.emoji:\n emoji_index: !!python/name:material.extensions.emoji.twemoji\n emoji_generator: !!python/name:material.extensions.emoji.to_svg\n - pymdownx.details\n - pymdownx.highlight:\n anchor_linenums: true\n auto_title: true\n - pymdownx.inlinehilite\n - pymdownx.magiclink\n - pymdownx.snippets\n - pymdownx.superfences\n - pymdownx.tabbed:\n alternate_style: true\n - toc:\n permalink: true\n\nnav:\n - Home: index.md\n - Getting Started:\n - Installation: installation.md\n - Configuration: configuration.md\n - Templates:\n - template/index.md\n - template/testify.md\n - template/matryer.md\n - Features:\n - include-auto-generated.md\n - inpackage.md\n - replace-type.md\n - generate-directive.md\n - Notes:\n - faq.md\n - v3.md\n - dev-notes.md\n\nextra_css:\n - stylesheets/extra.css\n\nextra_javascript:\n - https://unpkg.com/tablesort@5.3.0/dist/tablesort.min.js\n - javascripts/tablesort.js\n\nextra:\n version:\n provider: mike\n analytics:\n provider: google\n property: G-0ZGMQGZGRN\n\nplugins:\n- glightbox\n- mike:\n alias_type: symlink\n canonical_version: null\n- open-in-new-tab\n- search\n- social\n- typeset:\n enabled: true\n" }, { "path": "mockery-tools.env", "content": "VERSION=v3.7.0\n" }, { "path": "mocks_testify_main_test.go", "content": "// TEST MOCKERY BOILERPLATE\n\n// Code generated by mockery; DO NOT EDIT.\n// github.com/vektra/mockery\n// template: testify\n\npackage main\n\nimport (\n\tmock \"github.com/stretchr/testify/mock\"\n)\n\n// newMockfoo creates a new instance of mockfoo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.\n// The first argument is typically a *testing.T value.\nfunc newMockfoo(t interface {\n\tmock.TestingT\n\tCleanup(func())\n}) *mockfoo {\n\tmock := &mockfoo{}\n\tmock.Mock.Test(t)\n\n\tt.Cleanup(func() { mock.AssertExpectations(t) })\n\n\treturn mock\n}\n\n// mockfoo is an autogenerated mock type for the foo type\ntype mockfoo struct {\n\tmock.Mock\n}\n\ntype mockfoo_Expecter struct {\n\tmock *mock.Mock\n}\n\nfunc (_m *mockfoo) EXPECT() *mockfoo_Expecter {\n\treturn &mockfoo_Expecter{mock: &_m.Mock}\n}\n\n// Bar provides a mock function for the type mockfoo\nfunc (_mock *mockfoo) Bar() baz {\n\tret := _mock.Called()\n\n\tif len(ret) == 0 {\n\t\tpanic(\"no return value specified for Bar\")\n\t}\n\n\tvar r0 baz\n\tif returnFunc, ok := ret.Get(0).(func() baz); ok {\n\t\tr0 = returnFunc()\n\t} else {\n\t\tr0 = ret.Get(0).(baz)\n\t}\n\treturn r0\n}\n\n// mockfoo_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'\ntype mockfoo_Bar_Call struct {\n\t*mock.Call\n}\n\n// Bar is a helper method to define mock.On call\nfunc (_e *mockfoo_Expecter) Bar() *mockfoo_Bar_Call {\n\treturn &mockfoo_Bar_Call{Call: _e.mock.On(\"Bar\")}\n}\n\nfunc (_c *mockfoo_Bar_Call) Run(run func()) *mockfoo_Bar_Call {\n\t_c.Call.Run(func(args mock.Arguments) {\n\t\trun()\n\t})\n\treturn _c\n}\n\nfunc (_c *mockfoo_Bar_Call) Return(bazMoqParam baz) *mockfoo_Bar_Call {\n\t_c.Call.Return(bazMoqParam)\n\treturn _c\n}\n\nfunc (_c *mockfoo_Bar_Call) RunAndReturn(run func() baz) *mockfoo_Bar_Call {\n\t_c.Call.Return(run)\n\treturn _c\n}\n" }, { "path": "template/README.md", "content": "Template\n--------\n\nThis package contains all of the data passed to mockery templates. The top-most variable provided\nto the templates is [Data](https://pkg.go.dev/github.com/vektra/mockery/v3/template#Data). Attributes\nof this struct can be accessed using syntax like:\n\n```\npackage {{.PkgName}}\n\nimport (\n{{- range .Imports}}\n\t{{. | importStatement}}\n{{- end}}\n mock \"github.com/stretchr/testify/mock\"\n)\n```\n\nFurther examples of how to use the data provided to mockery templates can be found in the pre-curated mocks, such as:\n\n- [matryer](https://github.com/vektra/mockery/blob/v3/internal/mock_matryer.templ)\n- [testify](https://github.com/vektra/mockery/blob/v3/internal/mock_testify.templ)\n\n\nFull documentation is provided at: https://vektra.github.io/mockery/v3/" }, { "path": "template/comment_group.go", "content": "package template\n\nimport \"go/ast\"\n\n// Comment represents a single line of comments exactly as it appears in source.\n// This includes the \"//\" or \"/*\" strings if present.\ntype Comment string\n\ntype CommentGroup struct {\n\t// List contains each individual line of the comments exactly as they appear\n\t// in source, including comment characters.\n\tList []Comment\n\t// Text contains the text of the comments without comment characters.\n\tText string\n}\n\nfunc NewCommentGroupFromAST(comments *ast.CommentGroup) CommentGroup {\n\tgroup := CommentGroup{\n\t\tList: []Comment{},\n\t\tText: \"\",\n\t}\n\tif comments == nil {\n\t\treturn group\n\t}\n\tgroup.Text = comments.Text()\n\tfor _, line := range comments.List {\n\t\tgroup.List = append(group.List, Comment(line.Text))\n\t}\n\treturn group\n}\n" }, { "path": "template/comments.go", "content": "package template\n\nimport \"go/ast\"\n\ntype Comments struct {\n\t/*\n\t\tGenDeclDoc represents the doc comments for a general declaration.\n\t\tFor example, if you were to define an interface with the following comments:\n\n\t\t// Foo defines Bar\n\t\ttype Foo interface {\n\t\t\tBar() string\n\t\t}\n\n\t\tthen GenDeclDoc will contain the \"// Foo defines Bar\" comment.\n\t\tSimilarly, if you define your interface like:\n\n\t\t// hello world\n\t\ttype (\n\t\t\t// Foo defines Bar\n\t\t\tFoo interface {\n\t\t\t\tBar() string\n\t\t\t}\n\t\t)\n\n\t\tthen GenDeclDoc will contain the \"// hello world\" comment.\n\t*/\n\tGenDeclDoc CommentGroup\n\t/*\n\t\tTypeSpecComment contains in-line comments for a type spec.\n\t\tFor example:\n\n\t\ttype Foo interface {\n\t\t\tBar() string\n\t\t} // This is a line comment\n\t*/\n\tTypeSpecComment CommentGroup\n\n\t/*\n\t\tTypeSpecDoc contains the docs for a type spec.\n\t\tFor example:\n\n\t\ttype (\n\t\t\t// Foo defines Bar\n\t\t\tFoo interface {\n\t\t\t\tBar() string\n\t\t\t}\n\t\t)\n\n\t\tTypeSpecDoc will _not_ contain the comments defined like this:\n\n\t\t// Foo defines Bar\n\t\ttype Foo interface {\n\t\t\tBar() string\n\t\t}\n\n\t\tThe reason is because the Go AST defines this as a comment on an *ast.GenDecl, not an *ast.TypeSpec.\n\t*/\n\tTypeSpecDoc CommentGroup\n}\n\nfunc NewComments(typeSpec *ast.TypeSpec, genDecl *ast.GenDecl) Comments {\n\treturn Comments{\n\t\tGenDeclDoc: NewCommentGroupFromAST(genDecl.Doc),\n\t\tTypeSpecComment: NewCommentGroupFromAST(typeSpec.Comment),\n\t\tTypeSpecDoc: NewCommentGroupFromAST(typeSpec.Doc),\n\t}\n}\n" }, { "path": "template/data.go", "content": "package template\n\n// Data is the template data used to render the mock template.\ntype Data struct {\n\t// PkgName is the name of the package chosen for the template.\n\tPkgName string\n\t// Registry chiefly maintains the list of imports that are required in the\n\t// rendered template file.\n\tRegistry *Registry\n\t// SrcPkgQualifier is the qualifier used for the source package, if any.\n\t// For example, if the source package is different from the package the template\n\t// is rendered into, this string will contain something like \"foo.\", where\n\t// \"foo\" is the alias or package name of the source package.\n\tSrcPkgQualifier string\n\t// Interfaces is the list of interfaces being rendered in the template.\n\tInterfaces Interfaces\n\t// TemplateData is a schemaless map containing parameters from configuration\n\t// you may consume in your template.\n\tTemplateData TemplateData\n}\n\nfunc (d Data) Imports() Packages {\n\treturn d.Registry.Imports()\n}\n\nfunc NewData(\n\tpkgName string,\n\tsrcPkgQualifier string,\n\timports Packages,\n\tinterfaces Interfaces,\n\ttemplateData TemplateData,\n\tregistry *Registry,\n) Data {\n\treturn Data{\n\t\tInterfaces: interfaces,\n\t\tPkgName: pkgName,\n\t\tRegistry: registry,\n\t\tTemplateData: templateData,\n\t\tSrcPkgQualifier: srcPkgQualifier,\n\t}\n}\n" }, { "path": "template/interface.go", "content": "package template\n\n// Interface is the data used to generate a mock for some interface.\ntype Interface struct {\n\tComments Comments\n\tMethods []Method\n\t// Name is the name of the original interface.\n\tName string\n\t// StructName is the chosen name for the struct that will implement the interface.\n\tStructName string\n\tTemplateData TemplateData\n\tTypeParams []TypeParam\n}\n\nfunc NewInterface(\n\tname string,\n\tstructName string,\n\ttypeParams []TypeParam,\n\tmethods []Method,\n\ttemplateData TemplateData,\n\tcomments Comments,\n) Interface {\n\treturn Interface{\n\t\tName: name,\n\t\tStructName: structName,\n\t\tTypeParams: typeParams,\n\t\tMethods: methods,\n\t\tTemplateData: templateData,\n\t\tComments: comments,\n\t}\n}\n\nfunc (m Interface) TypeConstraintTest() string {\n\tif len(m.TypeParams) == 0 {\n\t\treturn \"\"\n\t}\n\ts := \"[\"\n\tfor idx, param := range m.TypeParams {\n\t\tif idx != 0 {\n\t\t\ts += \", \"\n\t\t}\n\t\ts += param.Name()\n\t\ts += \" \"\n\t\ts += param.TypeString()\n\t}\n\ts += \"]\"\n\treturn s\n}\n\nfunc (m Interface) TypeConstraint() string {\n\tif len(m.TypeParams) == 0 {\n\t\treturn \"\"\n\t}\n\ts := \"[\"\n\tfor idx, param := range m.TypeParams {\n\t\tif idx != 0 {\n\t\t\ts += \", \"\n\t\t}\n\t\ts += param.Name()\n\t\ts += \" \"\n\t\ts += param.TypeString()\n\t}\n\ts += \"]\"\n\treturn s\n}\n\nfunc (m Interface) TypeInstantiation() string {\n\tif len(m.TypeParams) == 0 {\n\t\treturn \"\"\n\t}\n\ts := \"[\"\n\tfor idx, param := range m.TypeParams {\n\t\tif idx != 0 {\n\t\t\ts += \", \"\n\t\t}\n\t\ts += param.Name()\n\t}\n\ts += \"]\"\n\treturn s\n}\n" }, { "path": "template/interfaces.go", "content": "package template\n\ntype Interfaces []Interface\n\n// ImplementsSomeMethod returns true if any one of the Mocks has at least 1 method.\nfunc (m Interfaces) ImplementsSomeMethod() bool {\n\tfor _, mock := range m {\n\t\tif len(mock.Methods) > 0 {\n\t\t\treturn true\n\t\t}\n\t}\n\n\treturn false\n}\n" }, { "path": "template/method.go", "content": "package template\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n)\n\n// Method is the data which represents a method on some interface.\ntype Method struct {\n\t// Name is the method's name.\n\tName string\n\n\t// Params represents all the arguments to the method.\n\tParams []Param\n\n\t// Returns represents all the return parameters of the method.\n\tReturns []Param\n\n\t// Scope represents the lexical scope of the method. Its primary function\n\t// is keeping track of all names visible in the current scope, which allows\n\t// the creation of new variables with guaranteed non-conflicting names.\n\tScope *MethodScope\n}\n\n// ReturnStatement returns the string \"return\" if a method has return values.\n// Otherwise, it returns an empty string.\nfunc (m Method) ReturnStatement() string {\n\tif len(m.Returns) > 0 {\n\t\treturn \"return\"\n\t}\n\treturn \"\"\n}\n\n// Call returns a string containing the method call. This will usually need to be\n// prefixed with a selector to specify which actual method to call. For example,\n// if the method has a signature of \"func Foo(s string) error\", this method will\n// return the string \"Foo(s)\". The name of each argument variable will be the same\n// as what was generated post collision-resolution. Meaning, the argument variable\n// name might be slightly altered from the original function if a naming collision\n// was found.\nfunc (m Method) Call() string {\n\treturn fmt.Sprintf(\"%s(%s)\", m.Name, m.ArgCallList())\n}\n\n// AcceptsContext returns whether or not the first argument of the method is a context.Context.\nfunc (m Method) AcceptsContext() bool {\n\tif len(m.Params) > 0 && m.Params[0].TypeString() == \"context.Context\" {\n\t\treturn true\n\t}\n\treturn false\n}\n\nfunc (m Method) signature(includeNames bool) string {\n\treturn fmt.Sprintf(\"(%s) (%s)\", m.argList(includeNames), m.returnArgList(includeNames))\n}\n\n// Signature returns the string representation of the method's signature. For example,\n// if a method was declared as \"func (b Bar) Foo(s string) error\", this method will\n// return \"(s string) error\"\nfunc (m Method) Signature() string {\n\treturn m.signature(true)\n}\n\n// SignatureNoName is the same as Signature except the argument and return parameter\n// names are not included.\nfunc (m Method) SignatureNoName() string {\n\treturn m.signature(false)\n}\n\n// Declaration returns the method name followed by its signature. For\n// example, if a method was declared as \"func (b Bar) Foo(s string) error\", this method\n// will return \"Foo(s string) error\"\nfunc (m Method) Declaration() string {\n\treturn m.Name + m.Signature()\n}\n\nfunc (m Method) ReturnsError() bool {\n\t// Yes I know that by convention the last return value is the error,\n\t// but to be technically correct, we have to check all return values.\n\tfor _, ret := range m.Returns {\n\t\tif ret.Var.TypeString() == \"error\" {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\nfunc (m Method) HasParams() bool {\n\treturn len(m.Params) > 0\n}\n\nfunc (m Method) HasReturns() bool {\n\treturn len(m.Returns) > 0\n}\n\nfunc (m Method) argList(includeName bool) string {\n\tparams := make([]string, len(m.Params))\n\tfor i, p := range m.Params {\n\t\tif includeName {\n\t\t\tparams[i] = p.MethodArg()\n\t\t} else {\n\t\t\tparams[i] = p.MethodArgNoName()\n\t\t}\n\t}\n\treturn strings.Join(params, \", \")\n}\n\n// ArgList is the string representation of method parameters, ex:\n// 's string, n int, foo bar.Baz'.\nfunc (m Method) ArgList() string {\n\treturn m.argList(true)\n}\n\n// ArgListNoName is the same as ArgList except the argument names are not included.\nfunc (m Method) ArgListNoName() string {\n\treturn m.argList(false)\n}\n\n// ArgTypeList returns the argument types in a comma-separated string, ex:\n// `string, int, bar.Baz`\nfunc (m Method) ArgTypeList() string {\n\tparams := make([]string, len(m.Params))\n\tfor i, p := range m.Params {\n\t\tparams[i] = p.TypeString()\n\t}\n\treturn strings.Join(params, \", \")\n}\n\n// ArgTypeListEllipsis returns the argument types in a comma-separated string, ex:\n// `string, int, bar.Baz`. If the last argument is variadic, it will contain an\n// ellipsis as would be expected in a variadic function definition.\nfunc (m Method) ArgTypeListEllipsis() string {\n\tparams := make([]string, len(m.Params))\n\tfor i, p := range m.Params {\n\t\tparams[i] = p.TypeStringEllipsis()\n\t}\n\treturn strings.Join(params, \", \")\n}\n\n// ArgCallList is the string representation of method call parameters,\n// ex: 's, n, foo'. In case of a last variadic parameter, it will be of\n// the format 's, n, foos...'.\nfunc (m Method) ArgCallList() string {\n\treturn m.argCallListSlice(0, -1, true)\n}\n\n// ArgCallListNoEllipsis is the same as ArgCallList, except the last parameter, if\n// variadic, will not contain an ellipsis.\nfunc (m Method) ArgCallListNoEllipsis() string {\n\treturn m.argCallListSlice(0, -1, false)\n}\n\n// argCallListSlice is similar to ArgCallList, but it allows specification of\n// a slice range to use for the parameter lists. Specifying an integer less than\n// 1 for end indicates to slice to the end of the parameters. As with regular\n// Go slicing semantics, the end value is a non-inclusive index.\nfunc (m Method) ArgCallListSlice(start, end int) string {\n\treturn m.argCallListSlice(start, end, true)\n}\n\nfunc (m Method) ArgCallListSliceNoEllipsis(start, end int) string {\n\treturn m.argCallListSlice(start, end, false)\n}\n\nfunc (m Method) argCallListSlice(start, end int, ellipsis bool) string {\n\tif end < 0 {\n\t\tend = len(m.Params)\n\t}\n\tif end == 1 && len(m.Params) == 0 {\n\t\tend = 0\n\t}\n\tparamsSlice := m.Params[start:end]\n\tparams := make([]string, len(paramsSlice))\n\tfor i, p := range paramsSlice {\n\t\tparams[i] = p.CallName(ellipsis)\n\t}\n\treturn strings.Join(params, \", \")\n}\n\n// ReturnArgTypeList is the string representation of method return\n// types, ex: 'bar.Baz', '(string, error)'.\nfunc (m Method) ReturnArgTypeList() string {\n\tparams := make([]string, len(m.Returns))\n\tfor i, p := range m.Returns {\n\t\tparams[i] = p.TypeString()\n\t}\n\tif len(m.Returns) > 1 {\n\t\treturn fmt.Sprintf(\"(%s)\", strings.Join(params, \", \"))\n\t}\n\treturn strings.Join(params, \", \")\n}\n\n// ReturnArgNameList is the string representation of values being\n// returned from the method, ex: 'foo', 's, err'.\nfunc (m Method) ReturnArgNameList() string {\n\tparams := make([]string, len(m.Returns))\n\tfor i, p := range m.Returns {\n\t\tparams[i] = p.Name()\n\t}\n\treturn strings.Join(params, \", \")\n}\n\nfunc (m Method) returnArgList(includeNames bool) string {\n\tparams := make([]string, len(m.Returns))\n\tfor i, p := range m.Returns {\n\t\tif includeNames {\n\t\t\tparams[i] = p.Name() + \" \"\n\t\t}\n\t\tparams[i] += p.TypeString()\n\t}\n\treturn strings.Join(params, \", \")\n}\n\n// ReturnArgList returns the name and types of the return values. For example:\n// \"foo int, bar string, err error\"\nfunc (m Method) ReturnArgList() string {\n\treturn m.returnArgList(true)\n}\n\n// ReturnArgListNoName is the same as ReturnArgList except the return argument\n// names are not included.\nfunc (m Method) ReturnArgListNoName() string {\n\treturn m.returnArgList(false)\n}\n\nfunc (m Method) IsVariadic() bool {\n\treturn len(m.Params) > 0 && m.Params[len(m.Params)-1].Variadic\n}\n" }, { "path": "template/method_scope.go", "content": "package template\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"go/types\"\n\n\t\"github.com/rs/zerolog\"\n\t\"github.com/vektra/mockery/v3/config\"\n\t\"github.com/vektra/mockery/v3/internal/stackerr\"\n\t\"golang.org/x/tools/go/packages\"\n)\n\n// MethodScope is the sub-registry for allocating variables present in\n// the method scope.\n//\n// It should be created using a registry instance.\ntype MethodScope struct {\n\t// registry is a pointer to the file-global registry that contains a list\n\t// of all imports.\n\tregistry *Registry\n\tpkgPath string\n\n\tvars []*Var\n\tconflicted map[string]bool\n\t// visibleNames contains a collection of all names visible to this lexical\n\t// scope. This includes import qualifiers, type names etc. This is used to prevent naming\n\t// collisions.\n\tvisibleNames map[string]any\n}\n\nfunc NewMethodScope(r *Registry) *MethodScope {\n\tm := &MethodScope{\n\t\tregistry: r,\n\t\tvars: []*Var{},\n\t\tconflicted: map[string]bool{},\n\t\tvisibleNames: map[string]any{},\n\t}\n\tfor key := range r.importQualifiers {\n\t\tm.AddName(key)\n\t}\n\treturn m\n}\n\n// ResolveVariableNameCollisions modifies argument names if they are found to\n// collide with any other names visible to the scope.\n//\n// This method is not meant to be used directly by templates.\nfunc (m *MethodScope) ResolveVariableNameCollisions(ctx context.Context) {\n\tlog := zerolog.Ctx(ctx)\n\tfor _, v := range m.vars {\n\t\tvarLog := log.With().Str(\"variable-name\", v.Name).Logger()\n\t\tnewName := m.SuggestName(v.Name)\n\t\tif newName != v.Name {\n\t\t\tvarLog.Debug().Str(\"new-name\", newName).Msg(\"variable was found to conflict with previously allocated name. Giving new name.\")\n\t\t}\n\t\tv.Name = newName\n\t\tm.AddName(v.Name)\n\t}\n}\n\n// SuggestName creates a new variable name in the lexical scope of the method.\n// It ensures the returned name does not conflict with any other name visible\n// to the scope. This method does _not_ register the returned name suggestion\n// in the scope, which must separately be done by `MethodScope.AddName`.\nfunc (m *MethodScope) SuggestName(prefix string) string {\n\tvar suggestion string\n\tfor i := 0; ; i++ {\n\t\tif i == 0 {\n\t\t\tsuggestion = prefix\n\t\t} else {\n\t\t\tsuggestion = fmt.Sprintf(\"%s%d\", prefix, i)\n\t\t}\n\n\t\tif !m.NameExists(suggestion) {\n\t\t\tbreak\n\t\t}\n\t}\n\treturn suggestion\n}\n\n// AllocateName creates a new variable name in the lexical scope of the method.\n// The name is guaranteed to not collide with any other existing names at the time\n// of the call. It automatically allocates the name to the current scope. Returned\n// is the name post collision resolution.\nfunc (m *MethodScope) AllocateName(prefix string) string {\n\tsuggestion := m.SuggestName(prefix)\n\tm.AddName(suggestion)\n\treturn suggestion\n}\n\n// fakePackage is used during type replacements (the replace-type parameter).\n// We don't want to call `packages.Load` in order to obtain a real `*packages.Package`\n// object, so we instead can create a mock implementation and provide the necessary\n// values (obtained from `replace-type`).\ntype fakePackage struct {\n\tname string\n\tpath string\n}\n\nfunc (f fakePackage) Name() string {\n\treturn f.name\n}\n\nfunc (f fakePackage) Path() string {\n\treturn f.path\n}\n\nvar _ TypesPackage = fakePackage{}\n\n// AddVar allocates a variable instance and adds it to the method scope.\n//\n// Variables names are generated if required and are ensured to be\n// without conflict with other variables and imported packages. It also\n// adds the relevant imports to the registry for each added variable.\n//\n// This method is not meant to be used directly by templates.\nfunc (m *MethodScope) AddVar(ctx context.Context, vr *types.Var, prefix string, replacement *config.ReplaceType) (*Var, error) {\n\tvar (\n\t\timports map[string]*Package = map[string]*Package{}\n\t\tv Var\n\t)\n\n\tlog := zerolog.Ctx(ctx)\n\n\tif replacement != nil {\n\t\tnewLogger := log.With().\n\t\t\tStr(\"replace-pkg-path\", replacement.PkgPath).\n\t\t\tStr(\"replace-type-name\", replacement.TypeName).Logger()\n\t\tlog = &newLogger\n\t\tctx = log.WithContext(ctx)\n\t\tlog.Debug().Msg(\"working with replacement\")\n\n\t\t// Type replacements are really tricky. Mockery needs to correctly\n\t\t// gather type information from the package specified in the replacement.\n\t\t// This basically means that we need to call packages.Load to satisfy this requirement,\n\t\t// then find the type name in the replacement.\n\t\t//\n\t\t// NOTE: This section WILL be slow, because `packages.Load` is slow. Future\n\t\t// enhancement will be to find a way to either cache these calls, batch\n\t\t// them together for all replace-type instances, or find a way to avoid\n\t\t// this altogether.\n\t\tvar conf packages.Config\n\t\tconf.Mode = packages.NeedTypes |\n\t\t\tpackages.NeedTypesSizes |\n\t\t\tpackages.NeedSyntax |\n\t\t\tpackages.NeedTypesInfo |\n\t\t\tpackages.NeedImports |\n\t\t\tpackages.NeedName |\n\t\t\tpackages.NeedFiles |\n\t\t\tpackages.NeedCompiledGoFiles\n\t\tpkgs, err := packages.Load(&conf, replacement.PkgPath)\n\t\tif err != nil {\n\t\t\tlog.Err(err).Msg(\"couldn't load package\")\n\t\t\treturn nil, stackerr.NewStackErr(err)\n\t\t}\n\t\tvar object types.Object\n\t\tvar objectPkg *packages.Package\n\t\tfor _, pkg := range pkgs {\n\t\t\tobject = pkg.Types.Scope().Lookup(replacement.TypeName)\n\t\t\tif object != nil {\n\t\t\t\tobjectPkg = pkg\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\tif object == nil {\n\t\t\tlog.Error().Msg(\"type-name was not found in the referenced package\")\n\t\t\treturn nil, stackerr.NewStackErr(fmt.Errorf(\"type does not exist in referenced package\"))\n\t\t}\n\n\t\tm.addImport(\n\t\t\tctx,\n\t\t\tobjectPkg.Types,\n\t\t\timports,\n\t\t)\n\n\t\t// Check to see if the original type is a pointer. If so, the replacement type\n\t\t// should also be a pointer. At some point we may want to provide configuration\n\t\t// overrides for this behavior, but this auto-detection should be good enough\n\t\t// for now.\n\t\tobjectType := object.Type()\n\t\tswitch vr.Type().(type) {\n\t\tcase *types.Pointer:\n\t\t\tobjectType = types.NewPointer(objectType)\n\t\t}\n\n\t\tv = Var{\n\t\t\tvr: vr,\n\t\t\ttyp: objectType,\n\t\t\timports: imports,\n\t\t\tpkgPath: m.pkgPath,\n\t\t}\n\t} else {\n\t\timports = m.populateImports(ctx, vr.Type())\n\t\tv = Var{\n\t\t\tvr: vr,\n\t\t\ttyp: vr.Type(),\n\t\t\timports: imports,\n\t\t\tpkgPath: m.pkgPath,\n\t\t}\n\t\tm.AddName(v.TypeString())\n\t}\n\tv.Name = m.SuggestName(varName(vr, prefix))\n\tm.vars = append(m.vars, &v)\n\treturn &v, nil\n}\n\n// AddName records name as visible in the current scope. This method does not check\n// for naming collisions, and consequently will not modify the given name in any\n// way. It's recommended that you first check MethodScope.NameExists to determine\n// if the name has any collisions, or use MethodScope.AllocateName.\nfunc (m *MethodScope) AddName(name string) {\n\tm.visibleNames[name] = nil\n}\n\n// NameExists returns whether or not the name is currently visible in the scope.\nfunc (m *MethodScope) NameExists(name string) bool {\n\t_, exists := m.visibleNames[name]\n\treturn exists\n}\n\nfunc (m *MethodScope) addImport(ctx context.Context, pkg TypesPackage, imports map[string]*Package) {\n\timprt := m.registry.addImport(ctx, pkg)\n\timports[pkg.Path()] = imprt\n\tm.AddName(imprt.Qualifier())\n}\n\nfunc (m *MethodScope) populateImportNamedType(\n\tctx context.Context,\n\tt interface {\n\t\tObj() *types.TypeName\n\t\tTypeArgs() *types.TypeList\n\t},\n\timports map[string]*Package,\n) {\n\tlog := zerolog.Ctx(ctx)\n\tif pkg := t.Obj().Pkg(); pkg != nil {\n\t\tlog.Debug().Str(\"method\", \"populateImportNamedType\").Str(\"pkg-path\", pkg.Path()).Msg(\"adding import from var\")\n\t\tm.addImport(ctx, pkg, imports)\n\t}\n\t// The imports of a Type with a TypeList must be added to the imports list\n\t// For example: Foo[otherpackage.Bar] , must have otherpackage imported\n\tif targs := t.TypeArgs(); targs != nil {\n\t\tfor i := 0; i < targs.Len(); i++ {\n\t\t\tm.populateImportsHelper(ctx, targs.At(i), imports)\n\t\t}\n\t}\n}\n\nfunc (m *MethodScope) populateImports(ctx context.Context, t types.Type) map[string]*Package {\n\timports := map[string]*Package{}\n\tm.populateImportsHelper(ctx, t, imports)\n\treturn imports\n}\n\n// populateImportsHelper extracts all the package imports for a given type\n// recursively. The imported packages by a single type can be more than\n// one (ex: map[a.Type]b.Type).\n//\n// Returned are the imports that were added for the given type.\nfunc (m *MethodScope) populateImportsHelper(ctx context.Context, t types.Type, imports map[string]*Package) {\n\tlog := zerolog.Ctx(ctx).With().\n\t\tStr(\"type-str\", t.String()).Logger()\n\tswitch t := t.(type) {\n\tcase *types.Named:\n\t\tm.populateImportNamedType(ctx, t, imports)\n\tcase *types.Alias:\n\t\tm.populateImportNamedType(ctx, t, imports)\n\tcase *types.Array:\n\t\tm.populateImportsHelper(ctx, t.Elem(), imports)\n\n\tcase *types.Slice:\n\t\tm.populateImportsHelper(ctx, t.Elem(), imports)\n\n\tcase *types.Signature:\n\t\tfor i := 0; i < t.Params().Len(); i++ {\n\t\t\tm.populateImportsHelper(ctx, t.Params().At(i).Type(), imports)\n\t\t}\n\t\tfor i := 0; i < t.Results().Len(); i++ {\n\t\t\tm.populateImportsHelper(ctx, t.Results().At(i).Type(), imports)\n\t\t}\n\n\tcase *types.Map:\n\t\tm.populateImportsHelper(ctx, t.Key(), imports)\n\t\tm.populateImportsHelper(ctx, t.Elem(), imports)\n\n\tcase *types.Chan:\n\t\tm.populateImportsHelper(ctx, t.Elem(), imports)\n\n\tcase *types.Pointer:\n\t\tm.populateImportsHelper(ctx, t.Elem(), imports)\n\n\tcase *types.Struct: // anonymous struct\n\t\tfor i := 0; i < t.NumFields(); i++ {\n\t\t\tm.populateImportsHelper(ctx, t.Field(i).Type(), imports)\n\t\t}\n\n\tcase *types.Union:\n\t\tlog.Debug().Int(\"len\", t.Len()).Msg(\"found union\")\n\t\tfor i := 0; i < t.Len(); i++ {\n\t\t\tterm := t.Term(i)\n\t\t\tm.populateImportsHelper(ctx, term.Type(), imports)\n\t\t}\n\tcase *types.Interface: // anonymous interface\n\t\tlog.Debug().\n\t\t\tInt(\"num-methods\", t.NumMethods()).\n\t\t\tInt(\"num-explicit-methods\", t.NumExplicitMethods()).\n\t\t\tInt(\"num-embeddeds\", t.NumEmbeddeds()).\n\t\t\tMsg(\"found interface\")\n\t\tfor i := 0; i < t.NumExplicitMethods(); i++ {\n\t\t\tlog.Debug().Msg(\"populating import from explicit method\")\n\t\t\tm.populateImportsHelper(ctx, t.ExplicitMethod(i).Type(), imports)\n\t\t}\n\t\tfor i := 0; i < t.NumEmbeddeds(); i++ {\n\t\t\tlog.Debug().Msg(\"populating import form embedded type\")\n\t\t\tm.populateImportsHelper(ctx, t.EmbeddedType(i), imports)\n\t\t}\n\tcase *types.Basic:\n\t\tif t.Kind() == types.UnsafePointer {\n\t\t\tm.addImport(ctx, types.Unsafe, imports)\n\t\t}\n\tdefault:\n\t\tlog.Debug().Str(\"real-type\", fmt.Sprintf(\"%T\", t)).Msg(\"unable to determine type of object\")\n\t}\n}\n" }, { "path": "template/package.go", "content": "package template\n\ntype TypesPackage interface {\n\tName() string\n\tPath() string\n}\n\n// Package represents an imported package.\ntype Package struct {\n\tpkg TypesPackage\n\n\tAlias string\n}\n\n// NewPackage creates a new instance of Package.\nfunc NewPackage(pkg TypesPackage) *Package {\n\treturn &Package{pkg: pkg}\n}\n\nfunc (p *Package) ImportStatement() string {\n\tif p.Alias == \"\" {\n\t\treturn `\"` + p.Path() + `\"`\n\t}\n\treturn p.Alias + ` \"` + p.Path() + `\"`\n}\n\n// Qualifier returns the qualifier which must be used to refer to types\n// declared in the package.\nfunc (p *Package) Qualifier() string {\n\tif p == nil {\n\t\treturn \"\"\n\t}\n\n\tif p.Alias != \"\" {\n\t\treturn p.Alias\n\t}\n\n\treturn p.pkg.Name()\n}\n\n// Path is the full package import path (without vendor).\nfunc (p *Package) Path() string {\n\tif p == nil {\n\t\treturn \"\"\n\t}\n\n\treturn p.pkg.Path()\n}\n" }, { "path": "template/packages.go", "content": "package template\n\nimport \"fmt\"\n\ntype Packages []*Package\n\n// PkgQualifier returns the qualifier for the given pkgPath. If the pkgPath does\n// not exist in the container, an error is returned.\nfunc (p Packages) PkgQualifier(pkgPath string) (string, error) {\n\tfor _, imprt := range p {\n\t\tif imprt.Path() == pkgPath {\n\t\t\treturn imprt.Qualifier(), nil\n\t\t}\n\t}\n\n\treturn \"\", fmt.Errorf(\"unknown import %s\", pkgPath)\n}\n" }, { "path": "template/param.go", "content": "package template\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n)\n\n// Param is the data which represents a parameter to some method of\n// an interface.\ntype Param struct {\n\tVar *Var\n\tVariadic bool\n}\n\n// Name returns the name of the parameter.\nfunc (p Param) Name() string {\n\treturn p.Var.Name\n}\n\nfunc (p Param) methodArg(includeNames bool) string {\n\tvar arg string\n\tif includeNames {\n\t\targ += p.Name() + \" \"\n\t}\n\tif p.Variadic {\n\t\targ += fmt.Sprintf(\"...%s\", p.TypeString()[2:])\n\t} else {\n\t\targ += p.TypeString()\n\t}\n\treturn arg\n}\n\n// MethodArg is the representation of the parameter in the function\n// signature, ex: 'name a.Type'.\nfunc (p Param) MethodArg() string {\n\treturn p.methodArg(true)\n}\n\n// MethodArgNoName is the same as MethodArg except the argument name is not included.\nfunc (p Param) MethodArgNoName() string {\n\treturn p.methodArg(false)\n}\n\n// CallName returns the string representation of the parameter to be\n// used for a method call. For a variadic paramter, it will be of the\n// format 'foos...' if ellipsis is true.\nfunc (p Param) CallName(ellipsis bool) string {\n\tif ellipsis && p.Variadic {\n\t\treturn p.Name() + \"...\"\n\t}\n\treturn p.Name()\n}\n\n// TypeString returns the string representation of the type of the\n// parameter.\nfunc (p Param) TypeString() string {\n\treturn p.Var.TypeString()\n}\n\n// TypeStringEllipsis returns the string representation of the type of the\n// parameter. If it is a variadic parameter, it will be represented as a\n// variadic parameter instead of a slice. For example instead of `[]string`,\n// it will return `...string`.\nfunc (p Param) TypeStringEllipsis() string {\n\ttypeString := p.TypeString()\n\tif !p.Variadic {\n\t\treturn typeString\n\t}\n\treturn strings.Replace(typeString, \"[]\", \"...\", 1)\n}\n\n// TypeStringVariadicUnderlying returns the underlying type of a variadic parameter. For\n// instance, if a function has a parameter defined as `foo ...int`, this function\n// will return \"int\". If the parameter is not variadic, this will behave the same\n// as `TypeString`.\nfunc (p Param) TypeStringVariadicUnderlying() string {\n\ttypeString := p.TypeStringEllipsis()\n\treturn strings.Replace(typeString, \"...\", \"\", 1)\n}\n" }, { "path": "template/registry.go", "content": "package template\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"go/types\"\n\t\"sort\"\n\n\t\"github.com/rs/zerolog\"\n\t\"github.com/vektra/mockery/v3/internal/stackerr\"\n\t\"golang.org/x/tools/go/packages\"\n)\n\n// Registry encapsulates types information for the source and mock\n// destination package. For the mock package, it tracks the list of\n// imports and ensures there are no conflicts in the imported package\n// qualifiers.\ntype Registry struct {\n\tdstPkgPath string\n\tsrcPkg *packages.Package\n\tsrcPkgName string\n\timports map[string]*Package\n\timportQualifiers map[string]*Package\n\t// inPackage specifies whether this registry is considered to be in the same\n\t// package as the srcPkg. This is needed because of the way that Go package\n\t// qualifiers work. For example, test files for a package are allowed to have\n\t// a different package name than the files under test, in which case they are\n\t// considered to be in a separate package. In such a case, `inPackage` should\n\t// be set to false such that calls to AddImport for the original source package\n\t// are not ignored. Otherwise if it's set to true, AddImport ignores imports\n\t// for the package in which the file already resides.\n\tinPackage bool\n}\n\n// New loads the source package info and returns a new instance of\n// Registry.\nfunc NewRegistry(srcPkg *packages.Package, dstPkgPath string, inPackage bool) (*Registry, error) {\n\treturn &Registry{\n\t\tdstPkgPath: dstPkgPath,\n\t\tsrcPkg: srcPkg,\n\t\timports: make(map[string]*Package),\n\t\timportQualifiers: make(map[string]*Package),\n\t\tinPackage: inPackage,\n\t}, nil\n}\n\nfunc (r Registry) SrcPkg() *packages.Package {\n\treturn r.srcPkg\n}\n\n// SrcPkgName returns the name of the source package.\nfunc (r Registry) SrcPkgName() string {\n\treturn r.srcPkg.Name\n}\n\n// LookupInterface returns the underlying interface definition of the\n// given interface name.\nfunc (r Registry) LookupInterface(name string) (*types.Interface, *types.TypeParamList, error) {\n\tobj := r.SrcPkg().Types.Scope().Lookup(name)\n\tif obj == nil {\n\t\treturn nil, nil, stackerr.NewStackErr(fmt.Errorf(\"interface not found: %s\", name))\n\t}\n\n\tif !types.IsInterface(obj.Type()) {\n\t\treturn nil, nil, fmt.Errorf(\"%s (%s) is not an interface\", name, obj.Type())\n\t}\n\n\tvar tparams *types.TypeParamList\n\tnamed, ok := obj.Type().(*types.Named)\n\tif ok {\n\t\ttparams = named.TypeParams()\n\t}\n\n\treturn obj.Type().Underlying().(*types.Interface).Complete(), tparams, nil\n}\n\n// MethodScope returns a new MethodScope.\nfunc (r *Registry) MethodScope() *MethodScope {\n\treturn NewMethodScope(r)\n}\n\ntype fakeTypesPackage struct {\n\tname string\n\tpath string\n}\n\nfunc (f fakeTypesPackage) Name() string {\n\treturn f.name\n}\n\nfunc (f fakeTypesPackage) Path() string {\n\treturn f.path\n}\n\n// addImport adds the given package to the set of imports. It generates a\n// suitable alias if there are any conflicts with previously imported\n// packages. pkgName must be set to the unaliased package name.\nfunc (r *Registry) AddImport(pkgName string, pkgPath string) *Package {\n\t// Note: Yes this method is a little weird. This is intended to be used\n\t// by templates that want to add their own imports. Instead of requiring the\n\t// templates to pass in a ctx and TypesPackage instance, we create this new\n\t// AddImport method that wraps around r.addImport. r.addImport still exists\n\t// because mockery will add its own imports based on the existing types, and\n\t// in that case we want it to pass ctx (that contains the logger) and the\n\t// real types.Package type.\n\treturn r.addImport(context.Background(), fakeTypesPackage{\n\t\tname: pkgName,\n\t\tpath: pkgPath,\n\t})\n}\n\nfunc (r *Registry) addImport(ctx context.Context, pkg TypesPackage) *Package {\n\tpath := pkg.Path()\n\tlogContext := zerolog.Ctx(ctx).With().\n\t\tStr(\"method\", \"AddImport\").\n\t\tStr(\"dst-pkg-path\", r.dstPkgPath).\n\t\tStr(\"pkg-path\", path).\n\t\tBool(\"inpackage\", r.inPackage)\n\tif r.srcPkg != nil {\n\t\tlogContext = logContext.Str(\"src-pkg-path\", r.srcPkg.PkgPath)\n\t}\n\tlog := logContext.Logger()\n\n\tif r.srcPkg != nil && path == r.srcPkg.PkgPath && r.inPackage {\n\t\tlog.Debug().Msg(\"package path equals src-pkg-path, not adding import\")\n\t\treturn nil\n\t} else {\n\t\tlog.Debug().Msg(\"package path does not equal src-pkg-path, adding import\")\n\t}\n\n\tif imprt, ok := r.imports[path]; ok {\n\t\treturn imprt\n\t}\n\n\timprt := Package{pkg: pkg}\n\toriginalQualifier := imprt.Qualifier()\n\tvar aliasSuggestion string = imprt.Qualifier()\n\tfor i := 0; ; i++ {\n\t\tif _, conflict := r.importQualifiers[aliasSuggestion]; conflict {\n\t\t\taliasSuggestion = fmt.Sprintf(\"%s%d\", imprt.Qualifier(), i)\n\t\t\tcontinue\n\t\t}\n\t\tif originalQualifier != aliasSuggestion {\n\t\t\timprt.Alias = aliasSuggestion\n\t\t}\n\t\tbreak\n\t}\n\n\tr.imports[path] = &imprt\n\tr.importQualifiers[imprt.Qualifier()] = &imprt\n\treturn &imprt\n}\n\n// Imports returns the list of imported packages. The list is sorted by\n// path.\nfunc (r Registry) Imports() Packages {\n\timports := make([]*Package, 0, len(r.imports))\n\tfor _, imprt := range r.imports {\n\t\timports = append(imports, imprt)\n\t}\n\tsort.Slice(imports, func(i, j int) bool {\n\t\treturn imports[i].Path() < imports[j].Path()\n\t})\n\treturn imports\n}\n" }, { "path": "template/template.go", "content": "// Package template provides data and functionality for rendering templates using mockery.\n// The data and methods herein are guaranteed to be backwards compatible, as they\n// are used directly by user-defined Go templates. It is safe to import or use\n// this package for any purpose.\npackage template\n\nimport (\n\t\"io\"\n\t\"text/template\"\n\n\t\"github.com/vektra/mockery/v3/template_funcs\"\n)\n\n// Template represents the template requested for rendering.\ntype Template struct {\n\ttmpl *template.Template\n}\n\n// New returns a new instance of Template.\nfunc New(templateString string, name string) (Template, error) {\n\ttmpl, err := template.New(name).Funcs(template_funcs.FuncMap).Parse(templateString)\n\tif err != nil {\n\t\treturn Template{}, err\n\t}\n\n\treturn Template{tmpl: tmpl}, nil\n}\n\n// Execute generates and writes the Moq implementation for the given\n// data.\nfunc (t Template) Execute(w io.Writer, data Data) error {\n\treturn t.tmpl.Execute(w, data)\n}\n" }, { "path": "template/template_data.go", "content": "package template\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\n\t\"github.com/rs/zerolog\"\n\t\"github.com/xeipuuv/gojsonschema\"\n)\n\nvar ErrTemplateDataSchemaValidation = errors.New(\"unable to verify template-data schema\")\n\ntype TemplateData map[string]any\n\n// VerifyJSONSchema verifies that the contents of the type adhere to the schema\n// defined by the schema argument.\n//\n// This method is not meant to be used directly by templates.\nfunc (t TemplateData) VerifyJSONSchema(ctx context.Context, schema *gojsonschema.Schema) error {\n\tlog := zerolog.Ctx(ctx)\n\n\tresult, err := schema.Validate(gojsonschema.NewGoLoader(t))\n\tif err != nil {\n\t\treturn fmt.Errorf(\"validating json schema: %w\", err)\n\t}\n\tif !result.Valid() {\n\t\tlog.Error().Msg(\"issue with template-data json schema, see messages below:\")\n\t\tfor _, resultErr := range result.Errors() {\n\t\t\tlog.Error().Msg(resultErr.String())\n\t\t}\n\t\treturn ErrTemplateDataSchemaValidation\n\t}\n\tlog.Debug().Msg(\"validated json schema successfully\")\n\treturn nil\n}\n" }, { "path": "template/template_test.go", "content": "package template\n\nimport (\n\t\"context\"\n\t\"go/types\"\n\t\"os\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\nfunc TestTemplateMockFuncs(t *testing.T) {\n\ttests := []struct {\n\t\tname string\n\t\tinTemplate string\n\t\tdataInit func() Data\n\t\twant string\n\t}{\n\t\t{\n\t\t\tname: \"importStatement\",\n\t\t\tinTemplate: \"{{- range .Imports}}{{ .ImportStatement }}{{- end}}\",\n\t\t\tdataInit: func() Data {\n\t\t\t\timprt := NewPackage(types.NewPackage(\"xyz\", \"xyz\"))\n\t\t\t\timprt.Alias = \"x\"\n\t\t\t\tregistry, err := NewRegistry(nil, \"\", false)\n\t\t\t\trequire.NoError(t, err)\n\t\t\t\tregistry.addImport(context.Background(), imprt.pkg)\n\n\t\t\t\treturn Data{Registry: registry}\n\t\t\t},\n\t\t\twant: `\"xyz\"`,\n\t\t},\n\t\t{\n\t\t\tname: \"PkgQualifier\",\n\t\t\tinTemplate: `{{$.Imports.PkgQualifier \"sync\"}}`,\n\t\t\tdataInit: func() Data {\n\t\t\t\tregistry, err := NewRegistry(nil, \"\", false)\n\t\t\t\trequire.NoError(t, err)\n\t\t\t\tregistry.addImport(context.Background(), NewPackage(types.NewPackage(\"sync\", \"sync\")).pkg)\n\t\t\t\tregistry.addImport(context.Background(), NewPackage(types.NewPackage(\"github.com/some/module\", \"module\")).pkg)\n\n\t\t\t\treturn Data{Registry: registry}\n\t\t\t},\n\t\t\twant: \"sync\",\n\t\t},\n\t\t{\n\t\t\tname: \"PkgQualifier conflicting pkg names\",\n\t\t\tinTemplate: `{{$.Imports.PkgQualifier \"github.com/someother/sync\"}}`,\n\t\t\tdataInit: func() Data {\n\t\t\t\tregistry, err := NewRegistry(nil, \"\", false)\n\t\t\t\trequire.NoError(t, err)\n\t\t\t\tregistry.AddImport(\"sync\", \"sync\")\n\t\t\t\tregistry.AddImport(\"sync\", \"github.com/someother/sync\")\n\n\t\t\t\treturn Data{Registry: registry}\n\t\t\t},\n\t\t\twant: \"sync0\",\n\t\t},\n\t\t{\n\t\t\tname: \"exported empty\",\n\t\t\tinTemplate: \"{{exported .TemplateData.var}}\",\n\t\t\tdataInit: func() Data { return Data{TemplateData: map[string]any{\"var\": \"\"}} },\n\t\t\twant: \"\",\n\t\t},\n\t\t{\n\t\t\tname: \"exported var\",\n\t\t\tinTemplate: \"{{exported .TemplateData.var}}\",\n\t\t\tdataInit: func() Data { return Data{TemplateData: map[string]any{\"var\": \"someVar\"}} },\n\t\t\twant: \"SomeVar\",\n\t\t},\n\t\t{\n\t\t\tname: \"exported acronym\",\n\t\t\tinTemplate: \"{{exported .TemplateData.var}}\",\n\t\t\tdataInit: func() Data { return Data{TemplateData: map[string]any{\"var\": \"sql\"}} },\n\t\t\twant: \"SQL\",\n\t\t},\n\t\t{\n\t\t\tname: \"ImplementsSomeMethod\",\n\t\t\tinTemplate: \"{{ .Interfaces.ImplementsSomeMethod }}\",\n\t\t\tdataInit: func() Data {\n\t\t\t\t// MethodData has to have at least 1 element to pass.\n\t\t\t\treturn Data{Interfaces: []Interface{{Methods: []Method{{}}}}}\n\t\t\t},\n\t\t\twant: \"true\",\n\t\t},\n\t\t{\n\t\t\tname: \"typeConstraint\",\n\t\t\tinTemplate: \"{{ (index .Interfaces 0).TypeConstraintTest }}\",\n\t\t\tdataInit: func() Data {\n\t\t\t\treturn Data{Interfaces: []Interface{{\n\t\t\t\t\tTypeParams: []TypeParam{{\n\t\t\t\t\t\tParam: Param{\n\t\t\t\t\t\t\tVar: &Var{Name: \"t\", typ: &types.Slice{}},\n\t\t\t\t\t\t},\n\t\t\t\t\t}},\n\t\t\t\t}}}\n\t\t\t},\n\t\t\twant: \"[t []]\",\n\t\t},\n\t\t{\n\t\t\tname: \"readFile\",\n\t\t\tinTemplate: \"{{readFile .TemplateData.f}}\",\n\t\t\tdataInit: func() Data {\n\t\t\t\tf, err := os.CreateTemp(\".\", \"readFileTest\")\n\t\t\t\trequire.NoError(t, err)\n\t\t\t\tdefer f.Close()\n\n\t\t\t\tt.Cleanup(func() {\n\t\t\t\t\tos.Remove(f.Name())\n\t\t\t\t})\n\n\t\t\t\t_, err = f.WriteString(\"content\")\n\t\t\t\trequire.NoError(t, err)\n\n\t\t\t\treturn Data{TemplateData: map[string]any{\"f\": f.Name()}}\n\t\t\t},\n\t\t\twant: \"content\",\n\t\t},\n\t}\n\n\tfor _, tc := range tests {\n\t\tt.Run(tc.name, func(t *testing.T) {\n\t\t\tt.Parallel()\n\n\t\t\ttt, err := New(tc.inTemplate, tc.name)\n\t\t\trequire.NoError(t, err)\n\n\t\t\tvar sb strings.Builder\n\t\t\terr = tt.Execute(&sb, tc.dataInit())\n\t\t\trequire.NoError(t, err)\n\t\t\tassert.Equal(t, tc.want, sb.String())\n\t\t})\n\t}\n}\n" }, { "path": "template/type_param_data.go", "content": "package template\n\nimport \"go/types\"\n\ntype TypeParam struct {\n\tParam\n\tConstraint types.Type\n}\n" }, { "path": "template/var.go", "content": "package template\n\nimport (\n\t\"go/types\"\n\t\"strings\"\n)\n\n// Var represents a method variable/parameter.\n//\n// It should be created using a method scope instance.\ntype Var struct {\n\tvr *types.Var\n\t// typ is stored separately from `vr.Type()` because it's possible\n\t// for a variable to be replaced with another variable via replace-type.\n\t// In such a case, `vr.Type()` refers to the original type and `typ` refers\n\t// to the replacer type.\n\ttyp types.Type\n\timports map[string]*Package\n\tpkgPath string\n\n\tName string\n}\n\nfunc (v Var) Type() types.Type {\n\treturn v.typ\n}\n\n// IsSlice returns whether the type (or the underlying type) is a slice.\nfunc (v Var) IsSlice() bool {\n\t_, ok := v.Type().Underlying().(*types.Slice)\n\treturn ok\n}\n\n// TypeString returns the variable type with the package qualifier in the\n// format 'pkg.Type'.\nfunc (v Var) TypeString() string {\n\treturn types.TypeString(v.Type(), v.packageQualifier)\n}\n\n// packageQualifier is a types.Qualifier.\nfunc (v Var) packageQualifier(pkg *types.Package) string {\n\tpath := pkg.Path()\n\tif v.pkgPath != \"\" && v.pkgPath == path {\n\t\treturn \"\"\n\t}\n\treturn v.imports[path].Qualifier()\n}\n\nfunc nillable(typ types.Type) bool {\n\tswitch t := typ.(type) {\n\tcase *types.Pointer, *types.Array, *types.Map, *types.Interface, *types.Signature, *types.Chan, *types.Slice:\n\t\treturn true\n\tcase *types.Named, *types.Alias, *types.TypeParam:\n\t\treturn nillable(t.Underlying())\n\t}\n\treturn false\n}\n\nfunc (v Var) Nillable() bool {\n\treturn nillable(v.Type())\n}\n\nfunc varName(vr *types.Var, suffix string) string {\n\tname := vr.Name()\n\tif name != \"\" && name != \"_\" {\n\t\treturn name + suffix\n\t}\n\n\tname = varNameForType(vr.Type()) + suffix\n\n\tswitch name {\n\tcase \"mock\", \"callInfo\", \"break\", \"default\", \"func\", \"interface\", \"select\", \"case\", \"defer\", \"go\", \"map\", \"struct\",\n\t\t\"chan\", \"else\", \"goto\", \"package\", \"switch\", \"const\", \"fallthrough\", \"if\", \"range\", \"type\", \"continue\", \"for\",\n\t\t\"import\", \"return\", \"var\",\n\t\t// avoid shadowing basic types\n\t\t\"string\", \"bool\", \"byte\", \"rune\", \"uintptr\",\n\t\t\"int\", \"int8\", \"int16\", \"int32\", \"int64\",\n\t\t\"uint\", \"uint8\", \"uint16\", \"uint32\", \"uint64\",\n\t\t\"float32\", \"float64\", \"complex64\", \"complex128\":\n\t\tname += \"Param\"\n\t}\n\n\treturn name\n}\n\n// varNameForType generates a name for the variable using the type\n// information.\n//\n// Examples:\n// - string -> s\n// - int -> n\n// - chan int -> intCh\n// - []a.MyType -> myTypes\n// - map[string]int -> stringToInt\n// - error -> err\n// - a.MyType -> myType\nfunc varNameForType(t types.Type) string {\n\tnestedType := func(t types.Type) string {\n\t\tif t, ok := t.(*types.Basic); ok {\n\t\t\treturn deCapitalise(t.String())\n\t\t}\n\t\treturn varNameForType(t)\n\t}\n\n\tswitch t := t.(type) {\n\tcase *types.Named:\n\t\tif t.Obj().Name() == \"error\" {\n\t\t\treturn \"err\"\n\t\t}\n\n\t\tname := deCapitalise(t.Obj().Name())\n\t\tif name == t.Obj().Name() {\n\t\t\tname += \"MoqParam\"\n\t\t}\n\n\t\treturn name\n\n\tcase *types.Basic:\n\t\treturn basicTypeVarName(t)\n\n\tcase *types.Array:\n\t\treturn nestedType(t.Elem()) + \"s\"\n\n\tcase *types.Slice:\n\t\treturn nestedType(t.Elem()) + \"s\"\n\n\tcase *types.Struct: // anonymous struct\n\t\treturn \"val\"\n\n\tcase *types.Pointer:\n\t\treturn varNameForType(t.Elem())\n\n\tcase *types.Signature:\n\t\treturn \"fn\"\n\n\tcase *types.Interface: // anonymous interface\n\t\treturn \"ifaceVal\"\n\n\tcase *types.Map:\n\t\treturn nestedType(t.Key()) + \"To\" + capitalise(nestedType(t.Elem()))\n\n\tcase *types.Chan:\n\t\treturn nestedType(t.Elem()) + \"Ch\"\n\t}\n\n\treturn \"v\"\n}\n\nfunc basicTypeVarName(b *types.Basic) string {\n\tswitch b.Info() {\n\tcase types.IsBoolean:\n\t\treturn \"b\"\n\n\tcase types.IsInteger:\n\t\treturn \"n\"\n\n\tcase types.IsFloat:\n\t\treturn \"f\"\n\n\tcase types.IsString:\n\t\treturn \"s\"\n\t}\n\n\treturn \"v\"\n}\n\nfunc capitalise(s string) string { return strings.ToUpper(s[:1]) + s[1:] }\nfunc deCapitalise(s string) string { return strings.ToLower(s[:1]) + s[1:] }\n" }, { "path": "template_funcs/funcmap.go", "content": "// Package shared provides variables/objects that need to be shared\n// across multiple packages. The main purpose is to resolve cyclical imports\n// arising from multiple packages needing to share common utilies.\npackage template_funcs\n\nimport (\n\t\"math\"\n\t\"math/rand/v2\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"regexp\"\n\t\"strings\"\n\t\"text/template\"\n\n\t\"github.com/huandu/xstrings\"\n)\n\n// This list comes from the golint codebase. Golint will complain about any of\n// these being mixed-case, like \"Id\" instead of \"ID\".\nvar golintInitialisms = []string{\n\t\"ACL\", \"API\", \"ASCII\", \"CPU\", \"CSS\", \"DNS\", \"EOF\", \"GUID\", \"HTML\", \"HTTP\", \"HTTPS\", \"ID\", \"IP\", \"JSON\", \"LHS\",\n\t\"QPS\", \"RAM\", \"RHS\", \"RPC\", \"SLA\", \"SMTP\", \"SQL\", \"SSH\", \"TCP\", \"TLS\", \"TTL\", \"UDP\", \"UI\", \"UID\", \"UUID\", \"URI\",\n\t\"URL\", \"UTF8\", \"VM\", \"XML\", \"XMPP\", \"XSRF\", \"XSS\",\n}\n\n//nolint:predeclared\nvar FuncMap = template.FuncMap{\n\t// String inspection and manipulation. Note that the first argument is replaced\n\t// as the last argument in some functions in order to support chained\n\t// template pipelines.\n\t\"contains\": func(substr string, s string) bool { return strings.Contains(s, substr) },\n\t\"hasPrefix\": func(prefix string, s string) bool { return strings.HasPrefix(s, prefix) },\n\t\"hasSuffix\": func(suffix string, s string) bool { return strings.HasSuffix(s, suffix) },\n\t\"join\": func(sep string, elems []string) string { return strings.Join(elems, sep) },\n\t\"replace\": func(old string, new string, n int, s string) string { return strings.Replace(s, old, new, n) },\n\t\"replaceAll\": func(old string, new string, s string) string { return strings.ReplaceAll(s, old, new) },\n\t\"split\": func(sep string, s string) []string { return strings.Split(s, sep) },\n\t\"splitAfter\": func(sep string, s string) []string { return strings.SplitAfter(s, sep) },\n\t\"splitAfterN\": func(sep string, n int, s string) []string { return strings.SplitAfterN(s, sep, n) },\n\t\"trim\": func(cutset string, s string) string { return strings.Trim(s, cutset) },\n\t\"trimLeft\": func(cutset string, s string) string { return strings.TrimLeft(s, cutset) },\n\t\"trimPrefix\": func(prefix string, s string) string { return strings.TrimPrefix(s, prefix) },\n\t\"trimRight\": func(cutset string, s string) string { return strings.TrimRight(s, cutset) },\n\t\"trimSpace\": strings.TrimSpace,\n\t\"trimSuffix\": func(suffix string, s string) string { return strings.TrimSuffix(s, suffix) },\n\t\"lower\": strings.ToLower,\n\t\"upper\": strings.ToUpper,\n\t\"camelcase\": xstrings.ToCamelCase,\n\t\"snakecase\": xstrings.ToSnakeCase,\n\t\"kebabcase\": xstrings.ToKebabCase,\n\t\"firstIsLower\": FirstIsLower,\n\t\"firstLower\": xstrings.FirstRuneToLower,\n\t\"firstUpper\": xstrings.FirstRuneToUpper,\n\t\"exported\": Exported,\n\n\t// Regular expression matching\n\t\"matchString\": regexp.MatchString,\n\t\"quoteMeta\": regexp.QuoteMeta,\n\n\t// Filepath manipulation\n\t\"base\": func(path string) string { return filepath.ToSlash(filepath.Base(path)) },\n\t\"clean\": func(path string) string { return filepath.ToSlash(filepath.Clean(path)) },\n\t\"dir\": func(path string) string { return filepath.ToSlash(filepath.Dir(path)) },\n\t\"readFile\": ReadFile,\n\n\t// Basic access to reading environment variables\n\t\"expandEnv\": os.ExpandEnv,\n\t\"getenv\": os.Getenv,\n\n\t/*******\n\t* MATH *\n\t********/\n\t// int\n\t\"add\": Add[int],\n\t\"decr\": Decr[int],\n\t\"div\": Div[int],\n\t\"incr\": Incr[int],\n\t\"min\": Min[int],\n\t\"mod\": Mod[int],\n\t\"mul\": Mul[int],\n\t\"sub\": Sub[int],\n\n\t// float64\n\t\"ceil\": math.Ceil,\n\t\"floor\": math.Floor,\n\t\"round\": math.Round,\n\n\t// rand\n\t\"randInt\": rand.Int,\n}\n" }, { "path": "template_funcs/funcmap_test.go", "content": "package template_funcs\n\nimport (\n\t\"os\"\n\t\"regexp\"\n\t\"strings\"\n\t\"testing\"\n\t\"text/template\"\n\n\t\"github.com/stretchr/testify/assert\"\n\t\"github.com/stretchr/testify/require\"\n)\n\ntype Data struct {\n\tTemplateData map[string]any\n}\n\nfunc TestTemplateStringFuncs(t *testing.T) {\n\t// For env tests\n\tos.Setenv(\"MOCKERY_TEST_ENV\", \"TEST\")\n\n\ttests := []struct {\n\t\tname string\n\t\ttemplate string\n\t\tdata map[string]any\n\t\twant string\n\t\twantRegex string\n\t}{\n\t\t{\n\t\t\tname: \"contains\",\n\t\t\ttemplate: \"{{contains .TemplateData.sub .TemplateData.str}}\",\n\t\t\tdata: map[string]any{\"str\": \"golang\", \"sub\": \"go\"},\n\t\t\twant: \"true\",\n\t\t},\n\t\t{\n\t\t\tname: \"hasPrefix\",\n\t\t\ttemplate: \"{{hasPrefix .TemplateData.pre .TemplateData.str}}\",\n\t\t\tdata: map[string]any{\"str\": \"golang\", \"pre\": \"go\"},\n\t\t\twant: \"true\",\n\t\t},\n\t\t{\n\t\t\tname: \"hasSuffix\",\n\t\t\ttemplate: \"{{hasSuffix .TemplateData.suf .TemplateData.str}}\",\n\t\t\tdata: map[string]any{\"str\": \"golang\", \"suf\": \"lang\"},\n\t\t\twant: \"true\",\n\t\t},\n\t\t{\n\t\t\tname: \"join\",\n\t\t\ttemplate: \"{{join .TemplateData.sep .TemplateData.elems}}\",\n\t\t\tdata: map[string]any{\"elems\": []string{\"1\", \"2\", \"3\"}, \"sep\": \",\"},\n\t\t\twant: \"1,2,3\",\n\t\t},\n\t\t{\n\t\t\tname: \"replace\",\n\t\t\ttemplate: \"{{replace .TemplateData.old .TemplateData.new .TemplateData.n .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"old\": \"old\", \"new\": \"new\", \"n\": 2, \"s\": \"oldoldold\"},\n\t\t\twant: \"newnewold\",\n\t\t},\n\t\t{\n\t\t\tname: \"replaceAll\",\n\t\t\ttemplate: \"{{replaceAll .TemplateData.old .TemplateData.new .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"old\": \"old\", \"new\": \"new\", \"s\": \"oldoldold\"},\n\t\t\twant: \"newnewnew\",\n\t\t},\n\n\t\t// String splitting\n\t\t{\n\t\t\tname: \"split\",\n\t\t\ttemplate: \"{{split .TemplateData.sep .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"a,b,c\", \"sep\": \",\"},\n\t\t\twant: \"[a b c]\",\n\t\t},\n\t\t{\n\t\t\tname: \"splitAfter\",\n\t\t\ttemplate: \"{{splitAfter .TemplateData.sep .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"a,b,c\", \"sep\": \",\"},\n\t\t\twant: \"[a, b, c]\",\n\t\t},\n\t\t{\n\t\t\tname: \"splitAfterN\",\n\t\t\ttemplate: \"{{splitAfterN .TemplateData.sep .TemplateData.n .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"a,b,c,d\", \"sep\": \",\", \"n\": 2},\n\t\t\twant: \"[a, b,c,d]\",\n\t\t},\n\n\t\t// Trimming functions\n\t\t{\n\t\t\tname: \"trim\",\n\t\t\ttemplate: \"{{trim .TemplateData.cutset .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"---hello---\", \"cutset\": \"-\"},\n\t\t\twant: \"hello\",\n\t\t},\n\t\t{\n\t\t\tname: \"trimLeft\",\n\t\t\ttemplate: \"{{trimLeft .TemplateData.cutset .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"---hello---\", \"cutset\": \"-\"},\n\t\t\twant: \"hello---\",\n\t\t},\n\t\t{\n\t\t\tname: \"trimRight\",\n\t\t\ttemplate: \"{{trimRight .TemplateData.cutset .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"---hello---\", \"cutset\": \"-\"},\n\t\t\twant: \"---hello\",\n\t\t},\n\t\t{\n\t\t\tname: \"trimPrefix\",\n\t\t\ttemplate: \"{{trimPrefix .TemplateData.prefix .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"prefix_text\", \"prefix\": \"prefix_\"},\n\t\t\twant: \"text\",\n\t\t},\n\t\t{\n\t\t\tname: \"trimSuffix\",\n\t\t\ttemplate: \"{{trimSuffix .TemplateData.suffix .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"text_suffix\", \"suffix\": \"_suffix\"},\n\t\t\twant: \"text\",\n\t\t},\n\t\t{\n\t\t\tname: \"trimSpace\",\n\t\t\ttemplate: \"{{trimSpace .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \" hello world \"},\n\t\t\twant: \"hello world\",\n\t\t},\n\n\t\t// Casing functions\n\t\t{\n\t\t\tname: \"lower\",\n\t\t\ttemplate: \"{{lower .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"GoLang\"},\n\t\t\twant: \"golang\",\n\t\t},\n\t\t{\n\t\t\tname: \"upper\",\n\t\t\ttemplate: \"{{upper .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"golang\"},\n\t\t\twant: \"GOLANG\",\n\t\t},\n\t\t{\n\t\t\tname: \"camelcase\",\n\t\t\ttemplate: \"{{camelcase .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"hello_world\"},\n\t\t\twant: \"helloWorld\",\n\t\t},\n\t\t{\n\t\t\tname: \"snakecase\",\n\t\t\ttemplate: \"{{snakecase .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"HelloWorld\"},\n\t\t\twant: \"hello_world\",\n\t\t},\n\t\t{\n\t\t\tname: \"kebabcase\",\n\t\t\ttemplate: \"{{kebabcase .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"HelloWorld\"},\n\t\t\twant: \"hello-world\",\n\t\t},\n\t\t{\n\t\t\tname: \"firstLower\",\n\t\t\ttemplate: \"{{firstLower .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"GoLang\"},\n\t\t\twant: \"goLang\",\n\t\t},\n\t\t{\n\t\t\tname: \"firstUpper\",\n\t\t\ttemplate: \"{{firstUpper .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"golang\"},\n\t\t\twant: \"Golang\",\n\t\t},\n\n\t\t// Regex functions\n\t\t{\n\t\t\tname: \"matchString\",\n\t\t\ttemplate: \"{{matchString .TemplateData.pattern .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"pattern\": \"go.*\", \"s\": \"golang\"},\n\t\t\twant: \"true\",\n\t\t},\n\t\t{\n\t\t\tname: \"quoteMeta\",\n\t\t\ttemplate: \"{{quoteMeta .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"1+1=2\"},\n\t\t\twant: `1\\+1=2`,\n\t\t},\n\n\t\t// Filepath manipulation\n\t\t{\n\t\t\tname: \"base\",\n\t\t\ttemplate: \"{{base .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"/home/user/file.txt\"},\n\t\t\twant: \"file.txt\",\n\t\t},\n\t\t{\n\t\t\tname: \"clean\",\n\t\t\ttemplate: \"{{clean .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"/home/user/../file.txt\"},\n\t\t\twant: \"/home/file.txt\",\n\t\t},\n\t\t{\n\t\t\tname: \"dir\",\n\t\t\ttemplate: \"{{dir .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"/home/user/file.txt\"},\n\t\t\twant: \"/home/user\",\n\t\t},\n\n\t\t// Environment variables\n\t\t{\n\t\t\tname: \"getenv\",\n\t\t\ttemplate: \"{{getenv .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"MOCKERY_TEST_ENV\"},\n\t\t\twant: \"TEST\",\n\t\t},\n\t\t{\n\t\t\tname: \"expandEnv\",\n\t\t\ttemplate: \"{{expandEnv .TemplateData.s}}\",\n\t\t\tdata: map[string]any{\"s\": \"${MOCKERY_TEST_ENV}\"},\n\t\t\twant: \"TEST\",\n\t\t},\n\n\t\t// Arithmetic\n\t\t{\n\t\t\tname: \"add\",\n\t\t\ttemplate: \"{{add .TemplateData.i1 .TemplateData.i2}}\",\n\t\t\tdata: map[string]any{\"i1\": 5, \"i2\": 10},\n\t\t\twant: \"15\",\n\t\t},\n\t\t{\n\t\t\tname: \"decr\",\n\t\t\ttemplate: \"{{decr 15}}\",\n\t\t\twant: \"14\",\n\t\t},\n\t\t{\n\t\t\tname: \"div\",\n\t\t\ttemplate: \"{{div 28 7}}\",\n\t\t\twant: \"4\",\n\t\t},\n\t\t{\n\t\t\tname: \"incr\",\n\t\t\ttemplate: \"{{incr 1}}\",\n\t\t\twant: \"2\",\n\t\t},\n\t\t{\n\t\t\tname: \"min\",\n\t\t\ttemplate: \"{{min 2 4 6}}\",\n\t\t\twant: \"2\",\n\t\t},\n\t\t{\n\t\t\tname: \"mod\",\n\t\t\ttemplate: \"{{mod 5 2}}\",\n\t\t\twant: \"1\",\n\t\t},\n\t\t{\n\t\t\tname: \"mul\",\n\t\t\ttemplate: \"{{mul 5 2}}\",\n\t\t\twant: \"10\",\n\t\t},\n\t\t{\n\t\t\tname: \"sub\",\n\t\t\ttemplate: \"{{sub 5 2}}\",\n\t\t\twant: \"3\",\n\t\t},\n\t\t{\n\t\t\tname: \"ceil\",\n\t\t\ttemplate: \"{{ceil 1.71}}\",\n\t\t\twant: \"2\",\n\t\t},\n\t\t{\n\t\t\tname: \"floor\",\n\t\t\ttemplate: \"{{floor 1.71}}\",\n\t\t\twant: \"1\",\n\t\t},\n\t\t{\n\t\t\tname: \"round 1.6\",\n\t\t\ttemplate: \"{{round 1.6}}\",\n\t\t\twant: \"2\",\n\t\t},\n\t\t{\n\t\t\tname: \"round 1.4\",\n\t\t\ttemplate: \"{{round 1.4}}\",\n\t\t\twant: \"1\",\n\t\t},\n\t\t{\n\t\t\tname: \"randInt\",\n\t\t\ttemplate: \"{{randInt}}\",\n\t\t\twantRegex: \"%d\",\n\t\t},\n\t}\n\n\tfor _, tc := range tests {\n\t\tt.Run(tc.name, func(t *testing.T) {\n\t\t\tt.Parallel()\n\t\t\ttmpl, err := template.New(tc.name).Funcs(FuncMap).Parse(tc.template)\n\t\t\trequire.NoError(t, err)\n\t\t\tvar sb strings.Builder\n\t\t\terr = tmpl.Execute(&sb, Data{TemplateData: tc.data})\n\t\t\trequire.NoError(t, err)\n\n\t\t\tif tc.wantRegex == \"\" {\n\t\t\t\tassert.Equal(t, tc.want, sb.String())\n\t\t\t} else {\n\t\t\t\tre, err := regexp.Compile(tc.wantRegex)\n\t\t\t\trequire.NoError(t, err)\n\t\t\t\tre.Match([]byte(sb.String()))\n\t\t\t}\n\t\t})\n\t}\n}\n" }, { "path": "template_funcs/functions.go", "content": "package template_funcs\n\nimport (\n\t\"cmp\"\n\t\"os\"\n\t\"slices\"\n\t\"strings\"\n\t\"unicode\"\n\n\t\"golang.org/x/exp/constraints\"\n)\n\nfunc Exported(s string) string {\n\tif s == \"\" {\n\t\treturn \"\"\n\t}\n\tfor _, initialism := range golintInitialisms {\n\t\tif strings.ToUpper(s) == initialism {\n\t\t\treturn initialism\n\t\t}\n\t}\n\treturn strings.ToUpper(s[0:1]) + s[1:]\n}\n\nfunc ReadFile(path string) (string, error) {\n\tif path == \"\" {\n\t\treturn \"\", nil\n\t}\n\tfileBytes, err := os.ReadFile(path)\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\treturn string(fileBytes), nil\n}\n\n// Numbers defines the generic constraints of the arithmetic arguments.\ntype Numbers interface {\n\tconstraints.Integer | constraints.Float | constraints.Complex\n}\n\n// Add adds the given numbers.\nfunc Add[T Numbers](i1 T, in ...T) T {\n\tvar sum T = i1\n\tfor _, i := range in {\n\t\tsum += i\n\t}\n\treturn sum\n}\n\n// Incr increments the numbers by 1.\nfunc Incr[T Numbers](i T) T {\n\treturn i + 1\n}\n\n// Decr decrements the numbers by 1.\nfunc Decr[T Numbers](i T) T {\n\treturn i - 1\n}\n\n// Sub subtracts the given numbers.\nfunc Sub[T Numbers](i1 T, in ...T) T {\n\tvar sub T = i1\n\tfor _, i := range in {\n\t\tsub -= i\n\t}\n\treturn sub\n}\n\n// Div cumulatively divides the given numbers.\nfunc Div[T Numbers](i1 T, in ...T) T {\n\tvar sub T = i1\n\tfor _, i := range in {\n\t\tsub /= i\n\t}\n\treturn sub\n}\n\n// Mod returns the cumulative modulo of the given numbers.\nfunc Mod[T constraints.Integer](i1 T, in ...T) T {\n\tvar sub T = i1\n\tfor _, i := range in {\n\t\tsub = sub % i\n\t}\n\treturn sub\n}\n\n// Mul returns the cumulative multiplication of the given numbers.\nfunc Mul[T Numbers](i1 T, in ...T) T {\n\tvar sub T = i1\n\tfor _, i := range in {\n\t\tsub *= i\n\t}\n\treturn sub\n}\n\n// Max returns the maximum value.\nfunc Max[T cmp.Ordered](x ...T) T {\n\treturn slices.Max(x)\n}\n\n// Min returns the minimum value.\nfunc Min[T cmp.Ordered](x ...T) T {\n\treturn slices.Min(x)\n}\n\n// FirstIsLower returns whether or not the string's first character is lowercase.\n// If the string is empty, false is returned. If the first character is a non-alphabetic\n// character, false is returned.\nfunc FirstIsLower(s string) bool {\n\tfirst := rune(s[0])\n\tif len(s) == 0 || !unicode.IsLetter(first) {\n\t\treturn false\n\t}\n\treturn !unicode.IsUpper(first)\n}\n" }, { "path": "template_funcs/functions_test.go", "content": "package template_funcs\n\nimport \"testing\"\n\nfunc TestFirstIsLower(t *testing.T) {\n\ttests := []struct {\n\t\targ string\n\t\twant bool\n\t}{\n\t\t{\n\t\t\targ: \"Exported\",\n\t\t\twant: false,\n\t\t},\n\t\t{\n\t\t\targ: \"unexported\",\n\t\t\twant: true,\n\t\t},\n\t\t{\n\t\t\targ: \"1234\",\n\t\t\twant: false,\n\t\t},\n\t\t{\n\t\t\targ: \"MockargGetter\",\n\t\t\twant: false,\n\t\t},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.arg, func(t *testing.T) {\n\t\t\tif got := FirstIsLower(tt.arg); got != tt.want {\n\t\t\t\tt.Errorf(\"FirstIsLower() = %v, want %v\", got, tt.want)\n\t\t\t}\n\t\t})\n\t}\n}\n" }, { "path": "tools/cmd/root.go", "content": "package cmd\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\n\t\"github.com/go-errors/errors\"\n\t\"github.com/rs/zerolog\"\n\t\"github.com/spf13/cobra\"\n\t\"github.com/spf13/viper\"\n)\n\nvar logger zerolog.Logger\n\ntype timestampHook struct{}\n\nfunc (t timestampHook) Run(e *zerolog.Event, level zerolog.Level, message string) {\n\te.Timestamp()\n}\n\nfunc maybeExit(err error) {\n\tprintStack(err)\n\tif err != nil {\n\t\tos.Exit(1)\n\t}\n}\n\nfunc newViper() *viper.Viper {\n\tv := viper.New()\n\tv.SetConfigType(\"env\")\n\tv.SetConfigName(\"mockery-tools\")\n\tv.AddConfigPath(\".\")\n\tv.AddConfigPath(\"../\")\n\tv.SetEnvPrefix(\"MOCKERYTOOLS\")\n\tmaybeExit(v.ReadInConfig())\n\treturn v\n}\n\nfunc NewRootCmd() *cobra.Command {\n\tcmd := &cobra.Command{\n\t\tUse: \"mockery_tools [command]\",\n\t}\n\n\tlogger = zerolog.New(zerolog.ConsoleWriter{\n\t\tOut: os.Stderr,\n\t}).Hook(timestampHook{})\n\n\tsubCommands := []func(v *viper.Viper) (*cobra.Command, error){\n\t\tNewTagCmd,\n\t}\n\tfor _, CommandFunc := range subCommands {\n\t\tsubCmd, err := CommandFunc(newViper())\n\t\tif err != nil {\n\t\t\tpanic(err)\n\t\t}\n\t\tcmd.AddCommand(subCmd)\n\t}\n\treturn cmd\n}\n\nfunc printStack(err error) {\n\tif err == nil {\n\t\treturn\n\t}\n\tnewErr, ok := err.(*errors.Error)\n\tif ok {\n\t\tfmt.Fprintf(os.Stderr, \"%v\\n\", newErr.ErrorStack())\n\t} else {\n\t\tfmt.Fprintf(os.Stderr, \"%v\\n\", err)\n\t}\n}\n" }, { "path": "tools/cmd/tag.go", "content": "package cmd\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"strings\"\n\t\"time\"\n\n\t\"github.com/Masterminds/semver/v3\"\n\t\"github.com/go-errors/errors\"\n\t\"github.com/go-git/go-git/v5\"\n\t\"github.com/go-git/go-git/v5/plumbing\"\n\t\"github.com/go-git/go-git/v5/plumbing/object\"\n\t\"github.com/go-playground/validator/v10\"\n\t\"github.com/spf13/cobra\"\n\t\"github.com/spf13/viper\"\n)\n\nvar ErrNoNewVersion = errors.New(\"no new version specified\")\n\nvar EXIT_CODE_NO_NEW_VERSION = 8\n\nfunc NewTagCmd(v *viper.Viper) (*cobra.Command, error) {\n\tif err := v.ReadInConfig(); err != nil {\n\t\treturn nil, err\n\t}\n\tcmd := &cobra.Command{\n\t\tUse: \"tag\",\n\t\tRun: func(cmd *cobra.Command, args []string) {\n\t\t\ttagger, err := NewTagger(v)\n\t\t\tif err != nil {\n\t\t\t\tprintStack(err)\n\t\t\t\tos.Exit(1)\n\t\t\t}\n\t\t\trequestedVersion, previousVersion, err := tagger.Tag()\n\t\t\tif requestedVersion != nil && previousVersion != nil {\n\t\t\t\tfmt.Fprintf(os.Stdout, \"v%s,v%s\", requestedVersion.String(), previousVersion.String())\n\t\t\t}\n\t\t\tif err != nil {\n\t\t\t\tif errors.Is(ErrNoNewVersion, err) {\n\t\t\t\t\tos.Exit(EXIT_CODE_NO_NEW_VERSION)\n\t\t\t\t}\n\t\t\t\tprintStack(err)\n\t\t\t\tos.Exit(1)\n\t\t\t}\n\t\t},\n\t}\n\tflags := cmd.PersistentFlags()\n\tflags.Bool(\"dry-run\", true, \"print, but do not perform, any actions\")\n\n\tviper.BindPFlag(\"dry-run\", flags.Lookup(\"dry-run\"))\n\n\treturn cmd, nil\n}\n\nfunc (t *Tagger) createTag(repo *git.Repository, version string) error {\n\thash, err := repo.Head()\n\tif err != nil {\n\t\treturn errors.New(err)\n\t}\n\n\tif t.DryRun {\n\t\tlogger.Info().Str(\"tag\", version).Msg(\"would have created tag\")\n\t\treturn nil\n\t}\n\tmajorVersion := strings.Split(version, \".\")[0]\n\tfor _, v := range []string{version, majorVersion} {\n\t\tif err := repo.DeleteTag(v); err != nil {\n\t\t\tlogger.Warn().Err(err).Str(\"tag\", v).Msg(\"failed to delete tag, might be okay.\")\n\t\t}\n\t\t_, err = repo.CreateTag(v, hash.Hash(), &git.CreateTagOptions{\n\t\t\tTagger: &object.Signature{\n\t\t\t\tName: \"Landon Clipp\",\n\t\t\t\tEmail: \"11232769+LandonTClipp@users.noreply.github.com\",\n\t\t\t\tWhen: time.Now(),\n\t\t\t},\n\t\t\tMessage: v,\n\t\t})\n\t\tif err != nil {\n\t\t\treturn errors.New(err)\n\t\t}\n\t}\n\n\tlogger.Info().Str(\"tag\", version).Msg(\"tag successfully created\")\n\treturn nil\n}\n\nfunc (t *Tagger) largestTagSemver(repo *git.Repository, major uint64) (*semver.Version, error) {\n\tlargestTag, err := semver.NewVersion(\"v0.0.0\")\n\tif err != nil {\n\t\treturn nil, errors.New(err)\n\t}\n\n\titer, err := repo.Tags()\n\tif err != nil {\n\t\treturn nil, errors.New(err)\n\t}\n\tif err := iter.ForEach(func(ref *plumbing.Reference) error {\n\t\tvar versionString string\n\t\ttag, err := repo.TagObject(ref.Hash())\n\t\tswitch err {\n\t\tcase nil:\n\t\tcase plumbing.ErrObjectNotFound:\n\t\t\t// Not a tag object\n\t\tdefault:\n\t\t\t// Some other error\n\t\t\treturn errors.New(err)\n\t\t}\n\t\tif err != nil {\n\t\t\tif errors.Is(plumbing.ErrObjectNotFound, err) {\n\t\t\t\t// Tag is lightweight tag\n\t\t\t\tversionString = ref.Name().Short()\n\t\t\t} else {\n\t\t\t\tlogger.Err(err).\n\t\t\t\t\tStr(\"hash\", ref.Hash().String()).\n\t\t\t\t\tStr(\"name\", ref.Name().String()).\n\t\t\t\t\tMsg(\"error when retrieving tag object\")\n\t\t\t\treturn errors.New(err)\n\t\t\t}\n\t\t} else {\n\t\t\tversionString = tag.Name\n\t\t}\n\t\tversionParts := strings.Split(versionString, \".\")\n\t\tif len(versionParts) < 3 {\n\t\t\t// This is not a full version tag, so ignore it\n\t\t\treturn nil\n\t\t}\n\n\t\tversion, err := semver.NewVersion(versionString)\n\t\tif err != nil {\n\t\t\treturn errors.New(err)\n\t\t}\n\t\tif version.GreaterThan(largestTag) && version.Major() == major {\n\t\t\tlargestTag = version\n\t\t}\n\t\treturn nil\n\t}); err != nil {\n\t\treturn nil, err\n\t}\n\treturn largestTag, nil\n}\n\nfunc NewTagger(v *viper.Viper) (*Tagger, error) {\n\tt := &Tagger{}\n\tif err := v.Unmarshal(t); err != nil {\n\t\treturn nil, errors.New(err)\n\t}\n\tlogger.Info().Msgf(\"Using config: %s\", v.ConfigFileUsed())\n\tif err := validator.New(\n\t\tvalidator.WithRequiredStructEnabled(),\n\t).Struct(t); err != nil {\n\t\treturn nil, errors.New(err)\n\t}\n\treturn t, nil\n}\n\ntype Tagger struct {\n\tDryRun bool `mapstructure:\"dry-run\"`\n\tVersion string `mapstructure:\"version\" validate:\"required\"`\n}\n\nfunc (t *Tagger) Tag() (requestedVersion *semver.Version, previousVersion *semver.Version, err error) {\n\trepo, err := git.PlainOpen(\".\")\n\tif err != nil {\n\t\treturn nil, nil, errors.New(err)\n\t}\n\n\trequestedVersion, err = semver.NewVersion(t.Version)\n\tif err != nil {\n\t\tlogger.Err(err).Str(\"requested-version\", string(t.Version)).Msg(\"error when constructing semver from version config\")\n\t\treturn requestedVersion, nil, errors.New(err)\n\t}\n\n\tpreviousVersion, err = t.largestTagSemver(repo, requestedVersion.Major())\n\tif err != nil {\n\t\treturn requestedVersion, previousVersion, err\n\t}\n\tlogger := logger.With().\n\t\tStringer(\"previous-version\", previousVersion).Logger()\n\n\tlogger.Info().Msg(\"found largest semver tag\")\n\n\tlogger = logger.With().\n\t\tStringer(\"requested-version\", requestedVersion).\n\t\tLogger()\n\tif !requestedVersion.GreaterThan(previousVersion) {\n\t\tlogger.Info().\n\t\t\tMsg(\"VERSION is not greater than latest git tag, nothing to do.\")\n\t\treturn requestedVersion, previousVersion, ErrNoNewVersion\n\t}\n\n\tworktree, err := repo.Worktree()\n\tif err != nil {\n\t\treturn requestedVersion, previousVersion, errors.New(err)\n\t}\n\n\tstatus, err := worktree.Status()\n\tif err != nil {\n\t\treturn requestedVersion, previousVersion, errors.New(err)\n\t}\n\tif !status.IsClean() {\n\t\tlogger.Error().Msg(\"git is in a dirty state, can't tag.\")\n\t\tfmt.Println(status.String())\n\t\treturn requestedVersion, previousVersion, errors.New(\"dirty git state\")\n\t}\n\n\tif err := t.createTag(repo, fmt.Sprintf(\"v%s\", requestedVersion.String())); err != nil {\n\t\treturn requestedVersion, previousVersion, err\n\t}\n\tlogger.Info().Msg(\"created new tag. Push to origin still required.\")\n\n\treturn requestedVersion, previousVersion, nil\n}\n" }, { "path": "tools/go.mod", "content": "module github.com/vektra/mockery/tools\n\ngo 1.24.0\n\nrequire (\n\tgithub.com/go-errors/errors v1.5.1\n\tgithub.com/go-git/go-git/v5 v5.13.0\n\tgithub.com/go-playground/validator/v10 v10.23.0\n\tgithub.com/go-task/task/v3 v3.38.0\n\tgithub.com/golangci/golangci-lint v1.60.3\n\tgithub.com/rs/zerolog v1.33.0\n\tgotest.tools/gotestsum v1.11.0\n)\n\nrequire (\n\tdario.cat/mergo v1.0.0 // indirect\n\tgithub.com/4meepo/tagalign v1.3.4 // indirect\n\tgithub.com/Antonboom/testifylint v1.4.3 // indirect\n\tgithub.com/Crocmagnon/fatcontext v0.4.0 // indirect\n\tgithub.com/GaijinEntertainment/go-exhaustruct/v3 v3.3.0 // indirect\n\tgithub.com/Ladicle/tabwriter v1.0.0 // indirect\n\tgithub.com/Microsoft/go-winio v0.6.1 // indirect\n\tgithub.com/OpenPeeDeeP/depguard/v2 v2.2.0 // indirect\n\tgithub.com/ProtonMail/go-crypto v1.1.3 // indirect\n\tgithub.com/alecthomas/chroma/v2 v2.14.0 // indirect\n\tgithub.com/alecthomas/go-check-sumtype v0.1.4 // indirect\n\tgithub.com/alexkohler/nakedret/v2 v2.0.4 // indirect\n\tgithub.com/bombsimon/wsl/v4 v4.4.1 // indirect\n\tgithub.com/butuzov/mirror v1.2.0 // indirect\n\tgithub.com/catenacyber/perfsprint v0.7.1 // indirect\n\tgithub.com/ccojocar/zxcvbn-go v1.0.2 // indirect\n\tgithub.com/ckaznocha/intrange v0.1.2 // indirect\n\tgithub.com/cloudflare/circl v1.3.7 // indirect\n\tgithub.com/cyphar/filepath-securejoin v0.2.5 // indirect\n\tgithub.com/dlclark/regexp2 v1.11.0 // indirect\n\tgithub.com/dominikbraun/graph v0.23.0 // indirect\n\tgithub.com/emirpasic/gods v1.18.1 // indirect\n\tgithub.com/gabriel-vasile/mimetype v1.4.3 // indirect\n\tgithub.com/ghostiam/protogetter v0.3.6 // indirect\n\tgithub.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect\n\tgithub.com/go-git/go-billy/v5 v5.6.0 // indirect\n\tgithub.com/go-playground/locales v0.14.1 // indirect\n\tgithub.com/go-playground/universal-translator v0.18.1 // indirect\n\tgithub.com/go-task/slim-sprig/v3 v3.0.0 // indirect\n\tgithub.com/go-task/template v0.0.0-20240602015157-960e6f576656 // indirect\n\tgithub.com/go-viper/mapstructure/v2 v2.4.0 // indirect\n\tgithub.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect\n\tgithub.com/golangci/modinfo v0.3.4 // indirect\n\tgithub.com/golangci/plugin-module-register v0.1.1 // indirect\n\tgithub.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect\n\tgithub.com/jjti/go-spancheck v0.6.2 // indirect\n\tgithub.com/karamaru-alpha/copyloopvar v1.1.0 // indirect\n\tgithub.com/kevinburke/ssh_config v1.2.0 // indirect\n\tgithub.com/klauspost/cpuid/v2 v2.0.9 // indirect\n\tgithub.com/lasiar/canonicalheader v1.1.1 // indirect\n\tgithub.com/leodido/go-urn v1.4.0 // indirect\n\tgithub.com/macabu/inamedparam v0.1.3 // indirect\n\tgithub.com/pjbgf/sha1cd v0.3.0 // indirect\n\tgithub.com/quasilyte/go-ruleguard/dsl v0.3.22 // indirect\n\tgithub.com/rivo/uniseg v0.4.7 // indirect\n\tgithub.com/sagikazarmark/locafero v0.9.0 // indirect\n\tgithub.com/santhosh-tekuri/jsonschema/v5 v5.3.1 // indirect\n\tgithub.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect\n\tgithub.com/skeema/knownhosts v1.3.0 // indirect\n\tgithub.com/sourcegraph/conc v0.3.0 // indirect\n\tgithub.com/xanzy/ssh-agent v0.3.3 // indirect\n\tgithub.com/xen0n/gosmopolitan v1.2.2 // indirect\n\tgithub.com/ykadowak/zerologlint v0.1.5 // indirect\n\tgithub.com/zeebo/xxh3 v1.0.2 // indirect\n\tgo-simpler.org/musttag v0.12.2 // indirect\n\tgo-simpler.org/sloglint v0.7.2 // indirect\n\tgo.uber.org/automaxprocs v1.5.3 // indirect\n\tgolang.org/x/crypto v0.41.0 // indirect\n\tgolang.org/x/net v0.43.0 // indirect\n\tgolang.org/x/tools/go/expect v0.1.1-deprecated // indirect\n\tgolang.org/x/tools/go/packages/packagestest v0.1.1-deprecated // indirect\n\tgopkg.in/warnings.v0 v0.1.2 // indirect\n)\n\nrequire (\n\t4d63.com/gocheckcompilerdirectives v1.2.1 // indirect\n\t4d63.com/gochecknoglobals v0.2.1 // indirect\n\tgithub.com/Abirdcfly/dupword v0.0.14 // indirect\n\tgithub.com/Antonboom/errname v0.1.13 // indirect\n\tgithub.com/Antonboom/nilnil v0.1.9 // indirect; indirectccd\n\tgithub.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c // indirect\n\tgithub.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24 // indirect\n\tgithub.com/Masterminds/semver/v3 v3.2.1\n\tgithub.com/alexkohler/prealloc v1.0.0 // indirect\n\tgithub.com/alingse/asasalint v0.0.11 // indirect\n\tgithub.com/ashanbrown/forbidigo v1.6.0 // indirect\n\tgithub.com/ashanbrown/makezero v1.1.1 // indirect\n\tgithub.com/beorn7/perks v1.0.1 // indirect\n\tgithub.com/bitfield/gotestdox v0.2.1 // indirect\n\tgithub.com/bkielbasa/cyclop v1.2.1 // indirect\n\tgithub.com/blizzy78/varnamelen v0.8.0 // indirect\n\tgithub.com/breml/bidichk v0.2.7 // indirect\n\tgithub.com/breml/errchkjson v0.3.6 // indirect\n\tgithub.com/butuzov/ireturn v0.3.0 // indirect\n\tgithub.com/cespare/xxhash/v2 v2.3.0 // indirect\n\tgithub.com/charithe/durationcheck v0.0.10 // indirect\n\tgithub.com/chavacava/garif v0.1.0 // indirect\n\tgithub.com/curioswitch/go-reassign v0.2.0 // indirect\n\tgithub.com/daixiang0/gci v0.13.4 // indirect\n\tgithub.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect\n\tgithub.com/denis-tingaikin/go-header v0.5.0 // indirect\n\tgithub.com/dnephin/pflag v1.0.7 // indirect\n\tgithub.com/ettle/strcase v0.2.0 // indirect\n\tgithub.com/fatih/color v1.17.0 // indirect\n\tgithub.com/fatih/structtag v1.2.0 // indirect\n\tgithub.com/firefart/nonamedreturns v1.0.5 // indirect\n\tgithub.com/fsnotify/fsnotify v1.9.0 // indirect\n\tgithub.com/fzipp/gocyclo v0.6.0 // indirect\n\tgithub.com/go-critic/go-critic v0.11.4 // indirect\n\tgithub.com/go-toolsmith/astcast v1.1.0 // indirect\n\tgithub.com/go-toolsmith/astcopy v1.1.0 // indirect\n\tgithub.com/go-toolsmith/astequal v1.2.0 // indirect\n\tgithub.com/go-toolsmith/astfmt v1.1.0 // indirect\n\tgithub.com/go-toolsmith/astp v1.1.0 // indirect\n\tgithub.com/go-toolsmith/strparse v1.1.0 // indirect\n\tgithub.com/go-toolsmith/typep v1.1.0 // indirect\n\tgithub.com/go-xmlfmt/xmlfmt v1.1.2 // indirect\n\tgithub.com/gobwas/glob v0.2.3 // indirect\n\tgithub.com/gofrs/flock v0.12.1 // indirect\n\tgithub.com/golang/protobuf v1.5.3 // indirect\n\tgithub.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a // indirect\n\tgithub.com/golangci/gofmt v0.0.0-20240816233607-d8596aa466a9 // indirect\n\tgithub.com/golangci/misspell v0.6.0 // indirect\n\tgithub.com/golangci/revgrep v0.5.3 // indirect\n\tgithub.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed // indirect\n\tgithub.com/google/go-cmp v0.6.0 // indirect\n\tgithub.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect\n\tgithub.com/gordonklaus/ineffassign v0.1.0 // indirect\n\tgithub.com/gostaticanalysis/analysisutil v0.7.1 // indirect\n\tgithub.com/gostaticanalysis/comment v1.4.2 // indirect\n\tgithub.com/gostaticanalysis/forcetypeassert v0.1.0 // indirect\n\tgithub.com/gostaticanalysis/nilerr v0.1.1 // indirect\n\tgithub.com/hashicorp/go-version v1.7.0 // indirect\n\tgithub.com/hexops/gotextdiff v1.0.3 // indirect\n\tgithub.com/inconshreveable/mousetrap v1.1.0 // indirect\n\tgithub.com/jgautheron/goconst v1.7.1 // indirect\n\tgithub.com/jingyugao/rowserrcheck v1.1.1 // indirect\n\tgithub.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af // indirect\n\tgithub.com/joho/godotenv v1.5.1 // indirect\n\tgithub.com/julz/importas v0.1.0 // indirect\n\tgithub.com/kisielk/errcheck v1.7.0 // indirect\n\tgithub.com/kkHAIKE/contextcheck v1.1.5 // indirect\n\tgithub.com/kulti/thelper v0.6.3 // indirect\n\tgithub.com/kunwardeep/paralleltest v1.0.10 // indirect\n\tgithub.com/kyoh86/exportloopref v0.1.11 // indirect\n\tgithub.com/ldez/gomoddirectives v0.2.4 // indirect\n\tgithub.com/ldez/tagliatelle v0.5.0 // indirect\n\tgithub.com/leonklingele/grouper v1.1.2 // indirect\n\tgithub.com/lufeee/execinquery v1.2.1 // indirect\n\tgithub.com/maratori/testableexamples v1.0.0 // indirect\n\tgithub.com/maratori/testpackage v1.1.1 // indirect\n\tgithub.com/matoous/godox v0.0.0-20230222163458-006bad1f9d26 // indirect\n\tgithub.com/mattn/go-colorable v0.1.13 // indirect\n\tgithub.com/mattn/go-isatty v0.0.20 // indirect\n\tgithub.com/mattn/go-runewidth v0.0.16 // indirect\n\tgithub.com/mattn/go-zglob v0.0.4 // indirect\n\tgithub.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect\n\tgithub.com/mgechev/revive v1.3.9 // indirect\n\tgithub.com/mitchellh/go-homedir v1.1.0 // indirect\n\tgithub.com/mitchellh/hashstructure/v2 v2.0.2 // indirect\n\tgithub.com/moricho/tparallel v0.3.2 // indirect\n\tgithub.com/nakabonne/nestif v0.3.1 // indirect\n\tgithub.com/nishanths/exhaustive v0.12.0 // indirect\n\tgithub.com/nishanths/predeclared v0.2.2 // indirect\n\tgithub.com/nunnatsa/ginkgolinter v0.16.2 // indirect\n\tgithub.com/olekukonko/tablewriter v0.0.5 // indirect\n\tgithub.com/pelletier/go-toml/v2 v2.2.4 // indirect\n\tgithub.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect\n\tgithub.com/polyfloyd/go-errorlint v1.6.0 // indirect\n\tgithub.com/prometheus/client_golang v1.12.1 // indirect\n\tgithub.com/prometheus/client_model v0.2.0 // indirect\n\tgithub.com/prometheus/common v0.32.1 // indirect\n\tgithub.com/prometheus/procfs v0.7.3 // indirect\n\tgithub.com/quasilyte/go-ruleguard v0.4.2 // indirect\n\tgithub.com/quasilyte/gogrep v0.5.0 // indirect\n\tgithub.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727 // indirect\n\tgithub.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567 // indirect\n\tgithub.com/radovskyb/watcher v1.0.7 // indirect\n\tgithub.com/ryancurrah/gomodguard v1.3.3 // indirect\n\tgithub.com/ryanrolds/sqlclosecheck v0.5.1 // indirect\n\tgithub.com/sajari/fuzzy v1.0.0 // indirect\n\tgithub.com/sanposhiho/wastedassign/v2 v2.0.7 // indirect\n\tgithub.com/sashamelentyev/interfacebloat v1.1.0 // indirect\n\tgithub.com/sashamelentyev/usestdlibvars v1.27.0 // indirect\n\tgithub.com/securego/gosec/v2 v2.20.1-0.20240822074752-ab3f6c1c83a0 // indirect\n\tgithub.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c // indirect\n\tgithub.com/sirupsen/logrus v1.9.3 // indirect\n\tgithub.com/sivchari/containedctx v1.0.3 // indirect\n\tgithub.com/sivchari/tenv v1.10.0 // indirect\n\tgithub.com/sonatard/noctx v0.0.2 // indirect\n\tgithub.com/sourcegraph/go-diff v0.7.0 // indirect\n\tgithub.com/spf13/afero v1.14.0 // indirect\n\tgithub.com/spf13/cast v1.7.1 // indirect\n\tgithub.com/spf13/cobra v1.8.1\n\tgithub.com/spf13/pflag v1.0.6 // indirect\n\tgithub.com/spf13/viper v1.20.1\n\tgithub.com/ssgreg/nlreturn/v2 v2.2.1 // indirect\n\tgithub.com/stbenjam/no-sprintf-host-port v0.1.1 // indirect\n\tgithub.com/stretchr/objx v0.5.2 // indirect\n\tgithub.com/stretchr/testify v1.10.0 // indirect\n\tgithub.com/subosito/gotenv v1.6.0 // indirect\n\tgithub.com/tdakkota/asciicheck v0.2.0 // indirect\n\tgithub.com/tetafro/godot v1.4.16 // indirect\n\tgithub.com/timakin/bodyclose v0.0.0-20230421092635-574207250966 // indirect\n\tgithub.com/timonwong/loggercheck v0.9.4 // indirect\n\tgithub.com/tomarrell/wrapcheck/v2 v2.9.0 // indirect\n\tgithub.com/tommy-muehle/go-mnd/v2 v2.5.1 // indirect\n\tgithub.com/ultraware/funlen v0.1.0 // indirect\n\tgithub.com/ultraware/whitespace v0.1.1 // indirect\n\tgithub.com/uudashr/gocognit v1.1.3 // indirect\n\tgithub.com/yagipy/maintidx v1.0.0 // indirect\n\tgithub.com/yeya24/promlinter v0.3.0 // indirect\n\tgitlab.com/bosi/decorder v0.4.2 // indirect\n\tgo.uber.org/atomic v1.11.0 // indirect\n\tgo.uber.org/multierr v1.11.0 // indirect\n\tgo.uber.org/zap v1.24.0 // indirect\n\tgolang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect\n\tgolang.org/x/exp/typeparams v0.0.0-20240314144324-c7f7c6466f7f // indirect\n\tgolang.org/x/mod v0.27.0 // indirect\n\tgolang.org/x/sync v0.16.0 // indirect\n\tgolang.org/x/sys v0.35.0 // indirect\n\tgolang.org/x/term v0.34.0 // indirect\n\tgolang.org/x/text v0.28.0 // indirect\n\tgolang.org/x/tools v0.36.0 // indirect\n\tgoogle.golang.org/protobuf v1.36.1 // indirect\n\tgopkg.in/yaml.v2 v2.4.0 // indirect\n\tgopkg.in/yaml.v3 v3.0.1 // indirect\n\thonnef.co/go/tools v0.5.1 // indirect\n\tmvdan.cc/gofumpt v0.7.0\n\tmvdan.cc/sh/v3 v3.8.0 // indirect\n\tmvdan.cc/unparam v0.0.0-20240528143540-8a5130ca722f // indirect\n)\n" }, { "path": "tools/go.sum", "content": "4d63.com/gocheckcompilerdirectives v1.2.1 h1:AHcMYuw56NPjq/2y615IGg2kYkBdTvOaojYCBcRE7MA=\n4d63.com/gocheckcompilerdirectives v1.2.1/go.mod h1:yjDJSxmDTtIHHCqX0ufRYZDL6vQtMG7tJdKVeWwsqvs=\n4d63.com/gochecknoglobals v0.2.1 h1:1eiorGsgHOFOuoOiJDy2psSrQbRdIHrlge0IJIkUgDc=\n4d63.com/gochecknoglobals v0.2.1/go.mod h1:KRE8wtJB3CXCsb1xy421JfTHIIbmT3U5ruxw2Qu8fSU=\ncloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=\ncloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=\ncloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=\ncloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=\ncloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=\ncloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=\ncloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=\ncloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=\ncloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=\ncloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=\ncloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=\ncloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=\ncloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=\ncloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=\ncloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=\ncloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=\ncloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=\ncloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=\ncloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=\ncloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=\ncloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=\ncloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=\ncloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=\ncloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=\ncloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=\ncloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=\ncloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=\ncloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=\ncloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=\ncloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=\ncloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=\ncloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=\ndario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=\ndario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=\ndmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=\ngithub.com/4meepo/tagalign v1.3.4 h1:P51VcvBnf04YkHzjfclN6BbsopfJR5rxs1n+5zHt+w8=\ngithub.com/4meepo/tagalign v1.3.4/go.mod h1:M+pnkHH2vG8+qhE5bVc/zeP7HS/j910Fwa9TUSyZVI0=\ngithub.com/Abirdcfly/dupword v0.0.14 h1:3U4ulkc8EUo+CaT105/GJ1BQwtgyj6+VaBVbAX11Ba8=\ngithub.com/Abirdcfly/dupword v0.0.14/go.mod h1:VKDAbxdY8YbKUByLGg8EETzYSuC4crm9WwI6Y3S0cLI=\ngithub.com/Antonboom/errname v0.1.13 h1:JHICqsewj/fNckzrfVSe+T33svwQxmjC+1ntDsHOVvM=\ngithub.com/Antonboom/errname v0.1.13/go.mod h1:uWyefRYRN54lBg6HseYCFhs6Qjcy41Y3Jl/dVhA87Ns=\ngithub.com/Antonboom/nilnil v0.1.9 h1:eKFMejSxPSA9eLSensFmjW2XTgTwJMjZ8hUHtV4s/SQ=\ngithub.com/Antonboom/nilnil v0.1.9/go.mod h1:iGe2rYwCq5/Me1khrysB4nwI7swQvjclR8/YRPl5ihQ=\ngithub.com/Antonboom/testifylint v1.4.3 h1:ohMt6AHuHgttaQ1xb6SSnxCeK4/rnK7KKzbvs7DmEck=\ngithub.com/Antonboom/testifylint v1.4.3/go.mod h1:+8Q9+AOLsz5ZiQiiYujJKs9mNz398+M6UgslP4qgJLA=\ngithub.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=\ngithub.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c h1:pxW6RcqyfI9/kWtOwnv/G+AzdKuy2ZrqINhenH4HyNs=\ngithub.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=\ngithub.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=\ngithub.com/Crocmagnon/fatcontext v0.4.0 h1:4ykozu23YHA0JB6+thiuEv7iT6xq995qS1vcuWZq0tg=\ngithub.com/Crocmagnon/fatcontext v0.4.0/go.mod h1:ZtWrXkgyfsYPzS6K3O88va6t2GEglG93vnII/F94WC0=\ngithub.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24 h1:sHglBQTwgx+rWPdisA5ynNEsoARbiCBOyGcJM4/OzsM=\ngithub.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24/go.mod h1:4UJr5HIiMZrwgkSPdsjy2uOQExX/WEILpIrO9UPGuXs=\ngithub.com/GaijinEntertainment/go-exhaustruct/v3 v3.3.0 h1:/fTUt5vmbkAcMBt4YQiuC23cV0kEsN1MVMNqeOW43cU=\ngithub.com/GaijinEntertainment/go-exhaustruct/v3 v3.3.0/go.mod h1:ONJg5sxcbsdQQ4pOW8TGdTidT2TMAUy/2Xhr8mrYaao=\ngithub.com/Ladicle/tabwriter v1.0.0 h1:DZQqPvMumBDwVNElso13afjYLNp0Z7pHqHnu0r4t9Dg=\ngithub.com/Ladicle/tabwriter v1.0.0/go.mod h1:c4MdCjxQyTbGuQO/gvqJ+IA/89UEwrsD6hUCW98dyp4=\ngithub.com/Masterminds/semver/v3 v3.2.1 h1:RN9w6+7QoMeJVGyfmbcgs28Br8cvmnucEXnY0rYXWg0=\ngithub.com/Masterminds/semver/v3 v3.2.1/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ=\ngithub.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=\ngithub.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=\ngithub.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=\ngithub.com/OpenPeeDeeP/depguard/v2 v2.2.0 h1:vDfG60vDtIuf0MEOhmLlLLSzqaRM8EMcgJPdp74zmpA=\ngithub.com/OpenPeeDeeP/depguard/v2 v2.2.0/go.mod h1:CIzddKRvLBC4Au5aYP/i3nyaWQ+ClszLIuVocRiCYFQ=\ngithub.com/ProtonMail/go-crypto v1.1.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk=\ngithub.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=\ngithub.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=\ngithub.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=\ngithub.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=\ngithub.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=\ngithub.com/alecthomas/go-check-sumtype v0.1.4 h1:WCvlB3l5Vq5dZQTFmodqL2g68uHiSwwlWcT5a2FGK0c=\ngithub.com/alecthomas/go-check-sumtype v0.1.4/go.mod h1:WyYPfhfkdhyrdaligV6svFopZV8Lqdzn5pyVBaV6jhQ=\ngithub.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=\ngithub.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=\ngithub.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=\ngithub.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=\ngithub.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=\ngithub.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=\ngithub.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=\ngithub.com/alexkohler/nakedret/v2 v2.0.4 h1:yZuKmjqGi0pSmjGpOC016LtPJysIL0WEUiaXW5SUnNg=\ngithub.com/alexkohler/nakedret/v2 v2.0.4/go.mod h1:bF5i0zF2Wo2o4X4USt9ntUWve6JbFv02Ff4vlkmS/VU=\ngithub.com/alexkohler/prealloc v1.0.0 h1:Hbq0/3fJPQhNkN0dR95AVrr6R7tou91y0uHG5pOcUuw=\ngithub.com/alexkohler/prealloc v1.0.0/go.mod h1:VetnK3dIgFBBKmg0YnD9F9x6Icjd+9cvfHR56wJVlKE=\ngithub.com/alingse/asasalint v0.0.11 h1:SFwnQXJ49Kx/1GghOFz1XGqHYKp21Kq1nHad/0WQRnw=\ngithub.com/alingse/asasalint v0.0.11/go.mod h1:nCaoMhw7a9kSJObvQyVzNTPBDbNpdocqrSP7t/cW5+I=\ngithub.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=\ngithub.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=\ngithub.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=\ngithub.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=\ngithub.com/ashanbrown/forbidigo v1.6.0 h1:D3aewfM37Yb3pxHujIPSpTf6oQk9sc9WZi8gerOIVIY=\ngithub.com/ashanbrown/forbidigo v1.6.0/go.mod h1:Y8j9jy9ZYAEHXdu723cUlraTqbzjKF1MUyfOKL+AjcU=\ngithub.com/ashanbrown/makezero v1.1.1 h1:iCQ87C0V0vSyO+M9E/FZYbu65auqH0lnsOkf5FcB28s=\ngithub.com/ashanbrown/makezero v1.1.1/go.mod h1:i1bJLCRSCHOcOa9Y6MyF2FTfMZMFdHvxKHxgO5Z1axI=\ngithub.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=\ngithub.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=\ngithub.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=\ngithub.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=\ngithub.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=\ngithub.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=\ngithub.com/bitfield/gotestdox v0.2.1 h1:Zj8IMLAO5/oiAKoMmtN96eyFiPZraJRTH2p0zDgtxc0=\ngithub.com/bitfield/gotestdox v0.2.1/go.mod h1:D+gwtS0urjBrzguAkTM2wodsTQYFHdpx8eqRJ3N+9pY=\ngithub.com/bkielbasa/cyclop v1.2.1 h1:AeF71HZDob1P2/pRm1so9cd1alZnrpyc4q2uP2l0gJY=\ngithub.com/bkielbasa/cyclop v1.2.1/go.mod h1:K/dT/M0FPAiYjBgQGau7tz+3TMh4FWAEqlMhzFWCrgM=\ngithub.com/blizzy78/varnamelen v0.8.0 h1:oqSblyuQvFsW1hbBHh1zfwrKe3kcSj0rnXkKzsQ089M=\ngithub.com/blizzy78/varnamelen v0.8.0/go.mod h1:V9TzQZ4fLJ1DSrjVDfl89H7aMnTvKkApdHeyESmyR7k=\ngithub.com/bombsimon/wsl/v4 v4.4.1 h1:jfUaCkN+aUpobrMO24zwyAMwMAV5eSziCkOKEauOLdw=\ngithub.com/bombsimon/wsl/v4 v4.4.1/go.mod h1:Xu/kDxGZTofQcDGCtQe9KCzhHphIe0fDuyWTxER9Feo=\ngithub.com/breml/bidichk v0.2.7 h1:dAkKQPLl/Qrk7hnP6P+E0xOodrq8Us7+U0o4UBOAlQY=\ngithub.com/breml/bidichk v0.2.7/go.mod h1:YodjipAGI9fGcYM7II6wFvGhdMYsC5pHDlGzqvEW3tQ=\ngithub.com/breml/errchkjson v0.3.6 h1:VLhVkqSBH96AvXEyclMR37rZslRrY2kcyq+31HCsVrA=\ngithub.com/breml/errchkjson v0.3.6/go.mod h1:jhSDoFheAF2RSDOlCfhHO9KqhZgAYLyvHe7bRCX8f/U=\ngithub.com/butuzov/ireturn v0.3.0 h1:hTjMqWw3y5JC3kpnC5vXmFJAWI/m31jaCYQqzkS6PL0=\ngithub.com/butuzov/ireturn v0.3.0/go.mod h1:A09nIiwiqzN/IoVo9ogpa0Hzi9fex1kd9PSD6edP5ZA=\ngithub.com/butuzov/mirror v1.2.0 h1:9YVK1qIjNspaqWutSv8gsge2e/Xpq1eqEkslEUHy5cs=\ngithub.com/butuzov/mirror v1.2.0/go.mod h1:DqZZDtzm42wIAIyHXeN8W/qb1EPlb9Qn/if9icBOpdQ=\ngithub.com/catenacyber/perfsprint v0.7.1 h1:PGW5G/Kxn+YrN04cRAZKC+ZuvlVwolYMrIyyTJ/rMmc=\ngithub.com/catenacyber/perfsprint v0.7.1/go.mod h1:/wclWYompEyjUD2FuIIDVKNkqz7IgBIWXIH3V0Zol50=\ngithub.com/ccojocar/zxcvbn-go v1.0.2 h1:na/czXU8RrhXO4EZme6eQJLR4PzcGsahsBOAwU6I3Vg=\ngithub.com/ccojocar/zxcvbn-go v1.0.2/go.mod h1:g1qkXtUSvHP8lhHp5GrSmTz6uWALGRMQdw6Qnz/hi60=\ngithub.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=\ngithub.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=\ngithub.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=\ngithub.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=\ngithub.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=\ngithub.com/charithe/durationcheck v0.0.10 h1:wgw73BiocdBDQPik+zcEoBG/ob8uyBHf2iyoHGPf5w4=\ngithub.com/charithe/durationcheck v0.0.10/go.mod h1:bCWXb7gYRysD1CU3C+u4ceO49LoGOY1C1L6uouGNreQ=\ngithub.com/chavacava/garif v0.1.0 h1:2JHa3hbYf5D9dsgseMKAmc/MZ109otzgNFk5s87H9Pc=\ngithub.com/chavacava/garif v0.1.0/go.mod h1:XMyYCkEL58DF0oyW4qDjjnPWONs2HBqYKI+UIPD+Gww=\ngithub.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=\ngithub.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=\ngithub.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=\ngithub.com/ckaznocha/intrange v0.1.2 h1:3Y4JAxcMntgb/wABQ6e8Q8leMd26JbX2790lIss9MTI=\ngithub.com/ckaznocha/intrange v0.1.2/go.mod h1:RWffCw/vKBwHeOEwWdCikAtY0q4gGt8VhJZEEA5n+RE=\ngithub.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=\ngithub.com/cloudflare/circl v1.3.7 h1:qlCDlTPz2n9fu58M0Nh1J/JzcFpfgkFHHX3O35r5vcU=\ngithub.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBSc8r4zxgA=\ngithub.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=\ngithub.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=\ngithub.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=\ngithub.com/creack/pty v1.1.21 h1:1/QdRyBaHHJP61QkWMXlOIBfsgdDeeKfK8SYVUWJKf0=\ngithub.com/creack/pty v1.1.21/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=\ngithub.com/curioswitch/go-reassign v0.2.0 h1:G9UZyOcpk/d7Gd6mqYgd8XYWFMw/znxwGDUstnC9DIo=\ngithub.com/curioswitch/go-reassign v0.2.0/go.mod h1:x6OpXuWvgfQaMGks2BZybTngWjT84hqJfKoO8Tt/Roc=\ngithub.com/cyphar/filepath-securejoin v0.2.5 h1:6iR5tXJ/e6tJZzzdMc1km3Sa7RRIVBKAK32O2s7AYfo=\ngithub.com/cyphar/filepath-securejoin v0.2.5/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4=\ngithub.com/daixiang0/gci v0.13.4 h1:61UGkmpoAcxHM2hhNkZEf5SzwQtWJXTSws7jaPyqwlw=\ngithub.com/daixiang0/gci v0.13.4/go.mod h1:12etP2OniiIdP4q+kjUGrC/rUagga7ODbqsom5Eo5Yk=\ngithub.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=\ngithub.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=\ngithub.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=\ngithub.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=\ngithub.com/denis-tingaikin/go-header v0.5.0 h1:SRdnP5ZKvcO9KKRP1KJrhFR3RrlGuD+42t4429eC9k8=\ngithub.com/denis-tingaikin/go-header v0.5.0/go.mod h1:mMenU5bWrok6Wl2UsZjy+1okegmwQ3UgWl4V1D8gjlY=\ngithub.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=\ngithub.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=\ngithub.com/dnephin/pflag v1.0.7 h1:oxONGlWxhmUct0YzKTgrpQv9AUA1wtPBn7zuSjJqptk=\ngithub.com/dnephin/pflag v1.0.7/go.mod h1:uxE91IoWURlOiTUIA8Mq5ZZkAv3dPUfZNaT80Zm7OQE=\ngithub.com/dominikbraun/graph v0.23.0 h1:TdZB4pPqCLFxYhdyMFb1TBdFxp8XLcJfTTBQucVPgCo=\ngithub.com/dominikbraun/graph v0.23.0/go.mod h1:yOjYyogZLY1LSG9E33JWZJiq5k83Qy2C6POAuiViluc=\ngithub.com/elazarl/goproxy v1.2.1 h1:njjgvO6cRG9rIqN2ebkqy6cQz2Njkx7Fsfv/zIZqgug=\ngithub.com/elazarl/goproxy v1.2.1/go.mod h1:YfEbZtqP4AetfO6d40vWchF3znWX7C7Vd6ZMfdL8z64=\ngithub.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=\ngithub.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=\ngithub.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=\ngithub.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=\ngithub.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=\ngithub.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=\ngithub.com/ettle/strcase v0.2.0 h1:fGNiVF21fHXpX1niBgk0aROov1LagYsOwV/xqKDKR/Q=\ngithub.com/ettle/strcase v0.2.0/go.mod h1:DajmHElDSaX76ITe3/VHVyMin4LWSJN5Z909Wp+ED1A=\ngithub.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw=\ngithub.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=\ngithub.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=\ngithub.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4=\ngithub.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94=\ngithub.com/firefart/nonamedreturns v1.0.5 h1:tM+Me2ZaXs8tfdDw3X6DOX++wMCOqzYUho6tUTYIdRA=\ngithub.com/firefart/nonamedreturns v1.0.5/go.mod h1:gHJjDqhGM4WyPt639SOZs+G89Ko7QKH5R5BhnO6xJhw=\ngithub.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=\ngithub.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=\ngithub.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=\ngithub.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=\ngithub.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=\ngithub.com/fzipp/gocyclo v0.6.0 h1:lsblElZG7d3ALtGMx9fmxeTKZaLLpU8mET09yN4BBLo=\ngithub.com/fzipp/gocyclo v0.6.0/go.mod h1:rXPyn8fnlpa0R2csP/31uerbiVBugk5whMdlyaLkLoA=\ngithub.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=\ngithub.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=\ngithub.com/ghostiam/protogetter v0.3.6 h1:R7qEWaSgFCsy20yYHNIJsU9ZOb8TziSRRxuAOTVKeOk=\ngithub.com/ghostiam/protogetter v0.3.6/go.mod h1:7lpeDnEJ1ZjL/YtyoN99ljO4z0pd3H0d18/t2dPBxHw=\ngithub.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=\ngithub.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=\ngithub.com/go-critic/go-critic v0.11.4 h1:O7kGOCx0NDIni4czrkRIXTnit0mkyKOCePh3My6OyEU=\ngithub.com/go-critic/go-critic v0.11.4/go.mod h1:2QAdo4iuLik5S9YG0rT4wcZ8QxwHYkrr6/2MWAiv/vc=\ngithub.com/go-errors/errors v1.5.1 h1:ZwEMSLRCapFLflTpT7NKaAc7ukJ8ZPEjzlxt8rPN8bk=\ngithub.com/go-errors/errors v1.5.1/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=\ngithub.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=\ngithub.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=\ngithub.com/go-git/go-billy/v5 v5.6.0 h1:w2hPNtoehvJIxR00Vb4xX94qHQi/ApZfX+nBE2Cjio8=\ngithub.com/go-git/go-billy/v5 v5.6.0/go.mod h1:sFDq7xD3fn3E0GOwUSZqHo9lrkmx8xJhA0ZrfvjBRGM=\ngithub.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=\ngithub.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=\ngithub.com/go-git/go-git/v5 v5.13.0 h1:vLn5wlGIh/X78El6r3Jr+30W16Blk0CTcxTYcYPWi5E=\ngithub.com/go-git/go-git/v5 v5.13.0/go.mod h1:Wjo7/JyVKtQgUNdXYXIepzWfJQkUEIGvkvVkiXRR/zw=\ngithub.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=\ngithub.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=\ngithub.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=\ngithub.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=\ngithub.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=\ngithub.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=\ngithub.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=\ngithub.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=\ngithub.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=\ngithub.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=\ngithub.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=\ngithub.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=\ngithub.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=\ngithub.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=\ngithub.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=\ngithub.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=\ngithub.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=\ngithub.com/go-playground/validator/v10 v10.23.0 h1:/PwmTwZhS0dPkav3cdK9kV1FsAmrL8sThn8IHr/sO+o=\ngithub.com/go-playground/validator/v10 v10.23.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=\ngithub.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=\ngithub.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=\ngithub.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=\ngithub.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=\ngithub.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=\ngithub.com/go-task/task/v3 v3.38.0 h1:O7kgA6BfwktXHPrheByQO46p3teKtRuq1EpGnFxNzbo=\ngithub.com/go-task/task/v3 v3.38.0/go.mod h1:UzLDHoXTKNAtWwFP3WVsfMhlSw3K8i9KNzEO9kCHix8=\ngithub.com/go-task/template v0.0.0-20240602015157-960e6f576656 h1:knZZ4zVdTBQnevBz0zSES++4Mr7wr+cHopLvHabIgkA=\ngithub.com/go-task/template v0.0.0-20240602015157-960e6f576656/go.mod h1:RgwRaZK+kni/hJJ7/AaOE2lPQFPbAdji/DyhC6pxo4k=\ngithub.com/go-toolsmith/astcast v1.1.0 h1:+JN9xZV1A+Re+95pgnMgDboWNVnIMMQXwfBwLRPgSC8=\ngithub.com/go-toolsmith/astcast v1.1.0/go.mod h1:qdcuFWeGGS2xX5bLM/c3U9lewg7+Zu4mr+xPwZIB4ZU=\ngithub.com/go-toolsmith/astcopy v1.1.0 h1:YGwBN0WM+ekI/6SS6+52zLDEf8Yvp3n2seZITCUBt5s=\ngithub.com/go-toolsmith/astcopy v1.1.0/go.mod h1:hXM6gan18VA1T/daUEHCFcYiW8Ai1tIwIzHY6srfEAw=\ngithub.com/go-toolsmith/astequal v1.0.3/go.mod h1:9Ai4UglvtR+4up+bAD4+hCj7iTo4m/OXVTSLnCyTAx4=\ngithub.com/go-toolsmith/astequal v1.1.0/go.mod h1:sedf7VIdCL22LD8qIvv7Nn9MuWJruQA/ysswh64lffQ=\ngithub.com/go-toolsmith/astequal v1.2.0 h1:3Fs3CYZ1k9Vo4FzFhwwewC3CHISHDnVUPC4x0bI2+Cw=\ngithub.com/go-toolsmith/astequal v1.2.0/go.mod h1:c8NZ3+kSFtFY/8lPso4v8LuJjdJiUFVnSuU3s0qrrDY=\ngithub.com/go-toolsmith/astfmt v1.1.0 h1:iJVPDPp6/7AaeLJEruMsBUlOYCmvg0MoCfJprsOmcco=\ngithub.com/go-toolsmith/astfmt v1.1.0/go.mod h1:OrcLlRwu0CuiIBp/8b5PYF9ktGVZUjlNMV634mhwuQ4=\ngithub.com/go-toolsmith/astp v1.1.0 h1:dXPuCl6u2llURjdPLLDxJeZInAeZ0/eZwFJmqZMnpQA=\ngithub.com/go-toolsmith/astp v1.1.0/go.mod h1:0T1xFGz9hicKs8Z5MfAqSUitoUYS30pDMsRVIDHs8CA=\ngithub.com/go-toolsmith/pkgload v1.2.2 h1:0CtmHq/02QhxcF7E9N5LIFcYFsMR5rdovfqTtRKkgIk=\ngithub.com/go-toolsmith/pkgload v1.2.2/go.mod h1:R2hxLNRKuAsiXCo2i5J6ZQPhnPMOVtU+f0arbFPWCus=\ngithub.com/go-toolsmith/strparse v1.0.0/go.mod h1:YI2nUKP9YGZnL/L1/DLFBfixrcjslWct4wyljWhSRy8=\ngithub.com/go-toolsmith/strparse v1.1.0 h1:GAioeZUK9TGxnLS+qfdqNbA4z0SSm5zVNtCQiyP2Bvw=\ngithub.com/go-toolsmith/strparse v1.1.0/go.mod h1:7ksGy58fsaQkGQlY8WVoBFNyEPMGuJin1rfoPS4lBSQ=\ngithub.com/go-toolsmith/typep v1.1.0 h1:fIRYDyF+JywLfqzyhdiHzRop/GQDxxNhLGQ6gFUNHus=\ngithub.com/go-toolsmith/typep v1.1.0/go.mod h1:fVIw+7zjdsMxDA3ITWnH1yOiw1rnTQKCsF/sk2H/qig=\ngithub.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=\ngithub.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=\ngithub.com/go-xmlfmt/xmlfmt v1.1.2 h1:Nea7b4icn8s57fTx1M5AI4qQT5HEM3rVUO8MuE6g80U=\ngithub.com/go-xmlfmt/xmlfmt v1.1.2/go.mod h1:aUCEOzzezBEjDBbFBoSiya/gduyIiWYRP6CnSFIV8AM=\ngithub.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=\ngithub.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=\ngithub.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=\ngithub.com/gofrs/flock v0.12.1 h1:MTLVXXHf8ekldpJk3AKicLij9MdwOWkZ+a/jHHZby9E=\ngithub.com/gofrs/flock v0.12.1/go.mod h1:9zxTsyu5xtJ9DK+1tFZyibEV7y3uwDxPPfbxeeHCoD0=\ngithub.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=\ngithub.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=\ngithub.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=\ngithub.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=\ngithub.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=\ngithub.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=\ngithub.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=\ngithub.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=\ngithub.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=\ngithub.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=\ngithub.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=\ngithub.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=\ngithub.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=\ngithub.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=\ngithub.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=\ngithub.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=\ngithub.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=\ngithub.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=\ngithub.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=\ngithub.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=\ngithub.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=\ngithub.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=\ngithub.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=\ngithub.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=\ngithub.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=\ngithub.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=\ngithub.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=\ngithub.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=\ngithub.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=\ngithub.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=\ngithub.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=\ngithub.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=\ngithub.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a h1:w8hkcTqaFpzKqonE9uMCefW1WDie15eSP/4MssdenaM=\ngithub.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a/go.mod h1:ryS0uhF+x9jgbj/N71xsEqODy9BN81/GonCZiOzirOk=\ngithub.com/golangci/gofmt v0.0.0-20240816233607-d8596aa466a9 h1:/1322Qns6BtQxUZDTAT4SdcoxknUki7IAoK4SAXr8ME=\ngithub.com/golangci/gofmt v0.0.0-20240816233607-d8596aa466a9/go.mod h1:Oesb/0uFAyWoaw1U1qS5zyjCg5NP9C9iwjnI4tIsXEE=\ngithub.com/golangci/golangci-lint v1.60.3 h1:l38A5de24ZeDlcFF+EB7m3W5joPD99/hS5SIHJPyZa0=\ngithub.com/golangci/golangci-lint v1.60.3/go.mod h1:J4vOpcjzRI+lDL2DKNGBZVB3EQSBfCBCMpaydWLtJNo=\ngithub.com/golangci/misspell v0.6.0 h1:JCle2HUTNWirNlDIAUO44hUsKhOFqGPoC4LZxlaSXDs=\ngithub.com/golangci/misspell v0.6.0/go.mod h1:keMNyY6R9isGaSAu+4Q8NMBwMPkh15Gtc8UCVoDtAWo=\ngithub.com/golangci/modinfo v0.3.4 h1:oU5huX3fbxqQXdfspamej74DFX0kyGLkw1ppvXoJ8GA=\ngithub.com/golangci/modinfo v0.3.4/go.mod h1:wytF1M5xl9u0ij8YSvhkEVPP3M5Mc7XLl1pxH3B2aUM=\ngithub.com/golangci/plugin-module-register v0.1.1 h1:TCmesur25LnyJkpsVrupv1Cdzo+2f7zX0H6Jkw1Ol6c=\ngithub.com/golangci/plugin-module-register v0.1.1/go.mod h1:TTpqoB6KkwOJMV8u7+NyXMrkwwESJLOkfl9TxR1DGFc=\ngithub.com/golangci/revgrep v0.5.3 h1:3tL7c1XBMtWHHqVpS5ChmiAAoe4PF/d5+ULzV9sLAzs=\ngithub.com/golangci/revgrep v0.5.3/go.mod h1:U4R/s9dlXZsg8uJmaR1GrloUr14D7qDl8gi2iPXJH8k=\ngithub.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed h1:IURFTjxeTfNFP0hTEi1YKjB/ub8zkpaOqFFMApi2EAs=\ngithub.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed/go.mod h1:XLXN8bNw4CGRPaqgl3bv/lhz7bsGPh4/xSaMTbo2vkQ=\ngithub.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=\ngithub.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=\ngithub.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=\ngithub.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=\ngithub.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=\ngithub.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=\ngithub.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=\ngithub.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=\ngithub.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=\ngithub.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=\ngithub.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=\ngithub.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=\ngithub.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=\ngithub.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=\ngithub.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=\ngithub.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=\ngithub.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=\ngithub.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=\ngithub.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=\ngithub.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=\ngithub.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=\ngithub.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=\ngithub.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=\ngithub.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=\ngithub.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=\ngithub.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=\ngithub.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=\ngithub.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8 h1:FKHo8hFI3A+7w0aUQuYXQ+6EN5stWmeY/AZqtM8xk9k=\ngithub.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo=\ngithub.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=\ngithub.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=\ngithub.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ=\ngithub.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=\ngithub.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=\ngithub.com/gordonklaus/ineffassign v0.1.0 h1:y2Gd/9I7MdY1oEIt+n+rowjBNDcLQq3RsH5hwJd0f9s=\ngithub.com/gordonklaus/ineffassign v0.1.0/go.mod h1:Qcp2HIAYhR7mNUVSIxZww3Guk4it82ghYcEXIAk+QT0=\ngithub.com/gostaticanalysis/analysisutil v0.7.1 h1:ZMCjoue3DtDWQ5WyU16YbjbQEQ3VuzwxALrpYd+HeKk=\ngithub.com/gostaticanalysis/analysisutil v0.7.1/go.mod h1:v21E3hY37WKMGSnbsw2S/ojApNWb6C1//mXO48CXbVc=\ngithub.com/gostaticanalysis/comment v1.4.1/go.mod h1:ih6ZxzTHLdadaiSnF5WY3dxUoXfXAlTaRzuaNDlSado=\ngithub.com/gostaticanalysis/comment v1.4.2 h1:hlnx5+S2fY9Zo9ePo4AhgYsYHbM2+eAv8m/s1JiCd6Q=\ngithub.com/gostaticanalysis/comment v1.4.2/go.mod h1:KLUTGDv6HOCotCH8h2erHKmpci2ZoR8VPu34YA2uzdM=\ngithub.com/gostaticanalysis/forcetypeassert v0.1.0 h1:6eUflI3DiGusXGK6X7cCcIgVCpZ2CiZ1Q7jl6ZxNV70=\ngithub.com/gostaticanalysis/forcetypeassert v0.1.0/go.mod h1:qZEedyP/sY1lTGV1uJ3VhWZ2mqag3IkWsDHVbplHXak=\ngithub.com/gostaticanalysis/nilerr v0.1.1 h1:ThE+hJP0fEp4zWLkWHWcRyI2Od0p7DlgYG3Uqrmrcpk=\ngithub.com/gostaticanalysis/nilerr v0.1.1/go.mod h1:wZYb6YI5YAxxq0i1+VJbY0s2YONW0HU0GPE3+5PWN4A=\ngithub.com/gostaticanalysis/testutil v0.3.1-0.20210208050101-bfb5c8eec0e4/go.mod h1:D+FIZ+7OahH3ePw/izIEeH5I06eKs1IKI4Xr64/Am3M=\ngithub.com/gostaticanalysis/testutil v0.4.0 h1:nhdCmubdmDF6VEatUNjgUZBJKWRqugoISdUv3PPQgHY=\ngithub.com/gostaticanalysis/testutil v0.4.0/go.mod h1:bLIoPefWXrRi/ssLFWX1dx7Repi5x3CuviD3dgAZaBU=\ngithub.com/hashicorp/go-version v1.2.1/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=\ngithub.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=\ngithub.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=\ngithub.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=\ngithub.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=\ngithub.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=\ngithub.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=\ngithub.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=\ngithub.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=\ngithub.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=\ngithub.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=\ngithub.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=\ngithub.com/jgautheron/goconst v1.7.1 h1:VpdAG7Ca7yvvJk5n8dMwQhfEZJh95kl/Hl9S1OI5Jkk=\ngithub.com/jgautheron/goconst v1.7.1/go.mod h1:aAosetZ5zaeC/2EfMeRswtxUFBpe2Hr7HzkgX4fanO4=\ngithub.com/jingyugao/rowserrcheck v1.1.1 h1:zibz55j/MJtLsjP1OF4bSdgXxwL1b+Vn7Tjzq7gFzUs=\ngithub.com/jingyugao/rowserrcheck v1.1.1/go.mod h1:4yvlZSDb3IyDTUZJUmpZfm2Hwok+Dtp+nu2qOq+er9c=\ngithub.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af h1:KA9BjwUk7KlCh6S9EAGWBt1oExIUv9WyNCiRz5amv48=\ngithub.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af/go.mod h1:HEWGJkRDzjJY2sqdDwxccsGicWEf9BQOZsq2tV+xzM0=\ngithub.com/jjti/go-spancheck v0.6.2 h1:iYtoxqPMzHUPp7St+5yA8+cONdyXD3ug6KK15n7Pklk=\ngithub.com/jjti/go-spancheck v0.6.2/go.mod h1:+X7lvIrR5ZdUTkxFYqzJ0abr8Sb5LOo80uOhWNqIrYA=\ngithub.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=\ngithub.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=\ngithub.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=\ngithub.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=\ngithub.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=\ngithub.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=\ngithub.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=\ngithub.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=\ngithub.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=\ngithub.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=\ngithub.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=\ngithub.com/julz/importas v0.1.0 h1:F78HnrsjY3cR7j0etXy5+TU1Zuy7Xt08X/1aJnH5xXY=\ngithub.com/julz/importas v0.1.0/go.mod h1:oSFU2R4XK/P7kNBrnL/FEQlDGN1/6WoxXEjSSXO0DV0=\ngithub.com/karamaru-alpha/copyloopvar v1.1.0 h1:x7gNyKcC2vRBO1H2Mks5u1VxQtYvFiym7fCjIP8RPos=\ngithub.com/karamaru-alpha/copyloopvar v1.1.0/go.mod h1:u7CIfztblY0jZLOQZgH3oYsJzpC2A7S6u/lfgSXHy0k=\ngithub.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=\ngithub.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=\ngithub.com/kisielk/errcheck v1.7.0 h1:+SbscKmWJ5mOK/bO1zS60F5I9WwZDWOfRsC4RwfwRV0=\ngithub.com/kisielk/errcheck v1.7.0/go.mod h1:1kLL+jV4e+CFfueBmI1dSK2ADDyQnlrnrY/FqKluHJQ=\ngithub.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=\ngithub.com/kkHAIKE/contextcheck v1.1.5 h1:CdnJh63tcDe53vG+RebdpdXJTc9atMgGqdx8LXxiilg=\ngithub.com/kkHAIKE/contextcheck v1.1.5/go.mod h1:O930cpht4xb1YQpK+1+AgoM3mFsvxr7uyFptcnWTYUA=\ngithub.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=\ngithub.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=\ngithub.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=\ngithub.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=\ngithub.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=\ngithub.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=\ngithub.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=\ngithub.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=\ngithub.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=\ngithub.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=\ngithub.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=\ngithub.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=\ngithub.com/kulti/thelper v0.6.3 h1:ElhKf+AlItIu+xGnI990no4cE2+XaSu1ULymV2Yulxs=\ngithub.com/kulti/thelper v0.6.3/go.mod h1:DsqKShOvP40epevkFrvIwkCMNYxMeTNjdWL4dqWHZ6I=\ngithub.com/kunwardeep/paralleltest v1.0.10 h1:wrodoaKYzS2mdNVnc4/w31YaXFtsc21PCTdvWJ/lDDs=\ngithub.com/kunwardeep/paralleltest v1.0.10/go.mod h1:2C7s65hONVqY7Q5Efj5aLzRCNLjw2h4eMc9EcypGjcY=\ngithub.com/kyoh86/exportloopref v0.1.11 h1:1Z0bcmTypkL3Q4k+IDHMWTcnCliEZcaPiIe0/ymEyhQ=\ngithub.com/kyoh86/exportloopref v0.1.11/go.mod h1:qkV4UF1zGl6EkF1ox8L5t9SwyeBAZ3qLMd6up458uqA=\ngithub.com/lasiar/canonicalheader v1.1.1 h1:wC+dY9ZfiqiPwAexUApFush/csSPXeIi4QqyxXmng8I=\ngithub.com/lasiar/canonicalheader v1.1.1/go.mod h1:cXkb3Dlk6XXy+8MVQnF23CYKWlyA7kfQhSw2CcZtZb0=\ngithub.com/ldez/gomoddirectives v0.2.4 h1:j3YjBIjEBbqZ0NKtBNzr8rtMHTOrLPeiwTkfUJZ3alg=\ngithub.com/ldez/gomoddirectives v0.2.4/go.mod h1:oWu9i62VcQDYp9EQ0ONTfqLNh+mDLWWDO+SO0qSQw5g=\ngithub.com/ldez/tagliatelle v0.5.0 h1:epgfuYt9v0CG3fms0pEgIMNPuFf/LpPIfjk4kyqSioo=\ngithub.com/ldez/tagliatelle v0.5.0/go.mod h1:rj1HmWiL1MiKQuOONhd09iySTEkUuE/8+5jtPYz9xa4=\ngithub.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=\ngithub.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=\ngithub.com/leonklingele/grouper v1.1.2 h1:o1ARBDLOmmasUaNDesWqWCIFH3u7hoFlM84YrjT3mIY=\ngithub.com/leonklingele/grouper v1.1.2/go.mod h1:6D0M/HVkhs2yRKRFZUoGjeDy7EZTfFBE9gl4kjmIGkA=\ngithub.com/lufeee/execinquery v1.2.1 h1:hf0Ems4SHcUGBxpGN7Jz78z1ppVkP/837ZlETPCEtOM=\ngithub.com/lufeee/execinquery v1.2.1/go.mod h1:EC7DrEKView09ocscGHC+apXMIaorh4xqSxS/dy8SbM=\ngithub.com/macabu/inamedparam v0.1.3 h1:2tk/phHkMlEL/1GNe/Yf6kkR/hkcUdAEY3L0hjYV1Mk=\ngithub.com/macabu/inamedparam v0.1.3/go.mod h1:93FLICAIk/quk7eaPPQvbzihUdn/QkGDwIZEoLtpH6I=\ngithub.com/maratori/testableexamples v1.0.0 h1:dU5alXRrD8WKSjOUnmJZuzdxWOEQ57+7s93SLMxb2vI=\ngithub.com/maratori/testableexamples v1.0.0/go.mod h1:4rhjL1n20TUTT4vdh3RDqSizKLyXp7K2u6HgraZCGzE=\ngithub.com/maratori/testpackage v1.1.1 h1:S58XVV5AD7HADMmD0fNnziNHqKvSdDuEKdPD1rNTU04=\ngithub.com/maratori/testpackage v1.1.1/go.mod h1:s4gRK/ym6AMrqpOa/kEbQTV4Q4jb7WeLZzVhVVVOQMc=\ngithub.com/matoous/godox v0.0.0-20230222163458-006bad1f9d26 h1:gWg6ZQ4JhDfJPqlo2srm/LN17lpybq15AryXIRcWYLE=\ngithub.com/matoous/godox v0.0.0-20230222163458-006bad1f9d26/go.mod h1:1BELzlh859Sh1c6+90blK8lbYy0kwQf1bYlBhBysy1s=\ngithub.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE=\ngithub.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=\ngithub.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=\ngithub.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=\ngithub.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=\ngithub.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=\ngithub.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=\ngithub.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=\ngithub.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=\ngithub.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=\ngithub.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=\ngithub.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=\ngithub.com/mattn/go-zglob v0.0.4 h1:LQi2iOm0/fGgu80AioIJ/1j9w9Oh+9DZ39J4VAGzHQM=\ngithub.com/mattn/go-zglob v0.0.4/go.mod h1:MxxjyoXXnMxfIpxTK2GAkw1w8glPsQILx3N5wrKakiY=\ngithub.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=\ngithub.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=\ngithub.com/mgechev/revive v1.3.9 h1:18Y3R4a2USSBF+QZKFQwVkBROUda7uoBlkEuBD+YD1A=\ngithub.com/mgechev/revive v1.3.9/go.mod h1:+uxEIr5UH0TjXWHTno3xh4u7eg6jDpXKzQccA9UGhHU=\ngithub.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=\ngithub.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=\ngithub.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=\ngithub.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=\ngithub.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=\ngithub.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=\ngithub.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=\ngithub.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=\ngithub.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=\ngithub.com/moricho/tparallel v0.3.2 h1:odr8aZVFA3NZrNybggMkYO3rgPRcqjeQUlBBFVxKHTI=\ngithub.com/moricho/tparallel v0.3.2/go.mod h1:OQ+K3b4Ln3l2TZveGCywybl68glfLEwFGqvnjok8b+U=\ngithub.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=\ngithub.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=\ngithub.com/nakabonne/nestif v0.3.1 h1:wm28nZjhQY5HyYPx+weN3Q65k6ilSBxDb8v5S81B81U=\ngithub.com/nakabonne/nestif v0.3.1/go.mod h1:9EtoZochLn5iUprVDmDjqGKPofoUEBL8U4Ngq6aY7OE=\ngithub.com/nishanths/exhaustive v0.12.0 h1:vIY9sALmw6T/yxiASewa4TQcFsVYZQQRUQJhKRf3Swg=\ngithub.com/nishanths/exhaustive v0.12.0/go.mod h1:mEZ95wPIZW+x8kC4TgC+9YCUgiST7ecevsVDTgc2obs=\ngithub.com/nishanths/predeclared v0.2.2 h1:V2EPdZPliZymNAn79T8RkNApBjMmVKh5XRpLm/w98Vk=\ngithub.com/nishanths/predeclared v0.2.2/go.mod h1:RROzoN6TnGQupbC+lqggsOlcgysk3LMK/HI84Mp280c=\ngithub.com/nunnatsa/ginkgolinter v0.16.2 h1:8iLqHIZvN4fTLDC0Ke9tbSZVcyVHoBs0HIbnVSxfHJk=\ngithub.com/nunnatsa/ginkgolinter v0.16.2/go.mod h1:4tWRinDN1FeJgU+iJANW/kz7xKN5nYRAOfJDQUS9dOQ=\ngithub.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=\ngithub.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=\ngithub.com/onsi/ginkgo/v2 v2.20.0 h1:PE84V2mHqoT1sglvHc8ZdQtPcwmvvt29WLEEO3xmdZw=\ngithub.com/onsi/ginkgo/v2 v2.20.0/go.mod h1:lG9ey2Z29hR41WMVthyJBGUBcBhGOtoPF2VFMvBXFCI=\ngithub.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=\ngithub.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=\ngithub.com/otiai10/copy v1.2.0/go.mod h1:rrF5dJ5F0t/EWSYODDu4j9/vEeYHMkc8jt0zJChqQWw=\ngithub.com/otiai10/copy v1.14.0 h1:dCI/t1iTdYGtkvCuBG2BgR6KZa83PTclw4U5n2wAllU=\ngithub.com/otiai10/copy v1.14.0/go.mod h1:ECfuL02W+/FkTWZWgQqXPWZgW9oeKCSQ5qVfSc4qc4w=\ngithub.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE=\ngithub.com/otiai10/curr v1.0.0/go.mod h1:LskTG5wDwr8Rs+nNQ+1LlxRjAtTZZjtJW4rMXl6j4vs=\ngithub.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo=\ngithub.com/otiai10/mint v1.3.1/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc=\ngithub.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=\ngithub.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=\ngithub.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4=\ngithub.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI=\ngithub.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=\ngithub.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=\ngithub.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=\ngithub.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=\ngithub.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=\ngithub.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=\ngithub.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=\ngithub.com/polyfloyd/go-errorlint v1.6.0 h1:tftWV9DE7txiFzPpztTAwyoRLKNj9gpVm2cg8/OwcYY=\ngithub.com/polyfloyd/go-errorlint v1.6.0/go.mod h1:HR7u8wuP1kb1NeN1zqTd1ZMlqUKPPHF+Id4vIPvDqVw=\ngithub.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g=\ngithub.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=\ngithub.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=\ngithub.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=\ngithub.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=\ngithub.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=\ngithub.com/prometheus/client_golang v1.12.1 h1:ZiaPsmm9uiBeaSMRznKsCDNtPCS0T3JVDGF+06gjBzk=\ngithub.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=\ngithub.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=\ngithub.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=\ngithub.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=\ngithub.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=\ngithub.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=\ngithub.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=\ngithub.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=\ngithub.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=\ngithub.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4=\ngithub.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=\ngithub.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=\ngithub.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=\ngithub.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=\ngithub.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=\ngithub.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU=\ngithub.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=\ngithub.com/quasilyte/go-ruleguard v0.4.2 h1:htXcXDK6/rO12kiTHKfHuqR4kr3Y4M0J0rOL6CH/BYs=\ngithub.com/quasilyte/go-ruleguard v0.4.2/go.mod h1:GJLgqsLeo4qgavUoL8JeGFNS7qcisx3awV/w9eWTmNI=\ngithub.com/quasilyte/go-ruleguard/dsl v0.3.22 h1:wd8zkOhSNr+I+8Qeciml08ivDt1pSXe60+5DqOpCjPE=\ngithub.com/quasilyte/go-ruleguard/dsl v0.3.22/go.mod h1:KeCP03KrjuSO0H1kTuZQCWlQPulDV6YMIXmpQss17rU=\ngithub.com/quasilyte/gogrep v0.5.0 h1:eTKODPXbI8ffJMN+W2aE0+oL0z/nh8/5eNdiO34SOAo=\ngithub.com/quasilyte/gogrep v0.5.0/go.mod h1:Cm9lpz9NZjEoL1tgZ2OgeUKPIxL1meE7eo60Z6Sk+Ng=\ngithub.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727 h1:TCg2WBOl980XxGFEZSS6KlBGIV0diGdySzxATTWoqaU=\ngithub.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727/go.mod h1:rlzQ04UMyJXu/aOvhd8qT+hvDrFpiwqp8MRXDY9szc0=\ngithub.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567 h1:M8mH9eK4OUR4lu7Gd+PU1fV2/qnDNfzT635KRSObncs=\ngithub.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567/go.mod h1:DWNGW8A4Y+GyBgPuaQJuWiy0XYftx4Xm/y5Jqk9I6VQ=\ngithub.com/radovskyb/watcher v1.0.7 h1:AYePLih6dpmS32vlHfhCeli8127LzkIgwJGcwwe8tUE=\ngithub.com/radovskyb/watcher v1.0.7/go.mod h1:78okwvY5wPdzcb1UYnip1pvrZNIVEIh/Cm+ZuvsUYIg=\ngithub.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=\ngithub.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=\ngithub.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=\ngithub.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=\ngithub.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=\ngithub.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=\ngithub.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=\ngithub.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=\ngithub.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=\ngithub.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=\ngithub.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=\ngithub.com/ryancurrah/gomodguard v1.3.3 h1:eiSQdJVNr9KTNxY2Niij8UReSwR8Xrte3exBrAZfqpg=\ngithub.com/ryancurrah/gomodguard v1.3.3/go.mod h1:rsKQjj4l3LXe8N344Ow7agAy5p9yjsWOtRzUMYmA0QY=\ngithub.com/ryanrolds/sqlclosecheck v0.5.1 h1:dibWW826u0P8jNLsLN+En7+RqWWTYrjCB9fJfSfdyCU=\ngithub.com/ryanrolds/sqlclosecheck v0.5.1/go.mod h1:2g3dUjoS6AL4huFdv6wn55WpLIDjY7ZgUR4J8HOO/XQ=\ngithub.com/sagikazarmark/locafero v0.9.0 h1:GbgQGNtTrEmddYDSAH9QLRyfAHY12md+8YFTqyMTC9k=\ngithub.com/sagikazarmark/locafero v0.9.0/go.mod h1:UBUyz37V+EdMS3hDF3QWIiVr/2dPrx49OMO0Bn0hJqk=\ngithub.com/sajari/fuzzy v1.0.0 h1:+FmwVvJErsd0d0hAPlj4CxqxUtQY/fOoY0DwX4ykpRY=\ngithub.com/sajari/fuzzy v1.0.0/go.mod h1:OjYR6KxoWOe9+dOlXeiCJd4dIbED4Oo8wpS89o0pwOo=\ngithub.com/sanposhiho/wastedassign/v2 v2.0.7 h1:J+6nrY4VW+gC9xFzUc+XjPD3g3wF3je/NsJFwFK7Uxc=\ngithub.com/sanposhiho/wastedassign/v2 v2.0.7/go.mod h1:KyZ0MWTwxxBmfwn33zh3k1dmsbF2ud9pAAGfoLfjhtI=\ngithub.com/santhosh-tekuri/jsonschema/v5 v5.3.1 h1:lZUw3E0/J3roVtGQ+SCrUrg3ON6NgVqpn3+iol9aGu4=\ngithub.com/santhosh-tekuri/jsonschema/v5 v5.3.1/go.mod h1:uToXkOrWAZ6/Oc07xWQrPOhJotwFIyu2bBVN41fcDUY=\ngithub.com/sashamelentyev/interfacebloat v1.1.0 h1:xdRdJp0irL086OyW1H/RTZTr1h/tMEOsumirXcOJqAw=\ngithub.com/sashamelentyev/interfacebloat v1.1.0/go.mod h1:+Y9yU5YdTkrNvoX0xHc84dxiN1iBi9+G8zZIhPVoNjQ=\ngithub.com/sashamelentyev/usestdlibvars v1.27.0 h1:t/3jZpSXtRPRf2xr0m63i32ZrusyurIGT9E5wAvXQnI=\ngithub.com/sashamelentyev/usestdlibvars v1.27.0/go.mod h1:9nl0jgOfHKWNFS43Ojw0i7aRoS4j6EBye3YBhmAIRF8=\ngithub.com/securego/gosec/v2 v2.20.1-0.20240822074752-ab3f6c1c83a0 h1:VqD4JMoqwuuCz8GZlBDsIDyE6K4YUsWJpbNtuOWHoFk=\ngithub.com/securego/gosec/v2 v2.20.1-0.20240822074752-ab3f6c1c83a0/go.mod h1:iyeMMRw8QEmueUSZ2VqmkQMiDyDcobfPnG00CV/NWdE=\ngithub.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=\ngithub.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=\ngithub.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c h1:W65qqJCIOVP4jpqPQ0YvHYKwcMEMVWIzWC5iNQQfBTU=\ngithub.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c/go.mod h1:/PevMnwAxekIXwN8qQyfc5gl2NlkB3CQlkizAbOkeBs=\ngithub.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=\ngithub.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ=\ngithub.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=\ngithub.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=\ngithub.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=\ngithub.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=\ngithub.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=\ngithub.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=\ngithub.com/sivchari/containedctx v1.0.3 h1:x+etemjbsh2fB5ewm5FeLNi5bUjK0V8n0RB+Wwfd0XE=\ngithub.com/sivchari/containedctx v1.0.3/go.mod h1:c1RDvCbnJLtH4lLcYD/GqwiBSSf4F5Qk0xld2rBqzJ4=\ngithub.com/sivchari/tenv v1.10.0 h1:g/hzMA+dBCKqGXgW8AV/1xIWhAvDrx0zFKNR48NFMg0=\ngithub.com/sivchari/tenv v1.10.0/go.mod h1:tdY24masnVoZFxYrHv/nD6Tc8FbkEtAQEEziXpyMgqY=\ngithub.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY=\ngithub.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M=\ngithub.com/sonatard/noctx v0.0.2 h1:L7Dz4De2zDQhW8S0t+KUjY0MAQJd6SgVwhzNIc4ok00=\ngithub.com/sonatard/noctx v0.0.2/go.mod h1:kzFz+CzWSjQ2OzIm46uJZoXuBpa2+0y3T36U18dWqIo=\ngithub.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=\ngithub.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=\ngithub.com/sourcegraph/go-diff v0.7.0 h1:9uLlrd5T46OXs5qpp8L/MTltk0zikUGi0sNNyCpA8G0=\ngithub.com/sourcegraph/go-diff v0.7.0/go.mod h1:iBszgVvyxdc8SFZ7gm69go2KDdt3ag071iBaWPF6cjs=\ngithub.com/spf13/afero v1.14.0 h1:9tH6MapGnn/j0eb0yIXiLjERO8RB6xIVZRDCX7PtqWA=\ngithub.com/spf13/afero v1.14.0/go.mod h1:acJQ8t0ohCGuMN3O+Pv0V0hgMxNYDlvdk+VTfyZmbYo=\ngithub.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y=\ngithub.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=\ngithub.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=\ngithub.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=\ngithub.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=\ngithub.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=\ngithub.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=\ngithub.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=\ngithub.com/spf13/viper v1.20.1 h1:ZMi+z/lvLyPSCoNtFCpqjy0S4kPbirhpTMwl8BkW9X4=\ngithub.com/spf13/viper v1.20.1/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4=\ngithub.com/ssgreg/nlreturn/v2 v2.2.1 h1:X4XDI7jstt3ySqGU86YGAURbxw3oTDPK9sPEi6YEwQ0=\ngithub.com/ssgreg/nlreturn/v2 v2.2.1/go.mod h1:E/iiPB78hV7Szg2YfRgyIrk1AD6JVMTRkkxBiELzh2I=\ngithub.com/stbenjam/no-sprintf-host-port v0.1.1 h1:tYugd/yrm1O0dV+ThCbaKZh195Dfm07ysF0U6JQXczc=\ngithub.com/stbenjam/no-sprintf-host-port v0.1.1/go.mod h1:TLhvtIvONRzdmkFiio4O8LHsN9N74I+PhRquPsxpL0I=\ngithub.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=\ngithub.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=\ngithub.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=\ngithub.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=\ngithub.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=\ngithub.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=\ngithub.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=\ngithub.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=\ngithub.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=\ngithub.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=\ngithub.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=\ngithub.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=\ngithub.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=\ngithub.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=\ngithub.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=\ngithub.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=\ngithub.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=\ngithub.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=\ngithub.com/tdakkota/asciicheck v0.2.0 h1:o8jvnUANo0qXtnslk2d3nMKTFNlOnJjRrNcj0j9qkHM=\ngithub.com/tdakkota/asciicheck v0.2.0/go.mod h1:Qb7Y9EgjCLJGup51gDHFzbI08/gbGhL/UVhYIPWG2rg=\ngithub.com/tenntenn/modver v1.0.1 h1:2klLppGhDgzJrScMpkj9Ujy3rXPUspSjAcev9tSEBgA=\ngithub.com/tenntenn/modver v1.0.1/go.mod h1:bePIyQPb7UeioSRkw3Q0XeMhYZSMx9B8ePqg6SAMGH0=\ngithub.com/tenntenn/text/transform v0.0.0-20200319021203-7eef512accb3 h1:f+jULpRQGxTSkNYKJ51yaw6ChIqO+Je8UqsTKN/cDag=\ngithub.com/tenntenn/text/transform v0.0.0-20200319021203-7eef512accb3/go.mod h1:ON8b8w4BN/kE1EOhwT0o+d62W65a6aPw1nouo9LMgyY=\ngithub.com/tetafro/godot v1.4.16 h1:4ChfhveiNLk4NveAZ9Pu2AN8QZ2nkUGFuadM9lrr5D0=\ngithub.com/tetafro/godot v1.4.16/go.mod h1:2oVxTBSftRTh4+MVfUaUXR6bn2GDXCaMcOG4Dk3rfio=\ngithub.com/timakin/bodyclose v0.0.0-20230421092635-574207250966 h1:quvGphlmUVU+nhpFa4gg4yJyTRJ13reZMDHrKwYw53M=\ngithub.com/timakin/bodyclose v0.0.0-20230421092635-574207250966/go.mod h1:27bSVNWSBOHm+qRp1T9qzaIpsWEP6TbUnei/43HK+PQ=\ngithub.com/timonwong/loggercheck v0.9.4 h1:HKKhqrjcVj8sxL7K77beXh0adEm6DLjV/QOGeMXEVi4=\ngithub.com/timonwong/loggercheck v0.9.4/go.mod h1:caz4zlPcgvpEkXgVnAJGowHAMW2NwHaNlpS8xDbVhTg=\ngithub.com/tomarrell/wrapcheck/v2 v2.9.0 h1:801U2YCAjLhdN8zhZ/7tdjB3EnAoRlJHt/s+9hijLQ4=\ngithub.com/tomarrell/wrapcheck/v2 v2.9.0/go.mod h1:g9vNIyhb5/9TQgumxQyOEqDHsmGYcGsVMOx/xGkqdMo=\ngithub.com/tommy-muehle/go-mnd/v2 v2.5.1 h1:NowYhSdyE/1zwK9QCLeRb6USWdoif80Ie+v+yU8u1Zw=\ngithub.com/tommy-muehle/go-mnd/v2 v2.5.1/go.mod h1:WsUAkMJMYww6l/ufffCD3m+P7LEvr8TnZn9lwVDlgzw=\ngithub.com/ultraware/funlen v0.1.0 h1:BuqclbkY6pO+cvxoq7OsktIXZpgBSkYTQtmwhAK81vI=\ngithub.com/ultraware/funlen v0.1.0/go.mod h1:XJqmOQja6DpxarLj6Jj1U7JuoS8PvL4nEqDaQhy22p4=\ngithub.com/ultraware/whitespace v0.1.1 h1:bTPOGejYFulW3PkcrqkeQwOd6NKOOXvmGD9bo/Gk8VQ=\ngithub.com/ultraware/whitespace v0.1.1/go.mod h1:XcP1RLD81eV4BW8UhQlpaR+SDc2givTvyI8a586WjW8=\ngithub.com/uudashr/gocognit v1.1.3 h1:l+a111VcDbKfynh+airAy/DJQKaXh2m9vkoysMPSZyM=\ngithub.com/uudashr/gocognit v1.1.3/go.mod h1:aKH8/e8xbTRBwjbCkwZ8qt4l2EpKXl31KMHgSS+lZ2U=\ngithub.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=\ngithub.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=\ngithub.com/xen0n/gosmopolitan v1.2.2 h1:/p2KTnMzwRexIW8GlKawsTWOxn7UHA+jCMF/V8HHtvU=\ngithub.com/xen0n/gosmopolitan v1.2.2/go.mod h1:7XX7Mj61uLYrj0qmeN0zi7XDon9JRAEhYQqAPLVNTeg=\ngithub.com/yagipy/maintidx v1.0.0 h1:h5NvIsCz+nRDapQ0exNv4aJ0yXSI0420omVANTv3GJM=\ngithub.com/yagipy/maintidx v1.0.0/go.mod h1:0qNf/I/CCZXSMhsRsrEPDZ+DkekpKLXAJfsTACwgXLk=\ngithub.com/yeya24/promlinter v0.3.0 h1:JVDbMp08lVCP7Y6NP3qHroGAO6z2yGKQtS5JsjqtoFs=\ngithub.com/yeya24/promlinter v0.3.0/go.mod h1:cDfJQQYv9uYciW60QT0eeHlFodotkYZlL+YcPQN+mW4=\ngithub.com/ykadowak/zerologlint v0.1.5 h1:Gy/fMz1dFQN9JZTPjv1hxEk+sRWm05row04Yoolgdiw=\ngithub.com/ykadowak/zerologlint v0.1.5/go.mod h1:KaUskqF3e/v59oPmdq1U1DnKcuHokl2/K1U4pmIELKg=\ngithub.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=\ngithub.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=\ngithub.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=\ngithub.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=\ngithub.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=\ngithub.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=\ngithub.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=\ngithub.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=\ngithub.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=\ngithub.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=\ngithub.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=\ngitlab.com/bosi/decorder v0.4.2 h1:qbQaV3zgwnBZ4zPMhGLW4KZe7A7NwxEhJx39R3shffo=\ngitlab.com/bosi/decorder v0.4.2/go.mod h1:muuhHoaJkA9QLcYHq4Mj8FJUwDZ+EirSHRiaTcTf6T8=\ngo-simpler.org/assert v0.9.0 h1:PfpmcSvL7yAnWyChSjOz6Sp6m9j5lyK8Ok9pEL31YkQ=\ngo-simpler.org/assert v0.9.0/go.mod h1:74Eqh5eI6vCK6Y5l3PI8ZYFXG4Sa+tkr70OIPJAUr28=\ngo-simpler.org/musttag v0.12.2 h1:J7lRc2ysXOq7eM8rwaTYnNrHd5JwjppzB6mScysB2Cs=\ngo-simpler.org/musttag v0.12.2/go.mod h1:uN1DVIasMTQKk6XSik7yrJoEysGtR2GRqvWnI9S7TYM=\ngo-simpler.org/sloglint v0.7.2 h1:Wc9Em/Zeuu7JYpl+oKoYOsQSy2X560aVueCW/m6IijY=\ngo-simpler.org/sloglint v0.7.2/go.mod h1:US+9C80ppl7VsThQclkM7BkCHQAzuz8kHLsW3ppuluo=\ngo.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=\ngo.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=\ngo.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=\ngo.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=\ngo.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=\ngo.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=\ngo.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=\ngo.uber.org/automaxprocs v1.5.3 h1:kWazyxZUrS3Gs4qUpbwo5kEIMGe/DAvi5Z4tl2NW4j8=\ngo.uber.org/automaxprocs v1.5.3/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=\ngo.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI=\ngo.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=\ngo.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=\ngo.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=\ngo.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60=\ngo.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg=\ngolang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=\ngolang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=\ngolang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=\ngolang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=\ngolang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=\ngolang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=\ngolang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=\ngolang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=\ngolang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=\ngolang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=\ngolang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=\ngolang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=\ngolang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=\ngolang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=\ngolang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=\ngolang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=\ngolang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=\ngolang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=\ngolang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=\ngolang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=\ngolang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=\ngolang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=\ngolang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=\ngolang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=\ngolang.org/x/exp/typeparams v0.0.0-20220428152302-39d4317da171/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=\ngolang.org/x/exp/typeparams v0.0.0-20230203172020-98cc5a0785f9/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=\ngolang.org/x/exp/typeparams v0.0.0-20240314144324-c7f7c6466f7f h1:phY1HzDcf18Aq9A8KkmRtY9WvOFIxN8wgfvy6Zm1DV8=\ngolang.org/x/exp/typeparams v0.0.0-20240314144324-c7f7c6466f7f/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=\ngolang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=\ngolang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=\ngolang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=\ngolang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=\ngolang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=\ngolang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=\ngolang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=\ngolang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=\ngolang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=\ngolang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=\ngolang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=\ngolang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=\ngolang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=\ngolang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=\ngolang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=\ngolang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=\ngolang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=\ngolang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=\ngolang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=\ngolang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=\ngolang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=\ngolang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=\ngolang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=\ngolang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY=\ngolang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=\ngolang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI=\ngolang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=\ngolang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=\ngolang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=\ngolang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=\ngolang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=\ngolang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=\ngolang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=\ngolang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=\ngolang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=\ngolang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=\ngolang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=\ngolang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=\ngolang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=\ngolang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=\ngolang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=\ngolang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=\ngolang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=\ngolang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=\ngolang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=\ngolang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=\ngolang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=\ngolang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=\ngolang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=\ngolang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=\ngolang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=\ngolang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=\ngolang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=\ngolang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=\ngolang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=\ngolang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=\ngolang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=\ngolang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=\ngolang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=\ngolang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws=\ngolang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=\ngolang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=\ngolang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=\ngolang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=\ngolang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=\ngolang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=\ngolang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=\ngolang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=\ngolang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=\ngolang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=\ngolang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=\ngolang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=\ngolang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=\ngolang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=\ngolang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=\ngolang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=\ngolang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=\ngolang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=\ngolang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20211105183446-c75c47738b0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=\ngolang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=\ngolang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=\ngolang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=\ngolang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=\ngolang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=\ngolang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ=\ngolang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=\ngolang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=\ngolang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o=\ngolang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=\ngolang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=\ngolang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=\ngolang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=\ngolang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=\ngolang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=\ngolang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=\ngolang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=\ngolang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=\ngolang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=\ngolang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=\ngolang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=\ngolang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=\ngolang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=\ngolang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=\ngolang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=\ngolang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=\ngolang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=\ngolang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=\ngolang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=\ngolang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=\ngolang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=\ngolang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=\ngolang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=\ngolang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=\ngolang.org/x/tools v0.0.0-20190321232350-e250d351ecad/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=\ngolang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=\ngolang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=\ngolang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=\ngolang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=\ngolang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=\ngolang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=\ngolang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20190910044552-dd2b5c81c578/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=\ngolang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=\ngolang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=\ngolang.org/x/tools v0.0.0-20200324003944-a576cf524670/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=\ngolang.org/x/tools v0.0.0-20200329025819-fd4102a86c65/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=\ngolang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=\ngolang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=\ngolang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=\ngolang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=\ngolang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=\ngolang.org/x/tools v0.0.0-20200724022722-7017fd6b1305/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=\ngolang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=\ngolang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=\ngolang.org/x/tools v0.0.0-20200820010801-b793a1359eac/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=\ngolang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=\ngolang.org/x/tools v0.0.0-20201023174141-c8cfbd0f21e6/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=\ngolang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=\ngolang.org/x/tools v0.1.1-0.20210205202024-ef80cdb6ec6d/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU=\ngolang.org/x/tools v0.1.1-0.20210302220138-2ac05c832e1a/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU=\ngolang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=\ngolang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=\ngolang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=\ngolang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E=\ngolang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=\ngolang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA=\ngolang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k=\ngolang.org/x/tools v0.5.0/go.mod h1:N+Kgy78s5I24c24dU8OfWNEotWjutIs8SnJvn5IDq+k=\ngolang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=\ngolang.org/x/tools v0.11.0/go.mod h1:anzJrxPjNtfgiYQYirP2CPGzGLxrH2u2QBhn6Bf3qY8=\ngolang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=\ngolang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=\ngolang.org/x/tools/go/expect v0.1.1-deprecated h1:jpBZDwmgPhXsKZC6WhL20P4b/wmnpsEAGHaNy0n/rJM=\ngolang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY=\ngolang.org/x/tools/go/packages/packagestest v0.1.1-deprecated h1:1h2MnaIAIXISqTFKdENegdpAgUXz6NrPEsbIeWaBRvM=\ngolang.org/x/tools/go/packages/packagestest v0.1.1-deprecated/go.mod h1:RVAQXBGNv1ib0J382/DPCRS/BPnsGebyM1Gj5VSDpG8=\ngolang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=\ngolang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=\ngolang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=\ngolang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=\ngoogle.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=\ngoogle.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=\ngoogle.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=\ngoogle.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=\ngoogle.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=\ngoogle.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=\ngoogle.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=\ngoogle.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=\ngoogle.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=\ngoogle.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=\ngoogle.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=\ngoogle.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=\ngoogle.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=\ngoogle.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=\ngoogle.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=\ngoogle.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=\ngoogle.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=\ngoogle.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=\ngoogle.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=\ngoogle.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=\ngoogle.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=\ngoogle.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=\ngoogle.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=\ngoogle.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=\ngoogle.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=\ngoogle.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=\ngoogle.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=\ngoogle.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=\ngoogle.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=\ngoogle.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=\ngoogle.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=\ngoogle.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=\ngoogle.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=\ngoogle.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=\ngoogle.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=\ngoogle.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=\ngoogle.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=\ngoogle.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=\ngoogle.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=\ngoogle.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=\ngoogle.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=\ngoogle.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=\ngoogle.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=\ngoogle.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=\ngoogle.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=\ngoogle.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=\ngoogle.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=\ngoogle.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=\ngoogle.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=\ngoogle.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=\ngoogle.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=\ngoogle.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=\ngoogle.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=\ngoogle.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=\ngoogle.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=\ngoogle.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=\ngoogle.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=\ngoogle.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=\ngoogle.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=\ngoogle.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=\ngoogle.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=\ngoogle.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=\ngoogle.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=\ngoogle.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=\ngoogle.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=\ngoogle.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=\ngoogle.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=\ngoogle.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=\ngoogle.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=\ngoogle.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=\ngoogle.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=\ngoogle.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=\ngoogle.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=\ngoogle.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=\ngoogle.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=\ngoogle.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=\ngoogle.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=\ngopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=\ngopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=\ngopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=\ngopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=\ngopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=\ngopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=\ngopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=\ngopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=\ngopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=\ngopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=\ngopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=\ngopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=\ngopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=\ngopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=\ngopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=\ngopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=\ngopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=\ngopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=\ngopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=\ngotest.tools/gotestsum v1.11.0 h1:A88/QWw7acMjZH1dMe6KZFhw32odUOIjCiAU/Q4n3mI=\ngotest.tools/gotestsum v1.11.0/go.mod h1:cUOKgFEvWAP0twchmiOvdzX0SBZX0UI58bGRpRIu4xs=\ngotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo=\ngotest.tools/v3 v3.3.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A=\nhonnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=\nhonnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=\nhonnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=\nhonnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=\nhonnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=\nhonnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=\nhonnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=\nhonnef.co/go/tools v0.5.1 h1:4bH5o3b5ZULQ4UrBmP+63W9r7qIkqJClEA9ko5YKx+I=\nhonnef.co/go/tools v0.5.1/go.mod h1:e9irvo83WDG9/irijV44wr3tbhcFeRnfpVlRqVwpzMs=\nmvdan.cc/gofumpt v0.7.0 h1:bg91ttqXmi9y2xawvkuMXyvAA/1ZGJqYAEGjXuP0JXU=\nmvdan.cc/gofumpt v0.7.0/go.mod h1:txVFJy/Sc/mvaycET54pV8SW8gWxTlUuGHVEcncmNUo=\nmvdan.cc/sh/v3 v3.8.0 h1:ZxuJipLZwr/HLbASonmXtcvvC9HXY9d2lXZHnKGjFc8=\nmvdan.cc/sh/v3 v3.8.0/go.mod h1:w04623xkgBVo7/IUK89E0g8hBykgEpN0vgOj3RJr6MY=\nmvdan.cc/unparam v0.0.0-20240528143540-8a5130ca722f h1:lMpcwN6GxNbWtbpI1+xzFLSW8XzX0u72NttUGVFjO3U=\nmvdan.cc/unparam v0.0.0-20240528143540-8a5130ca722f/go.mod h1:RSLa7mKKCNeTTMHBw5Hsy2rfJmd6O2ivt9Dw9ZqCQpQ=\nrsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=\nrsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=\nrsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=\n" }, { "path": "tools/main.go", "content": "package main\n\nimport (\n\t\"os\"\n\n\t\"github.com/vektra/mockery/tools/cmd\"\n)\n\nfunc main() {\n\tif err := cmd.NewRootCmd().Execute(); err != nil {\n\t\tos.Exit(1)\n\t}\n}\n" }, { "path": "tools/tools.go", "content": "//go:build tools\n\npackage main\n\nimport (\n\t_ \"github.com/go-task/task/v3/cmd/task\"\n\t_ \"github.com/golangci/golangci-lint/cmd/golangci-lint\"\n\t_ \"gotest.tools/gotestsum\"\n\t_ \"mvdan.cc/gofumpt\"\n)\n" } ]