when:
        configurationCacheRun(task, *options)
        def secondRunOutput = removeVfsLogOutput(result.normalizedOutput)
            .replaceAll(/Reusing configuration cache.\n/, '')
            .replaceAll(/Configuration cache entry reused.\n/, '')

        then:
        firstRunOutput == secondRunOutput

        where:
        task           | options

        cst.erase();
      }

      if (result.needs_densify) {
        auto value = op->getOperand(operand);
        auto densify =
            builder.create<DensifyOp>(op->getLoc(), value.getType(), value);
        value.replaceAllUsesWith(densify);
        densify.setOperand(value);
      }
    }
  });
}

}  // namespace

        when:
        configurationCacheRun(task, *options)
        def secondRunOutput = removeVfsLogOutput(result.normalizedOutput)
            .replaceAll(/Reusing configuration cache.\n/, '')
            .replaceAll(/Configuration cache entry reused.\n/, '')

        then:
        firstRunOutput == secondRunOutput

        where:
        task                    | options

            assertSingleFileReport(ReportSeverity.FATAL, EditorMessages.failure)
        }
    }

    @Test
    fun `report file error on TAPI failure when reusing previous dependencies`() {

        val editedScript = withBuildScript("")

        val previous = resolvedScriptDependencies(editedScript).apply {
            assertContainsBasicDependencies()
        }

                if (context.iteration > 1) {
                    def tag = action == storing
                        ? "Calculating task graph as no (cached configuration|configuration cache) is available"
                        : "Reusing configuration cache"
                    File buildLog = new File(invocationSettings.projectDir, "profile.log")

                    def found = Files.lines(buildLog.toPath()).withCloseable { lines ->

        // The origin execution time is recorded as “work duration” + “output snapshotting duration”,
        // As this is _roughly_ the amount of time that is avoided by reusing the outputs,
        // which is currently the _only_ thing this value is used for.
        Duration originExecutionTime = result.getDuration().plus(Duration.ofMillis(snapshotOutputDuration));

                logger.debug(
                        "Reusing cached resolved plugin version for {}:{} to {} from POM {}",
                        request.getGroupId(),
                        request.getArtifactId(),
                        result.getVersion(),
                        request.getPom());
            }
        } else {
            logger.debug(
                    "Reusing cached resolved plugin version for {}:{} to {} from POM {}",

			Annotations: map[string]string{
				annotation.SidecarUserVolume.Name:      clientSidecarVolumes,
				annotation.SidecarUserVolumeMount.Name: sidecarVolumeMounts,
				// the default bootstrap template does not support reusing values from the `ISTIO_META_TLS_CLIENT_*` environment variables
				// see security/pkg/nodeagent/cache/secretcache.go:generateFileSecret() for details

    else -> sameType(valueType, isAssignableTo)
}


/**
 * Can't check for equality: TAPI proxies are not equal to the original implementations.
 * TODO: maybe "reify" the TAPI proxies to ensure equality?
 */
private
fun sameType(left: DataType, right: DataType) = when (left) {
    is DataClass -> right is DataClass && left.name.qualifiedName == right.name.qualifiedName

                discard(client);
                client = reuseExistingOrCreateNewClient(sftpHost);
            } else {
                LOGGER.debug("Reusing an existing sftp client.");
            }
        }

        return client;
    }

    private LockableSftpClient createNewClient(SftpHost sftpHost) {