61if (File.Exists(releaseBinary)) 94if (File.Exists(binary))

52if (!File.Exists(sidecarPath)) 100if (!File.Exists(sidecarPath)) 156using var stream = File.OpenRead(sidecarPath);

30if (!File.Exists(sidecarPath)) 74if (File.Exists(temporaryPath)) 76File.Delete(temporaryPath); 92using var stream = File.OpenRead(sidecarPath); 121File.Move(_temporaryPath, sidecarPath, overwrite: true); 127if (_temporaryPath is not null && File.Exists(_temporaryPath)) 129File.Delete(_temporaryPath);

69if (string.IsNullOrEmpty(binaryPath) || !File.Exists(binaryPath))

42if (File.Exists(sidecarPath)) 67File.WriteAllBytes(tempPath, s_wingetSidecarContent); 77File.Move(tempPath, sidecarPath, overwrite: false); 96File.Delete(tempPath);

120if (!File.Exists(manifestPath)) 128await using var manifestStream = File.OpenRead(manifestPath); 280if (!File.Exists(fullPath)) 287var bytes = File.ReadAllBytes(fullPath); 455using var stream = File.OpenRead(archivePath); 484using var fileStream = File.OpenRead(tarballPath); 578if (File.Exists(rootManifestPath)) 585if (File.Exists(packageManifestPath)) 592.Where(directory => File.Exists(Path.Combine(directory, ManifestFileName))) 622File.Copy(sourceFile, targetFile, overwrite: true);

538await using var fileStream = File.Create(archivePath); 670!File.Exists(Path.Combine(cacheDirectory, GitHubAttestationVerifiedFileName))) 681var cachedArchiveSha512 = File.Exists(cachedArchiveSha512Path) 682? TryNormalizeArchiveSha512(File.ReadAllText(cachedArchiveSha512Path).Trim()) 694var cachedGitHubArchiveSha256 = File.Exists(cachedGitHubArchiveSha256Path) 695? TryNormalizeArchiveSha256(File.ReadAllText(cachedGitHubArchiveSha256Path).Trim()) 765await File.WriteAllTextAsync( 774await File.WriteAllTextAsync( 782await File.WriteAllTextAsync( 827File.Delete(Path.Combine(bundleDirectory, ArchiveSha512FileName)); 828File.Delete(Path.Combine(bundleDirectory, GitHubArchiveSha256FileName)); 829File.Delete(Path.Combine(bundleDirectory, GitHubAttestationVerifiedFileName)); 830File.Delete(Path.Combine(bundleDirectory, LastUsedFileName)); 934using var stream = File.OpenRead(archivePath); 940using var stream = File.OpenRead(archivePath); 1068File.Exists(Path.Combine(versionCacheDirectory, "skill-manifest.json")) || 1069File.Exists(Path.Combine(versionCacheDirectory, ArchiveSha512FileName)) || 1070File.Exists(Path.Combine(versionCacheDirectory, GitHubArchiveSha256FileName)) || 1071File.Exists(Path.Combine(versionCacheDirectory, GitHubAttestationVerifiedFileName)) || 1072File.Exists(Path.Combine(versionCacheDirectory, LastUsedFileName)); 1109File.WriteAllText(Path.Combine(directory, LastUsedFileName), DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(CultureInfo.InvariantCulture)); 1120if (File.Exists(markerPath) && 1121long.TryParse(File.ReadAllText(markerPath), NumberStyles.Integer, CultureInfo.InvariantCulture, out var unixTime) && 1161File.Delete(path);

81await using (var fileStream = File.Create(archivePath))

188using var stream = File.OpenRead(artifactPath);

157if (!File.Exists(configFilePath)) 164var content = File.ReadAllText(configFilePath); 223await File.WriteAllTextAsync(configFilePath, jsonContent, cancellationToken);

144if (!File.Exists(configFilePath)) 151var content = File.ReadAllText(configFilePath); 229await File.WriteAllTextAsync(configFilePath, jsonContent, cancellationToken);

46File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] Scanning context.RepositoryRoot: {context.RepositoryRoot.FullName}\n"); 51File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] Checking {location.AgentName}: {configPath}\n"); 53if (!File.Exists(configPath)) 55File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] -> File does not exist\n"); 59File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] -> File EXISTS!\n"); 63var content = File.ReadAllText(configPath); 64File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] -> Content: {content.Substring(0, Math.Min(200, content.Length))}\n"); 69File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] -> JSON parse returned null\n"); 74File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] -> HasDeprecatedMcpCommand: {hasDeprecated}\n"); 83File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] -> Added applicator\n"); 88File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] -> JsonException: {ex.Message}\n"); 93File.AppendAllText(debugPath, $"[{DateTime.UtcNow:O}] -> IOException: {ex.Message}\n"); 214await File.WriteAllTextAsync(configPath, jsonContent, cancellationToken);

159if (File.Exists(settingsPath)) 164content = await File.ReadAllTextAsync(settingsPath, cancellationToken); 386await File.WriteAllTextAsync(tempPath, json, cancellationToken); 387File.Move(tempPath, path, overwrite: true);

75if (File.Exists(path)) 79var existing = await File.ReadAllTextAsync(path, s_utf8NoBom, cancellationToken); 94await File.WriteAllTextAsync(tempPath, content, s_utf8NoBom, cancellationToken); 95File.Move(tempPath, path, overwrite: true); 107var mode = File.GetUnixFileMode(path); 108File.SetUnixFileMode(path, mode | UnixFileMode.UserExecute | UnixFileMode.GroupExecute | UnixFileMode.OtherExecute);

26if (!File.Exists(configFilePath)) 33var content = File.ReadAllText(configFilePath); 70if (!File.Exists(configFilePath)) 75var content = await File.ReadAllTextAsync(configFilePath, cancellationToken);

50var configFileExists = File.Exists(configFilePath); 109var content = File.ReadAllText(configFilePath); 215await File.WriteAllTextAsync(configFilePath, jsonOutput, cancellationToken);

435File.Copy(sourceFile, targetFile, overwrite: true); 446if (!File.Exists(sourceFile)) 448File.Delete(targetFile); 469using var stream = File.OpenRead(filePath);

196if (!File.Exists(mcpConfigPath)) 203var content = File.ReadAllText(mcpConfigPath); 269await File.WriteAllTextAsync(mcpConfigPath, jsonContent, cancellationToken);

582var data = await File.ReadAllBytesAsync(filePath, cancellationToken).ConfigureAwait(false);

405File.Delete(socketPath);

601if (!Directory.Exists(managedDir) || !File.Exists(managedExe)) 621if (!Directory.Exists(dcpDir) || !File.Exists(dcpExe)) 837File.WriteAllText(markerPath, version); 847if (!File.Exists(markerPath)) 852var content = File.ReadAllText(markerPath).Trim(); 918File.SetUnixFileMode(fullPath, (UnixFileMode)entry.Mode); 939if (File.Exists(fullPath)) 941File.Delete(fullPath); 943File.CreateSymbolicLink(fullPath, entry.LinkName);

140if (!File.Exists(path)) 146var json = await File.ReadAllTextAsync(path, cancellationToken).ConfigureAwait(false); 220await File.WriteAllTextAsync(tempPath, payload, cancellationToken).ConfigureAwait(false); 225File.Move(tempPath, path, overwrite: true); 243File.Delete(tempPath);

69return await File.ReadAllTextAsync(cacheFilePath, cancellationToken).ConfigureAwait(false); 108await File.WriteAllTextAsync(tempFile, content, cancellationToken).ConfigureAwait(false); 110if (File.Exists(fullPath)) 114File.Delete(fullPath); 122File.Move(tempFile, fullPath);

48File.Move(temporaryPath, outputPath); 50catch (IOException) when (File.Exists(outputPath)) 59File.Delete(temporaryPath); 78File.SetUnixFileMode(directory, DirectoryPermissions);

538if (!File.Exists(certificatePath)) 746File.Move(tempFilename, path, overwrite: true); 749File.WriteAllBytes(path, bytes); 774File.Move(tempFilename, keyPath, overwrite: true); 777File.WriteAllBytes(keyPath, pemEnvelope);

130File.Delete(tmpFile); 143return File.Exists(GetCertificateFilePath(candidate)) ? 190File.Delete(tmpFile); 222File.WriteAllBytes(certificatePath, certBytes); 243File.Delete(certificatePath); 351File.WriteAllBytes(certificatePath, certBytes); 392if (!File.Exists(onDiskPfxPath)) 417File.WriteAllBytes(keyPath, Encoding.UTF8.GetBytes(pem)); 515if (File.Exists(certificatePath)) 517File.Delete(certificatePath);

130if (File.Exists(certPath)) 271if (File.Exists(certPath)) 497if (File.Exists(certPath)) 648if (File.Exists(WslInteropPath) || File.Exists(WslInteropLatePath)) 819File.Delete(certPath); 1048if (!File.Exists(linkPath)) 1051File.CreateSymbolicLink(linkPath, cert.Name);

249if (File.Exists(outputPath))

341if (!File.Exists(nugetConfigPath))

725if (File.Exists(fullPath)) 727var existingContent = await File.ReadAllTextAsync(fullPath, cancellationToken); 734await File.WriteAllTextAsync(fullPath, skillFile.Content, cancellationToken);

981if (maxLines <= 0 || !File.Exists(childLogFile)) 990using var reader = File.OpenText(childLogFile); 1047if (maxLines <= 0 || !File.Exists(childLogFile)) 1053using var reader = File.OpenText(childLogFile);

112if (managedPath is null || !File.Exists(managedPath))

35if (!File.Exists(dcpPath))

276if (File.Exists(appHostPath)) 300File.WriteAllText(appHostPath, appHostContent); 488.FirstOrDefault(pattern => File.Exists(Path.Combine(workingDirectory.FullName, pattern))); 497if (File.Exists(appHostPath)) 538if (File.Exists(configPath)) 541var existingContent = File.ReadAllText(configPath); 647File.WriteAllText(configPath, JsonSerializer.Serialize(settings, JsonSourceGenerationContext.RelaxedEscaping.JsonObject)); 794if (File.Exists(path)) 841File.WriteAllText(path, JsonSerializer.Serialize(settings, JsonSourceGenerationContext.RelaxedEscaping.JsonObject));

1248if (!File.Exists(fullPath))

446await File.WriteAllTextAsync(filePath, "This file is used to smoke test SafeFileLink rendering.", cancellationToken).ConfigureAwait(false);

232await File.WriteAllTextAsync(outputFile.FullName, output, cancellationToken); 361await File.WriteAllTextAsync(outputPath, output, cancellationToken);

187await File.WriteAllTextAsync(filePath, content, cancellationToken);

784if (!File.Exists(newExePath)) 800if (File.Exists(targetExePath)) 808File.Move(targetExePath, backupPath); 815File.Copy(newExePath, targetExePath, overwrite: true); 856if (backupPath is not null && File.Exists(backupPath)) 858if (File.Exists(targetExePath)) 860File.Delete(targetExePath); 862File.Move(backupPath, targetExePath); 904var mode = File.GetUnixFileMode(filePath); 906File.SetUnixFileMode(filePath, mode);

133if (!File.Exists(filePath)) 140var json = File.ReadAllText(filePath); 161File.WriteAllText(filePath, json); 233if (!File.Exists(apphostRunPath)) 238var json = File.ReadAllText(apphostRunPath); 393return File.Exists(Path.Combine(directory, FileName));

100if (!File.Exists(filePath)) 105var json = File.ReadAllText(filePath); 141File.WriteAllText(filePath, json);

33if (File.Exists(settingsFilePath)) 35var existingContent = await File.ReadAllTextAsync(settingsFilePath, cancellationToken); 56if (!File.Exists(settingsFilePath)) 63var existingContent = await File.ReadAllTextAsync(settingsFilePath, cancellationToken); 115if (File.Exists(newSettingsPath)) 125if (File.Exists(legacySettingsPath)) 150if (!File.Exists(aspireConfigPath)) 189var content = await File.ReadAllTextAsync(filePath, cancellationToken); 387else if (File.Exists(configFilePath) && !continueSearchWhenKeyMissing) 397else if (File.Exists(legacySettingsPath) && !continueSearchWhenKeyMissing) 411if (File.Exists(globalSettingsFile.FullName)) 428if (!File.Exists(settingsFilePath)) 455content = File.ReadAllText(filePath);

61if (!_hasOutput || !File.Exists(_logFilePath))

190if (!File.Exists(filePath)) 196await using var stream = File.OpenRead(filePath); 238await using (var stream = File.Create(tempPath)) 243File.Move(tempPath, filePath, overwrite: true); 276if (!File.Exists(filePath)) 281return await File.ReadAllTextAsync(filePath, cancellationToken).ConfigureAwait(false); 297await File.WriteAllTextAsync(tempPath, content, cancellationToken).ConfigureAwait(false); 298File.Move(tempPath, filePath, overwrite: true); 328if (File.Exists(filePath)) 330File.Delete(filePath);

653if (!File.Exists(cliAssemblyPath)) 667return File.Exists(Path.Combine(cliDirectory, ".aspire-install.json")); 1186if (File.Exists(sourcePath) && string.Equals(Path.GetExtension(sourcePath), ".nupkg", StringComparison.OrdinalIgnoreCase)) 1420if (!File.Exists(filePath)) 1428using var stream = File.OpenRead(filePath);

70if (File.Exists(gitPath)) 154if (File.Exists(gitPath)) 241File.Exists(checkoutGitFile) && 310contents = File.ReadAllText(filePath); 374if (!File.Exists(candidate) && !Directory.Exists(candidate))

263_logger.LogDebug(" {Dir}/{Managed}/{Exe}: {Exists}", BundleDiscovery.BundleDirectoryName, BundleDiscovery.ManagedDirectoryName, managedExeName, File.Exists(bundleManagedExe) ? "exists" : "MISSING"); 264_logger.LogDebug(" {Dir}/{Dcp}/{Exe}: {Exists}", BundleDiscovery.BundleDirectoryName, BundleDiscovery.DcpDirectoryName, Path.GetFileName(bundleDcpExe), File.Exists(bundleDcpExe) ? "exists" : "MISSING"); 266if (File.Exists(bundleManagedExe) && File.Exists(bundleDcpExe)) 297_logger.LogDebug(" managed/{ManagedExe}: {Exists}", managedExeName, File.Exists(managedExePath) ? "exists" : "MISSING"); 298_logger.LogDebug(" dcp/{DcpExe}: {Exists}", Path.GetFileName(dcpExePath), File.Exists(dcpExePath) ? "exists" : "MISSING"); 300if (!File.Exists(managedExePath) || !File.Exists(dcpExePath)) 337if (managedPath is null || !File.Exists(managedPath)) 347!File.Exists(BundleDiscovery.GetDcpExecutablePath(dcpPath)))

161var modernAppHostContent = LegacyTypeScriptAppHost.RewriteAppHostContent(File.ReadAllText(legacyAppHostFile.FullName)); 178File.WriteAllText(modernAppHostFile.FullName, modernAppHostContent); 193if (!File.Exists(configPath)) 200if (JsonNode.Parse(File.ReadAllText(configPath)) is not JsonObject root || 221File.WriteAllText(configPath, root.ToJsonString(new JsonSerializerOptions { WriteIndented = true })); 232if (!File.Exists(tsConfigPath)) 242File.ReadAllText(tsConfigPath), 269File.WriteAllText(tsConfigPath, root.ToJsonString(new JsonSerializerOptions { WriteIndented = true })); 280if (!File.Exists(packageJsonPath)) 287if (JsonNode.Parse(File.ReadAllText(packageJsonPath)) is not JsonObject root || 311File.WriteAllText(packageJsonPath, root.ToJsonString(new JsonSerializerOptions { WriteIndented = true })); 325if (!File.Exists(configPath)) 330var current = File.ReadAllText(configPath); 334File.WriteAllText(configPath, rewritten);

120if (!File.Exists(tarballPath))

148if (managedPath is null || !File.Exists(managedPath))

91if (managedPath is null || !File.Exists(managedPath)) 118if (File.Exists(manifestPath) && TryValidatePackageManifest(manifestPath, _logger))

112File.Copy(tmpConfig.ConfigFile.FullName, targetPath, overwrite: true);

147await File.WriteAllTextAsync(configFile.FullName, content);

37if (!File.Exists(dcpPath))

76if (managedPath is null || !File.Exists(managedPath)) 173File.Exists(dashboardPath)) 182if (File.Exists(managedPath)) 188if (File.Exists(managedExecutable)) 215return File.Exists(managedPath) ? managedPath : null;

175if (!File.Exists(newPath) && File.Exists(legacyPath)) 179var legacyJson = File.ReadAllText(legacyPath);

207if (!File.Exists(absolutePath))

118if (!File.Exists(normalizedSourcePath)) 261using var stream = File.OpenRead(path); 384!File.Exists(manifestPath)) 438File.Copy(entry.SourcePath, destinationPath, overwrite: false); 488if (!File.ReadLines(manifestPath).SequenceEqual(expectedManifest.GetProjectLayoutManifestLines(), StringComparer.Ordinal)) 496if (!File.Exists(copiedPath) || 528await File.WriteAllLinesAsync(path, manifest.GetProjectLayoutManifestLines(), cancellationToken).ConfigureAwait(false);

62if (layout is not null && layout.GetManagedPath() is string serverPath && File.Exists(serverPath))

300if (!File.Exists(filePath)) 728if (!File.Exists(filePath)) 1896if (!File.Exists(resolvedTargetPath)) 1906if (!File.Exists(runtimeConfigPath)) 1920if (!File.Exists(resolvedRunCommand)) 2065if (File.Exists(propertiesLaunchSettingsPath)) 2072if (File.Exists(runJsonPath)) 2088using var stream = File.OpenRead(launchSettingsPath); 2202if (File.Exists(runJsonFilePath)) 2625File.Exists(BundleDiscovery.GetDcpExecutablePath(path)); 2628=> !string.IsNullOrWhiteSpace(path) && File.Exists(path);

113if (File.Exists(hashFilePath)) 115return File.ReadAllText(hashFilePath); 124File.WriteAllText(hashFilePath, hash); 195if (File.Exists(projectPath) && addedProjects.Add(integration.Name)) 214if (File.Exists(hostingPath) && addedProjects.Add("Aspire.Hosting")) 238if (File.Exists(appHostInTargets)) 242if (File.Exists(sdkInTargets)) 249if (File.Exists(dashboardProject)) 256if (File.Exists(remoteHostProject)) 282File.WriteAllText(Path.Combine(_projectModelPath, "Program.cs"), programCs); 322? File.ReadAllText(userNugetConfig) 464if (!File.Exists(Path.Combine(_projectModelPath, fileName))) 473if (!File.Exists(Path.Combine(_projectModelPath, "obj", "project.assets.json"))) 506File.WriteAllText(Path.Combine(_projectModelPath, fileName), content); 516if (File.Exists(staleNugetConfig)) 518File.Delete(staleNugetConfig); 756if (File.Exists(configPath)) 803if (!File.Exists(versionsPropsPath))

99var fileContent = File.ReadAllText(projectFile.FullName);

31if (File.Exists(path)) 35var existing = await File.ReadAllTextAsync(path, cancellationToken).ConfigureAwait(false); 46await File.WriteAllTextAsync(path, content, cancellationToken).ConfigureAwait(false);

927var configPath = File.Exists(apphostRunPath) ? apphostRunPath : launchSettingsPath; 929if (!File.Exists(configPath)) 938var json = File.ReadAllText(configPath); 1717await File.WriteAllTextAsync(filePath, content, cancellationToken); 1933if (File.Exists(manifestPath)) 1937foreach (var line in await File.ReadAllLinesAsync(manifestPath, cancellationToken).ConfigureAwait(false)) 1957await File.WriteAllLinesAsync(manifestPath, current.Order(StringComparer.Ordinal), cancellationToken).ConfigureAwait(false); 1990File.Delete(fullPath); 2005File.WriteAllText(hashPath, hash); 2248var devCertificateContents = await File.ReadAllBytesAsync(devCertPemPath, cancellationToken); 2249var existingBundleContents = await File.ReadAllBytesAsync(existingBundlePath, cancellationToken); 2262if (!File.Exists(bundlePath))

327if (File.Exists(path)) 333if (File.GetLastWriteTimeUtc(path) > stampWriteTime) 371if (MatchesExtension(check, file) && File.GetLastWriteTimeUtc(file) > stampWriteTime) 406if (File.GetLastWriteTimeUtc(file) > stampWriteTime) 521File.WriteAllBytes(stampFile.FullName, []); 589if (!File.Exists(filePath)) 592await File.WriteAllTextAsync(filePath, content, cancellationToken);

97/// <see cref="File.Exists"/> call.

131if (File.Exists(Path.Combine(candidate.FullName, MavenPomFileName))) 138if (File.Exists(Path.Combine(candidate.FullName, gradleBuildFileName))) 194if (File.Exists(candidate) 205if (Directory.Exists(gitPath) || File.Exists(gitPath)) 221JavaAppHostToolchain.Gradle => File.Exists(Path.Combine(directory, GradleSettingsFileName)) 222|| File.Exists(Path.Combine(directory, GradleKotlinSettingsFileName)), 225JavaAppHostToolchain.Maven => File.Exists(Path.Combine(directory, MavenPomFileName)), 257return (File.GetUnixFileMode(path) & UnixFileMode.OtherWrite) != 0; 417await File.WriteAllTextAsync(temporaryPath, GradleInitScript, cancellationToken).ConfigureAwait(false); 418File.Move(temporaryPath, scriptPath, overwrite: true); 424File.Delete(temporaryPath);

41return File.Exists(Path.Combine(appPath, LegacyAppHostFileName)) && 42!File.Exists(Path.Combine(appPath, ModernAppHostFileName));

135if (managedPath is null || !File.Exists(managedPath)) 413if (!File.Exists(projectPath)) 418var projectBytes = await File.ReadAllBytesAsync(projectPath, cancellationToken).ConfigureAwait(false); 431var importBytes = await File.ReadAllBytesAsync(importPath, cancellationToken).ConfigureAwait(false); 474if (!File.Exists(projectPath)) 482using var stream = File.OpenRead(projectPath); 547if (File.Exists(candidate)) 624if (!File.Exists(assetsPath) || !File.Exists(stampPath)) 631return string.Equals(File.ReadAllText(stampPath), expectedFingerprint, StringComparison.Ordinal); 649await File.WriteAllTextAsync(Path.Combine(objDir, RestoreStampFileName), fingerprint, cancellationToken).ConfigureAwait(false); 856await File.WriteAllLinesAsync( 1542if (!File.Exists(filePath)) 1548var lines = await File.ReadAllLinesAsync(filePath, cancellationToken); 1554if (!File.Exists(filePath)) 1559var lines = await File.ReadAllLinesAsync(filePath, cancellationToken).ConfigureAwait(false); 1587if (!File.Exists(assetsFilePath)) 1592await using var stream = File.OpenRead(assetsFilePath); 1709await File.WriteAllTextAsync(

992else if (File.Exists(projectFile.FullName)) 1254if (shouldPreserveExistingDefault && File.Exists(resolvedPath))

870var fileContent = await File.ReadAllTextAsync(projectFile.FullName); 892await File.WriteAllTextAsync(projectFile.FullName, updatedContent); 909var fileContent = File.ReadAllText(projectFile.FullName); 922var fileContent = await File.ReadAllTextAsync(projectFile.FullName); 927await File.WriteAllTextAsync(projectFile.FullName, updatedContent); 1034if (File.Exists(directoryPackagesPropsPath))

59if (File.Exists(Path.Combine(candidateDirectory.FullName, BunLockFileName))) 64if (File.Exists(Path.Combine(candidateDirectory.FullName, BunBinaryLockFileName))) 69if (File.Exists(Path.Combine(candidateDirectory.FullName, PnpmLockFileName))) 75if (File.Exists(yarnLockFilePath)) 85if (File.Exists(Path.Combine(candidateDirectory.FullName, YarnConfigFileName))) 90if (File.Exists(Path.Combine(candidateDirectory.FullName, PackageLockFileName))) 303if (!File.Exists(packageJsonPath)) 310var packageJson = JsonNode.Parse(File.ReadAllText(packageJsonPath), documentOptions: ConfigurationHelper.ParseOptions) as JsonObject; 381foreach (var line in File.ReadLines(yarnLockFilePath))

192if (fileName.Equals(PackageJsonFileName, StringComparison.OrdinalIgnoreCase) && File.Exists(filePath)) 194var existingContent = await File.ReadAllTextAsync(filePath, cancellationToken); 201else if (IsGitIgnoreFile(fileName) && File.Exists(filePath)) 203var existingContent = await File.ReadAllTextAsync(filePath, cancellationToken); 206else if (IsVsCodeSettingsFile(fileName) && File.Exists(filePath)) 208var existingContent = await File.ReadAllTextAsync(filePath, cancellationToken); 212await File.WriteAllTextAsync(filePath, contentToWrite, cancellationToken); 245if (profiles is not null && File.Exists(appHostRunPath)) 250File.Delete(appHostRunPath); 268if (IsTypeScriptLanguage(language) && File.Exists(Path.Combine(directory.FullName, PackageJsonFileName))) 295var existingContent = await File.ReadAllTextAsync(packageJsonPath, cancellationToken); 322await File.WriteAllTextAsync(packageJsonPath, serializedPackageJson, cancellationToken); 496await File.WriteAllTextAsync(filePath, content, cancellationToken); 509!File.Exists(Path.Combine(directory.FullName, PackageJsonFileName)) || 550if (File.Exists(filePath) || Directory.Exists(filePath))

470File.Delete(socketPath);

138if (File.Exists(dcpExePath)) 169if (File.Exists(managedExe)) 282return File.Exists(managedPath) ? managedPath : null;

29File.SetUnixFileMode(path, OwnerOnlyMode);

56using var fileStream = File.Create(filePath);

112if (!File.Exists(normalizedManifestPath)) 117using var stream = File.OpenRead(normalizedManifestPath); 173return File.WriteAllBytesAsync(path, stream.ToArray(), cancellationToken); 341if (!File.Exists(normalizedPath))

228if (!File.Exists(path)) 243return (File.GetUnixFileMode(path) & ExecuteBits) != 0;

172: File.ResolveLinkTarget(current, returnFinalTarget: true) 253if (storedLinkTarget is null && !File.Exists(current) && !Directory.Exists(current)) 257_ = File.GetAttributes(current); 273: File.ResolveLinkTarget(current, returnFinalTarget: true)

345contents = File.ReadAllText(statPath);

26if (!File.Exists(originalSecretsPath)) 43File.Copy(originalSecretsPath, isolatedSecretsPath, overwrite: true); 64if (File.Exists(secretsPath)) 66File.Delete(secretsPath);

93File.WriteAllText(tempFilename, json); 94File.Move(tempFilename, _secretsFilePath, overwrite: true); 99if (File.Exists(tempFilename)) 101File.Delete(tempFilename); 107File.WriteAllText(_secretsFilePath, json); 116if (!File.Exists(path)) 121var json = File.ReadAllText(path);

301if (!File.Exists(_cacheFilePath)) 308var json = await File.ReadAllTextAsync(_cacheFilePath, cancellationToken).ConfigureAwait(false); 352await File.WriteAllTextAsync(tempPath, json, cancellationToken).ConfigureAwait(false); 353File.Move(tempPath, _cacheFilePath, overwrite: true); 405if (!File.Exists(accountStore)) 478if (!File.Exists(stateDatabasePath)) 1008if (!File.Exists(filePath)) 1016text = File.ReadAllText(filePath); 1054if (File.Exists(path)) 1130if (!File.Exists("/proc/sys/kernel/osrelease")) 1135var osRelease = File.ReadAllText("/proc/sys/kernel/osrelease"); 1162if (File.Exists(candidate))

84File.Delete(fullPath); 86await File.WriteAllTextAsync(fullPath, value, Encoding.UTF8); 106if (!File.Exists(path)) 113var contents = await File.ReadAllTextAsync(path, Encoding.UTF8);

366var mode = File.GetUnixFileMode(filePath); 367File.SetUnixFileMode(filePath, mode | UnixFileMode.UserExecute | UnixFileMode.GroupExecute | UnixFileMode.OtherExecute);

153if (!File.Exists(aspireConfigPath)) 159var content = await File.ReadAllTextAsync(aspireConfigPath, cancellationToken); 163await File.WriteAllTextAsync(aspireConfigPath, updatedContent, cancellationToken);

117if (File.Exists(Path.Combine(directory, dotnetFileName)))

179if (File.Exists(socketPath)) 181File.Delete(socketPath);

112File.SetUnixFileMode(fullPath, (UnixFileMode)entry.Mode); 133if (File.Exists(fullPath)) 135File.Delete(fullPath); 137File.CreateSymbolicLink(fullPath, entry.LinkName);

97if (File.Exists(Path.Combine(currentDirectory, AspireSolutionFileName))) 117if (File.Exists(fullPath))

144if (File.Exists(lddPath)) 208var expectedChecksum = (await File.ReadAllTextAsync(checksumPath, cancellationToken)).Trim().ToLowerInvariant();

219/// the directory directly and <see cref="File.ResolveLinkTarget(string, bool)"/> 329var lastWrite = File.GetLastWriteTimeUtc(path); 332File.Delete(path); 369var resolved = File.ResolveLinkTarget(path, returnFinalTarget: true);

37if (File.Exists(newSettingsPath)) 64if (File.Exists(legacySettingsPath)) 74if (File.Exists(globalSettingsFile.FullName)) 155if (File.Exists(configPath)) 161if (File.Exists(legacyPath)) 176if (!File.Exists(filePath)) 183var content = File.ReadAllText(filePath); 230await File.WriteAllTextAsync(filePath, jsonContent, cancellationToken); 241File.WriteAllText(filePath, jsonContent); 265var content = File.ReadAllText(filePath); 292var content = File.ReadAllText(filePath);

383while (!File.Exists(_kubeconfigPath))

47if (!File.Exists(dcpExecutablePath))

33certificateManager.ExportCertificate(certificate, certificatePath, includePrivateKey: !File.Exists(keyPath), password: null, CertificateKeyExportFormat.Pem);

29var content = await File.ReadAllTextAsync(path, cancellationToken).ConfigureAwait(false);

48if (!File.Exists(configPath)) 55var content = File.ReadAllText(configPath);

294if (!File.Exists(certificateFile)) 391if (!File.Exists(certificateFile))

41if (File.Exists(modernConfigPath)) 48if (File.Exists(legacySettingsPath))

163return File.ReadAllText("/etc/os-release");

226return File.Exists(ProcVersionPath) ? File.ReadAllText(ProcVersionPath) : null;

69if (!File.Exists(path)) 76File.Delete(path); 83File.Move(path, renamedPath); 126File.Delete(oldFile);

20return await File.ReadAllTextAsync(path, cancellationToken).ConfigureAwait(false); 35return await File.ReadAllBytesAsync(path, cancellationToken).ConfigureAwait(false);

27return File.Exists(_sentinelFilePath); 45File.WriteAllText(_sentinelFilePath, string.Empty);

107return Directory.Exists(path) || File.Exists(path); 118var attributes = File.GetAttributes(path); 154var attributes = File.GetAttributes(path); 188var attributes = File.GetAttributes(path); 197File.Delete(path); 236if (File.Exists(path)) 238File.Delete(path);

76if (!File.Exists(assetsPath)) 139if (File.Exists(destPath) && 140File.GetLastWriteTimeUtc(sourcePath) <= File.GetLastWriteTimeUtc(destPath)) 150File.Copy(sourcePath, destPath, overwrite: true);

52if (!File.Exists(assetsPath)) 201if (!File.Exists(sourcePath)) 215if (File.Exists(xmlSourcePath)) 260if (runtimeIdentifierGraphPath is not null && File.Exists(runtimeIdentifierGraphPath)) 282using var stream = File.OpenRead(assetsPath); 333if (!File.Exists(sourcePath)) 364if (!File.Exists(sourcePath)) 405if (!File.Exists(sourcePath))

335if (File.Exists(graphPath)) 342using var fileStream = File.Create(graphPath);

181if (!string.IsNullOrEmpty(configPath) && File.Exists(configPath))

138if (File.Exists(dcpExePath)) 169if (File.Exists(managedExe)) 282return File.Exists(managedPath) ? managedPath : null;

112if (!File.Exists(normalizedManifestPath)) 117using var stream = File.OpenRead(normalizedManifestPath); 173return File.WriteAllBytesAsync(path, stream.ToArray(), cancellationToken); 341if (!File.Exists(normalizedPath))

345contents = File.ReadAllText(statPath);

32await File.WriteAllTextAsync(binaryPath, "#!/bin/bash\necho \"aspire mock v1.0\"\n"); 49await File.WriteAllTextAsync(checksumPath, hashHex); 67await File.WriteAllTextAsync(path, "fake-nupkg-content"); 74await File.WriteAllTextAsync(archive.ChecksumPath, "0000000000000000000000000000000000000000000000000000000000000000"); 117await File.WriteAllTextAsync(binaryPath, FakeVerifyAspireScript); 126await File.WriteAllTextAsync(sidecarPath, "{\"source\":\"stray\"}"); 132await File.WriteAllTextAsync(checksumPath, hashHex); 194await using var fileStream = File.Create(archivePath); 213using var stream = File.OpenRead(filePath);

18File.SetUnixFileMode(path,

64if (!File.Exists(fullScriptPath)) 114File.WriteAllText(tempScript, wrapperContent); 157File.WriteAllText(tempScript, scriptContent);

185if (!File.Exists(filePath)) 192var content = await File.ReadAllBytesAsync(filePath);

70if (!File.Exists(fullScriptPath))

277await File.WriteAllTextAsync(tempGhScriptPath, scriptContent); 284File.Move(tempGhScriptPath, ghScriptPath, overwrite: true);

18var source = File.ReadAllText(GetRepoPath(GetScriptPath(scriptPathName))); 30var source = File.ReadAllText(GetRepoPath(GetScriptPath(scriptPathName))); 43var source = File.ReadAllText(GetRepoPath(ScriptPaths.LocalHiveShell)); 55var source = File.ReadAllText(GetRepoPath(ScriptPaths.LocalHivePowerShell)); 69var source = File.ReadAllText(GetRepoPath(GetScriptPath(scriptPathName))); 84var source = File.ReadAllText(GetRepoPath(ScriptPaths.LocalHivePowerShell));

231File.WriteAllText(Path.Combine(tempDir, "artifact.tar.gz"), "fake"); 251File.WriteAllText(Path.Combine(tempDir, "artifact.tar.gz"), "fake"); 271File.WriteAllText(Path.Combine(tempDir, "artifact.tar.gz"), "fake"); 373File.WriteAllText(configFile, "# existing config\n"); 387var contents = File.ReadAllText(configFile);

57Assert.True(File.Exists(Path.Combine(binDir, "aspire")), $"CLI binary missing under {binDir}"); 60Assert.True(File.Exists(sidecarPath), $"Route sidecar missing at {sidecarPath}"); 62var sidecarContent = await File.ReadAllTextAsync(sidecarPath, cancellationToken);

37await File.WriteAllTextAsync(Path.Combine(root, "aspire.rb"), "cask \"aspire\" do\n version \"13.3.0\"\nend\n"); 38await File.WriteAllTextAsync(Path.Combine(root, "dogfood.sh"), "#!/usr/bin/env bash\nexit 0\n"); 47await File.WriteAllTextAsync(Path.Combine(root, "Microsoft.Aspire.installer.yaml"), "PackageIdentifier: Microsoft.Aspire\nPackageVersion: 13.3.0\nInstallers: []\n"); 48await File.WriteAllTextAsync(Path.Combine(root, "dogfood.ps1"), "exit 0\n"); 94await File.WriteAllTextAsync(Path.Combine(manifestDir, "Microsoft.Aspire.installer.yaml"), installerYaml); 95await File.WriteAllTextAsync(Path.Combine(manifestDir, "Microsoft.Aspire.yaml"), $"PackageIdentifier: Microsoft.Aspire\nPackageVersion: {version}\nManifestType: version\nManifestVersion: 1.10.0\n"); 96await File.WriteAllTextAsync(Path.Combine(manifestDir, "Microsoft.Aspire.locale.en-US.yaml"), $"PackageIdentifier: Microsoft.Aspire\nPackageVersion: {version}\nPackageLocale: en-US\nManifestType: defaultLocale\nManifestVersion: 1.10.0\n"); 97await File.WriteAllTextAsync(Path.Combine(manifestDir, "dogfood.ps1"), "exit 0\n"); 121await File.WriteAllTextAsync(brewPath, $$""" 195await File.WriteAllTextAsync(curlPath, """ 235await File.WriteAllTextAsync(implPath, $$""" 370await File.WriteAllTextAsync(wingetCmd, """ 376await File.WriteAllTextAsync(aspireCmd, $$""" 388await File.WriteAllTextAsync(Path.Combine(root, "aspire-cli-osx-arm64-13.3.0.tar.gz"), "fake arm64 archive"); 389await File.WriteAllTextAsync(Path.Combine(root, "aspire-cli-osx-x64-13.3.0.tar.gz"), "fake x64 archive"); 405var bytes = await File.ReadAllBytesAsync(path); 422if (File.Exists(path)) 424File.Delete(path); 427await using var fs = File.Create(path); 581await File.WriteAllTextAsync(caskPath, "cask \"aspire\" do\n version \"13.3.0\"\nend\n"); 616var brewLog = await File.ReadAllTextAsync(Path.Combine(env.TempDirectory, "brew.log")); 642var cask = await File.ReadAllTextAsync(Path.Combine(outputDir, "aspire.rb")); 649Assert.True(File.Exists(Path.Combine(outputDir, "dogfood.sh"))); 658var brewLog = await File.ReadAllTextAsync(Path.Combine(env.TempDirectory, "brew.log")); 772var installerManifest = await File.ReadAllTextAsync(Path.Combine(outputDir, "Microsoft.Aspire.installer.yaml")); 781var localeManifest = await File.ReadAllTextAsync(Path.Combine(outputDir, "Microsoft.Aspire.locale.en-US.yaml")); 783Assert.True(File.Exists(Path.Combine(outputDir, "Microsoft.Aspire.yaml"))); 784Assert.True(File.Exists(Path.Combine(outputDir, "dogfood.ps1"))); 801var wingetLog = await File.ReadAllTextAsync(Path.Combine(env.TempDirectory, "winget.log")); 848var wingetLog = await File.ReadAllTextAsync(Path.Combine(env.TempDirectory, "winget.log")); 853var originalInstaller = await File.ReadAllTextAsync(Path.Combine(manifestDir, "Microsoft.Aspire.installer.yaml")); 921var installerYaml = await File.ReadAllTextAsync(Path.Combine(outputDir, "Microsoft.Aspire.installer.yaml")); 932Assert.True(File.Exists(expected), 954File.Delete(x64Archive); 955await using (var fs = File.Create(x64Archive))

215await File.WriteAllTextAsync(Path.Combine(localDir, "aspire"), "#!/bin/sh\necho fake\n"); 477File.Exists(sidecarPath), 573File.Exists(sidecarPath), 588Assert.False(File.Exists(globalConfig), $"Unexpected global config at {globalConfig}"); 621Assert.False(File.Exists(binSidecar), $"--local-dir install must not write sidecar at {binSidecar} (unmanaged route).");

104Assert.Contains(cliBinDir, await File.ReadAllLinesAsync(githubPath)); 262File.WriteAllText(Path.Combine(tempDir, "artifact.tar.gz"), "fake"); 282File.WriteAllText(Path.Combine(tempDir, "artifact.tar.gz"), "fake"); 302File.WriteAllText(Path.Combine(tempDir, "artifact.tar.gz"), "fake"); 326await File.WriteAllTextAsync(Path.Combine(downloadDir, "README.txt"), "no archive here"); 348await File.WriteAllTextAsync(Path.Combine(downloadDir, "aspire-cli-linux-x64.tar.gz"), "fake1"); 349await File.WriteAllTextAsync(Path.Combine(downloadDir, "aspire-cli-osx-arm64.tar.gz"), "fake2");

173await File.WriteAllTextAsync(Path.Combine(localDir, "aspire"), "#!/bin/sh\necho fake\n"); 552File.Exists(sidecarPath), 636File.Exists(sidecarPath), 651Assert.False(File.Exists(globalConfig), $"Unexpected global config at {globalConfig}"); 686Assert.False(File.Exists(binSidecar), $"--local-dir install must not write sidecar at {binSidecar} (unmanaged route)."); 728File.Exists(sidecarPath),

120await File.WriteAllTextAsync(dotnetScriptPath, scriptContent); 407var dotnetCommands = await File.ReadAllTextAsync(dotnetCommandsPath, TestContext.Current.CancellationToken); 436var dotnetCommands = await File.ReadAllTextAsync(dotnetCommandsPath, TestContext.Current.CancellationToken); 446Assert.True(File.Exists(Path.Combine(prHive, "Aspire.Hosting.13.3.0-pr.5678.deadbeef.nupkg")), 476var dotnetCommands = await File.ReadAllTextAsync(dotnetCommandsPath, TestContext.Current.CancellationToken); 507Assert.False(File.Exists(sidecarPath), $"Tool mode must not write the PR-route sidecar at {sidecarPath}."); 512Assert.True(File.Exists(Path.Combine(prHive, "Aspire.Hosting.13.3.0-pr.5678.deadbeef.nupkg")), 515var dotnetCommands = await File.ReadAllTextAsync(dotnetCommandsPath, TestContext.Current.CancellationToken); 631await File.WriteAllTextAsync(Path.Combine(pkgDir, "Aspire.Cli.13.3.0-pr.5678.deadbeef.symbols.nupkg"), "fake-symbols-nupkg-content"); 632await File.WriteAllTextAsync(Path.Combine(pkgDir, "Aspire.Cli.13.3.0-pr.5678.deadbeef.snupkg"), "fake-symbols-package-content"); 634await File.WriteAllTextAsync(Path.Combine(pkgDir, "Aspire.Cli.13_3_0.nupkg"), "fake-invalid-version-content"); 657await File.WriteAllTextAsync(Path.Combine(pkgDir, "Aspire.Cli.1_0.nupkg"), "fake-invalid-version-content"); 983var dotnetCommands = await File.ReadAllTextAsync(dotnetCommandsPath, TestContext.Current.CancellationToken); 1012var dotnetCommands = await File.ReadAllTextAsync(dotnetCommandsPath, TestContext.Current.CancellationToken); 1022Assert.True(File.Exists(Path.Combine(prHive, "Aspire.Hosting.13.3.0-pr.5678.deadbeef.nupkg")), 1051Assert.False(File.Exists(sidecarPath), $"Tool mode must not write the PR-route sidecar at {sidecarPath}."); 1056Assert.True(File.Exists(Path.Combine(prHive, "Aspire.Hosting.13.3.0-pr.5678.deadbeef.nupkg")), 1059var dotnetCommands = await File.ReadAllTextAsync(dotnetCommandsPath, TestContext.Current.CancellationToken); 1158await File.WriteAllTextAsync(Path.Combine(pkgDir, "Aspire.Cli.13.3.0-pr.5678.deadbeef.symbols.nupkg"), "fake-symbols-nupkg-content"); 1159await File.WriteAllTextAsync(Path.Combine(pkgDir, "Aspire.Cli.13.3.0-pr.5678.deadbeef.snupkg"), "fake-symbols-package-content"); 1161await File.WriteAllTextAsync(Path.Combine(pkgDir, "Aspire.Cli.13_3_0.nupkg"), "fake-invalid-version-content"); 1183await File.WriteAllTextAsync(Path.Combine(pkgDir, "Aspire.Cli.1_0.nupkg"), "fake-invalid-version-content");

316Assert.True(File.Exists(Path.Combine(destPath, "aspire")), 337Assert.True(File.Exists(Path.Combine(destPath, "aspire.exe")), 439await File.WriteAllTextAsync(cliPath, ($$""" 455Assert.Equal("setup", (await File.ReadAllTextAsync(capturePath)).Trim()); 513File.WriteAllText(Path.Combine(env.MockHome, ".bashrc"), "# existing config\n"); 525var bashrcContent = File.ReadAllText(Path.Combine(env.MockHome, ".bashrc")); 537File.WriteAllText(Path.Combine(env.MockHome, ".zshrc"), "# existing config\n"); 549var zshrcContent = File.ReadAllText(Path.Combine(env.MockHome, ".zshrc")); 562File.WriteAllText( 576var bashrcContent = File.ReadAllText(Path.Combine(env.MockHome, ".bashrc")); 613await File.WriteAllTextAsync(mockCurl, 650await File.WriteAllTextAsync(mockCurl,

198await File.ReadAllBytesAsync(Path.Combine(installPath, ".aspire-install.json"))); 221await File.WriteAllTextAsync(sidecarPath, """{"source":"old"}"""); 235using var document = JsonDocument.Parse(await File.ReadAllBytesAsync(sidecarPath)); 276await File.ReadAllBytesAsync(Path.Combine(installPath, ".aspire-install.json"))); 365File.Exists(globalConfig), 387File.Exists(configPath), 410File.Exists(sidecarPath), 428File.Exists(sidecarPath),

283Assert.True(File.Exists(Path.Combine(destPath, "aspire")), 304Assert.True(File.Exists(Path.Combine(destPath, "aspire.exe")), 421await File.WriteAllTextAsync(cliPath, contents.ReplaceLineEndings(OperatingSystem.IsWindows() ? "\r\n" : "\n")); 424File.SetUnixFileMode(cliPath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 437Assert.Equal("setup", (await File.ReadAllTextAsync(capturePath)).Trim()); 463Assert.False(File.Exists(cliPath));

153await File.ReadAllBytesAsync(Path.Combine(installPath, ".aspire-install.json"))); 182Assert.True(File.Exists(Path.Combine(installPath, ".aspire-install.json"))); 212await File.ReadAllBytesAsync(Path.Combine(installPath, ".aspire-install.json"))); 299File.Exists(globalConfig), 321File.Exists(configPath), 344File.Exists(sidecarPath), 364File.Exists(sidecarPath),

14if (Directory.Exists(Path.Combine(repoRoot.FullName, ".git")) || File.Exists(Path.Combine(repoRoot.FullName, ".git")))

105File.WriteAllText(configPath, """{"mcpServers":{"aspire":{"command":"aspire","args":["mcp","start"]}}}"""); 108var fileContent = File.ReadAllText(configPath); 128fileContent = File.ReadAllText(configPath); 157File.WriteAllText(configPath, """{"mcpServers":{"aspire":{"command":"aspire","args":["mcp","start"]}}}"""); 216var fileContent = File.ReadAllText(skillFilePath); 219var deploymentFileContent = File.ReadAllText(deploymentSkillFilePath); 266Assert.True(File.Exists(skillFile), $"Expected {skillName} SKILL.md at {skillFile}"); 267Assert.Contains($"name: {skillName}", File.ReadAllText(skillFile));

38var content = File.ReadAllText(appHostFilePath); 43File.WriteAllText(appHostFilePath, modified);

145var recordingOffset = File.Exists(recordingPath) ? new FileInfo(recordingPath).Length : 0; 259File.WriteAllText(Path.Combine(projectDirectory, "BrokenDotNetApp.csproj"), $$""" 270File.WriteAllText(appHostPath, """ 282File.WriteAllText(Path.Combine(projectDirectory, "MissingSdkAppHost.csproj"), """ 294var firstLine = File.ReadLines(appHostPath).First(); 304File.WriteAllText(Path.Combine(projectDirectory, "apphost.mts"), "const value = ;");

71Assert.True(File.Exists(appHostProjectPath), $"Expected AppHost project file to exist at: {appHostProjectPath}"); 72Assert.True(File.Exists(appHostSourcePath), $"Expected AppHost source file to exist at: {appHostSourcePath}"); 74var appHostProject = File.ReadAllText(appHostProjectPath); 78File.WriteAllText( 102Assert.True(File.Exists(argsOutputPath), $"Expected AppHost to write forwarded args to: {argsOutputPath}"); 103Assert.Equal("--from-dotnet-run", File.ReadAllText(argsOutputPath)); 136Assert.True(File.Exists(appHostProjectPath), $"Expected AppHost project file to exist at: {appHostProjectPath}"); 137Assert.True(File.Exists(appHostSourcePath), $"Expected AppHost source file to exist at: {appHostSourcePath}"); 139var appHostProject = File.ReadAllText(appHostProjectPath); 147File.WriteAllText(appHostProjectPath, appHostProject); 149var appHostSource = File.ReadAllText(appHostSourcePath); 150File.WriteAllText( 197Assert.True(File.Exists(argsOutputPath), $"Expected AppHost to write forwarded args to: {argsOutputPath}"); 198Assert.Equal("--from-real-dnx", File.ReadAllText(argsOutputPath)); 227Assert.True(File.Exists(appHostSourcePath), $"Expected AppHost source file to exist at: {appHostSourcePath}"); 229var appHostSource = File.ReadAllText(appHostSourcePath); 230var sdkDirective = File.ReadLines(appHostSourcePath).First(); 235File.WriteAllText( 258Assert.True(File.Exists(argsOutputPath), $"Expected AppHost to write forwarded args to: {argsOutputPath}"); 259Assert.Equal("--from-dotnet-run-file", File.ReadAllText(argsOutputPath));

52File.WriteAllText(appHostCsprojPath, """ 66File.WriteAllText(Path.Combine(appHostDir, "Program.cs"), """ 71File.WriteAllText(directoryPackagesPropsPath, """ 95var content = File.ReadAllText(directoryPackagesPropsPath); 166File.WriteAllText(appHostCsprojPath, """ 177File.WriteAllText(Path.Combine(appHostDir, "Program.cs"), """ 183File.WriteAllText(directoryPackagesPropsPath, """ 203var migratedCsproj = File.ReadAllText(appHostCsprojPath); 218File.WriteAllText(directoryPackagesPropsPath, $$""" 244var content = File.ReadAllText(directoryPackagesPropsPath); 287File.WriteAllText(appHostCsprojPath, """ 297File.WriteAllText(Path.Combine(appHostDir, "Program.cs"), """ 302File.WriteAllText(directoryPackagesPropsPath, """

138await File.WriteAllTextAsync(appHostPath, 488if (!File.Exists(aspireConfigPath)) 493using var doc = JsonDocument.Parse(File.ReadAllText(aspireConfigPath)); 502if (!File.Exists(aspireConfigPath)) 507using var doc = JsonDocument.Parse(File.ReadAllText(aspireConfigPath)); 526if (!File.Exists(aspireConfigPath)) 531using var doc = JsonDocument.Parse(File.ReadAllText(aspireConfigPath));

59Assert.True(File.Exists(primaryConfigPath), $"Expected Primary config at: {primaryConfigPath}"); 60Assert.True(File.Exists(alternateConfigPath), $"Expected Alternate config at: {alternateConfigPath}"); 61Assert.True(File.Exists(alternateAppHostPath), $"Expected Alternate AppHost source file to exist at: {alternateAppHostPath}"); 65File.Delete(primaryConfigPath); 66File.Delete(alternateConfigPath); 71var alternateAppHostSource = File.ReadAllText(alternateAppHostPath); 73File.WriteAllText( 93File.WriteAllBytes(workspaceConfigPath, originalWorkspaceConfigBytes); 123Assert.True(File.Exists(alternateRunMarkerPath), $"Expected the Alternate AppHost to run and write: {alternateRunMarkerPath}"); 124Assert.Equal("alternate", File.ReadAllText(alternateRunMarkerPath)); 125Assert.Equal(originalWorkspaceConfigBytes, File.ReadAllBytes(workspaceConfigPath)); 126Assert.False(File.Exists(alternateConfigPath), $"Explicit alternate AppHost should not create a local config at: {alternateConfigPath}"); 167Assert.True(File.Exists(projectConfigPath), 170var originalContent = File.ReadAllText(projectConfigPath); 200Assert.False(File.Exists(parentConfigPath), 205Assert.True(File.Exists(projectConfigPath), 208var currentContent = File.ReadAllText(projectConfigPath);

61File.WriteAllText(configFilePath, malformedConfig); 76if (!File.Exists(configFilePath)) 82var content = File.ReadAllText(configFilePath);

63if (!File.Exists(filePath)) 68var content = File.ReadAllText(filePath); 85if (!File.Exists(filePath)) 90var content = File.ReadAllText(filePath); 128File.WriteAllText(legacyPath, 132if (File.Exists(newConfigPath)) 134File.Delete(newConfigPath); 191File.WriteAllText(newConfigPath, 193File.WriteAllText(legacyPath, 234File.WriteAllText( 238if (File.Exists(newConfigPath)) 240File.Delete(newConfigPath); 291File.WriteAllText(legacyPath, 302if (File.Exists(newConfigPath)) 304File.Delete(newConfigPath); 363if (File.Exists(f)) 365File.Delete(f); 397if (File.Exists(legacyPath)) 441File.WriteAllText(legacyPath, 456if (File.Exists(newConfigPath)) 458File.Delete(newConfigPath);

58Assert.True(File.Exists(appHostCs), $"Expected apphost.cs to exist at: {appHostCs}"); 59Assert.True(File.Exists(aspireConfigJson), $"Expected aspire.config.json to exist at: {aspireConfigJson}"); 61var configText = await File.ReadAllTextAsync(aspireConfigJson);

68File.WriteAllText(solutionPath, "Fake solution file"); 89File.Exists(workspaceNuGetConfig), 92Assert.True(File.Exists(appHostCsproj), $"Expected AppHost csproj at: {appHostCsproj}"); 140File.WriteAllText(solutionPath, "Fake solution file"); 144File.WriteAllText(leftoverPath, LeftoverContent); 161File.Exists(workspaceNuGetConfig), 165Assert.True(File.Exists(leftoverPath), $"Pre-existing AppHost file should be preserved: {leftoverPath}"); 166Assert.Equal(LeftoverContent, File.ReadAllText(leftoverPath));

117var content = File.ReadAllText(appHostFilePath); 136File.WriteAllText(appHostFilePath, content);

63var content = File.ReadAllText(appHostFilePath); 75File.WriteAllText(appHostFilePath, content); 163var content = File.ReadAllText(appHostFilePath); 175File.WriteAllText(appHostFilePath, content);

21File.WriteAllText(docsFilePath, """

115File.Delete(recordingPath); 127var recordingOffset = File.Exists(recordingPath) ? new FileInfo(recordingPath).Length : 0;

312if (!File.Exists(csprojPath)) 318var content = File.ReadAllText(csprojPath); 327if (!File.Exists(csprojPath)) 337var content = File.ReadAllText(csprojPath); 351if (!File.Exists(configPath)) 356using var document = JsonDocument.Parse(File.ReadAllText(configPath)); 371if (!File.Exists(configPath)) 379using var document = JsonDocument.Parse(File.ReadAllText(configPath));

225if (!File.Exists(csprojPath)) 231var content = File.ReadAllText(csprojPath); 240if (!File.Exists(configPath)) 245using var document = JsonDocument.Parse(File.ReadAllText(configPath));

272$"Dropped NuGet.config ({configPath}) does not contain a package source for the staging feed '{feedFragment}'. Content:\n{File.ReadAllText(configPath)}"); 284$"Dropped NuGet.config ({configPath}) does not map the 'Aspire*' pattern to the staging feed '{feedFragment}'. Content:\n{File.ReadAllText(configPath)}"); 289if (!File.Exists(csprojPath)) 295var content = File.ReadAllText(csprojPath); 308if (!File.Exists(configPath)) 313using var document = System.Text.Json.JsonDocument.Parse(File.ReadAllText(configPath)); 335if (!File.Exists(configPath)) 340using var document = System.Text.Json.JsonDocument.Parse(File.ReadAllText(configPath));

135var targetRuntime = File.ReadAllText(targetRuntimePath).Trim(); 136File.Delete(targetRuntimePath); 157File.WriteAllText( 208File.WriteAllText(

74File.Exists(filePath)) 107File.Exists(filePath))

607if (File.Exists(Path.Combine(dir.FullName, "Aspire.slnx"))) 1114var config = File.Exists(configPath) 1115? JsonNode.Parse(File.ReadAllText(configPath))?.AsObject() ?? new JsonObject() 1124File.WriteAllText(configPath, config.ToJsonString()); 1169File.Copy(sourcePath, destFile, overwrite: true); 1195File.Copy(file, destFile, overwrite: true);

480File.WriteAllText(Path.Combine(tempDir.FullName, "Aspire.Cli.13.3.0-preview.1.25175.1.nupkg"), ""); 481File.WriteAllText(Path.Combine(tempDir.FullName, "Aspire.Cli.linux-x64.13.3.0-preview.1.25175.1.nupkg"), ""); 777File.WriteAllText(Path.Combine(tempDir.FullName, "Aspire.Cli.13.3.0-preview.1.12345.1.nupkg"), ""); 795File.WriteAllText(Path.Combine(tempDir.FullName, "Aspire.Cli.linux-x64.13.3.0.nupkg"), ""); 813File.WriteAllText(Path.Combine(tempDir.FullName, "Aspire.Cli.13.3.0.nupkg"), ""); 814File.WriteAllText(Path.Combine(tempDir.FullName, "Aspire.Cli.13.4.0.nupkg"), ""); 833File.WriteAllText(Path.Combine(tempDir.FullName, "Aspire.Cli.linux-x64.13.3.0.nupkg"), "");

13Assert.True(File.Exists(gitIgnorePath), $"Expected generated .gitignore at {gitIgnorePath}"); 15var gitIgnoreLines = File.ReadAllLines(gitIgnorePath);

340File.WriteAllText(Path.Combine(appHostDir, "AppHost.cs"), appHostCode); 341File.WriteAllText(Path.Combine(apiDir, "Program.cs"), apiProgramCode);

129File.Copy(file, Path.Combine(destination, Path.GetFileName(file)), overwrite: true);

23File.Copy(file, Path.Combine(destination, Path.GetFileName(file)));

37var packageJson = JsonNode.Parse(File.ReadAllText(packageJsonPath))?.AsObject() 41File.WriteAllText(packageJsonPath, $"{packageJson.ToJsonString(s_packageJsonSerializerOptions)}{Environment.NewLine}"); 52if (File.Exists(lockFilePath)) 54File.Delete(lockFilePath); 160File.WriteAllText(yarnConfigPath, $"{YarnNodeModulesConfiguration}{Environment.NewLine}"); 163if (!File.Exists(yarnLockPath)) 167File.WriteAllText(yarnLockPath, string.Empty); 170else if (File.Exists(yarnConfigPath)) 172File.Delete(yarnConfigPath);

64var initialCodegenHash = File.Exists(codegenHashPath) ? File.ReadAllText(codegenHashPath) : null; 67if (File.Exists(builderPath) && File.ReadAllText(builderPath).Contains("addSqlServer")) 97if (!File.Exists(filePath)) 102var content = File.ReadAllText(filePath); 109var builderJava = File.ReadAllText(Path.Combine(modulesDir, "aspire", "IDistributedApplicationBuilder.java")); 119var restoredCodegenHash = File.Exists(codegenHashPath) ? File.ReadAllText(codegenHashPath) : null;

86File.WriteAllText(appHostPath, newContent);

68File.WriteAllText(appHostPath, newContent);

146File.WriteAllText(appHostPath, """ 179File.WriteAllText(appHostPath, $$""" 220File.WriteAllText(Path.Combine(appDir, "package.json"), $$""" 235File.WriteAllText(Path.Combine(appDir, "yarn.lock"), $$""" 252File.WriteAllText(Path.Combine(appDir, "server.js"), $$""" 277File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "verify-runtime.sh"), $$""" 330File.Copy(file, Path.Combine(workspace.WorkspaceRoot.FullName, Path.GetFileName(file)));

81var content = File.ReadAllText(appHostFilePath); 107File.WriteAllText(appHostFilePath, content);

103var appHostContent = File.ReadAllText(appHostFilePath); 137File.WriteAllText(appHostFilePath, appHostContent); 146var apiIndexContent = File.ReadAllText(apiIndexFilePath); 182File.WriteAllText(apiIndexFilePath, apiIndexContent);

92var content = File.ReadAllText(appHostFilePath); 96File.WriteAllText(appHostFilePath, content);

139var content = File.ReadAllText(appHostFilePath); 151File.WriteAllText(appHostFilePath, content); 346File.WriteAllText(

27File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "LaunchProfile.sln"), "Fake solution file"); 45Assert.True(File.Exists(appHostSourcePath), $"Expected AppHost source file to exist at: {appHostSourcePath}"); 46Assert.True(File.Exists(launchSettingsPath), $"Expected launch settings to exist at: {launchSettingsPath}"); 48File.WriteAllText( 62File.WriteAllText( 97Assert.True(File.Exists(profileOutputPath), $"Expected AppHost to write selected profile details to: {profileOutputPath}"); 98Assert.Equal("selected-profile|E2E|--profile-argument|selected-profile", File.ReadAllText(profileOutputPath));

91while (!File.Exists(configPath) && DateTime.UtcNow < deadline) 103Assert.True(File.Exists(configPath), "aspire.config.json was not created by migration"); 104var content = File.ReadAllText(configPath); 147content = File.ReadAllText(configPath);

32if (!File.Exists(cliProjectPath))

67Assert.True(File.Exists(nugetConfigPath), 72Assert.False(File.Exists(nugetConfigPath),

58var content = File.ReadAllText(appHostFilePath); 67File.WriteAllText(appHostFilePath, content);

70var content = File.ReadAllText(appHostFilePath); 81File.WriteAllText(appHostFilePath, content);

49var configJson = File.ReadAllText(configPath); 57File.WriteAllText(Path.Combine(integrationDir, "MyIntegration.csproj"), $$""" 97File.WriteAllText(Path.Combine(workDir, "nuget.config"), nugetConfig); 100File.WriteAllText(Path.Combine(integrationDir, "MyIntegrationExtensions.cs"), """ 123File.WriteAllText(configPath, updatedJson); 133File.WriteAllText(Path.Combine(workDir, "apphost.mts"), """

109var content = File.ReadAllText(outputFilePath).Trim();

119var content = File.ReadAllText(appHostFilePath); 129File.WriteAllText(appHostFilePath, content); 145Assert.True(File.Exists(appBicepPath), $"Expected generated Bicep at '{appBicepPath}'."); 146var appBicep = File.ReadAllText(appBicepPath);

84var content = File.ReadAllText(appHostFilePath); 92File.WriteAllText(appHostFilePath, content); 115Assert.True(File.Exists(appBicepPath), $"Expected generated Bicep at '{appBicepPath}'."); 116var appBicep = File.ReadAllText(appBicepPath); 127Assert.True(File.Exists(bicepConfigPath), $"Expected generated bicepconfig.json at '{bicepConfigPath}'."); 133using var bicepConfig = JsonDocument.Parse(File.ReadAllText(bicepConfigPath));

41var content = File.ReadAllText(appHostFilePath); 54File.WriteAllText(appHostFilePath, newContent); 139var content = File.ReadAllText(appHostFilePath); 184File.WriteAllText(appHostFilePath, newContent); 236var content = File.ReadAllText(appHostFilePath); 265File.WriteAllText(appHostFilePath, newContent); 344var content = File.ReadAllText(appHostFilePath); 366File.WriteAllText(appHostFilePath, newContent);

27await File.WriteAllTextAsync( 69using var document = JsonDocument.Parse(await File.ReadAllTextAsync(

49File.WriteAllText(configPath, createdConfig.ToJsonString()); 92return JsonNode.Parse(File.ReadAllText(path))?.AsObject()

70Assert.True(File.Exists(appHostCs), $"Expected apphost.cs to exist at: {appHostCs}"); 71Assert.True(File.Exists(aspireConfigJson), $"Expected aspire.config.json to exist at: {aspireConfigJson}"); 72Assert.Contains("#:property AspireUseCliBundle=true", File.ReadAllText(appHostCs)); 74File.Exists(appHostRunJson), 83var runJson = JsonNode.Parse(File.ReadAllText(appHostRunJson))?.AsObject();

170if (!File.Exists(appHostPath)) 184if (!File.Exists(appHostPath)) 189var appHostContent = File.ReadAllText(appHostPath); 198if (!File.Exists(configPath)) 205using var config = JsonDocument.Parse(File.ReadAllText(configPath));

250File.WriteAllText(assertionScript, $$""" 480using var document = JsonDocument.Parse(File.ReadAllText(path));

44var content = File.ReadAllText(appHostFilePath); 47File.WriteAllText(appHostFilePath, $$"""

36var appHostContent = File.ReadAllText(appHostPath); 48File.WriteAllText(appHostPath, appHostContent.Replace(oldFrontendLine, newFrontendLine, StringComparison.Ordinal));

13while (directory != null && !Directory.Exists(Path.Combine(directory, ".git")) && !File.Exists(Path.Combine(directory, ".git")))

297if (!File.Exists(archivePath))

241File.WriteAllText(settingsPath, "{}");

78await File.WriteAllTextAsync(appHostPath, """ 128await File.WriteAllTextAsync(verificationScriptPath, verificationScript.ReplaceLineEndings("\n"));

82if (!File.Exists(lockFilePath)) 103if (!File.Exists(filePath)) 108var content = File.ReadAllText(filePath); 115var aspireTs = File.ReadAllText(Path.Combine(modulesDir, "aspire.mts")); 171if (!File.Exists(aspireModulePath)) 176var initialAspireTs = File.ReadAllText(aspireModulePath); 188var initialCodegenHash = File.Exists(codegenHashPath) ? File.ReadAllText(codegenHashPath) : null; 207if (!File.Exists(filePath)) 212var content = File.ReadAllText(filePath); 219var restoredAspireTs = File.ReadAllText(aspireModulePath); 226var configJson = File.ReadAllText(configPath); 232var restoredCodegenHash = File.Exists(codegenHashPath) ? File.ReadAllText(codegenHashPath) : null; 239File.WriteAllText(appHostPath, """ 317File.WriteAllText(appHostPath, newContent); 396File.WriteAllText(appHostPath, newContent);

41var appHostContents = await File.ReadAllTextAsync(appHostPath, TestContext.Current.CancellationToken); 58await File.WriteAllTextAsync(appHostPath, appHostContents, TestContext.Current.CancellationToken); 108File.WriteAllText(Path.Combine(extensionDirectory.FullName, "DeadlockExtension.csproj"), $$""" 123File.WriteAllText(Path.Combine(extensionDirectory.FullName, "DeadlockExtensions.cs"), """ 163File.WriteAllText(Path.Combine(appDirectory, "apphost.mts"), """ 178var config = JsonNode.Parse(File.ReadAllText(configPath))?.AsObject() 184File.WriteAllText(configPath, config.ToJsonString(new JsonSerializerOptions { WriteIndented = true })); 190using var doc = JsonDocument.Parse(File.ReadAllText(configPath));

109if (File.Exists(mtsPath)) 111File.Delete(mtsPath); 123File.WriteAllText(Path.Combine(projectRoot, "apphost.ts"), """ 136var configJson = JsonNode.Parse(File.ReadAllText(configPath))!.AsObject(); 139File.WriteAllText( 146File.WriteAllText(Path.Combine(projectRoot, "tsconfig.apphost.json"), """ 192if (!File.Exists(filePath)) 197var content = File.ReadAllText(filePath); 219if (File.Exists(filePath)) 230var aspireTs = File.ReadAllText(Path.Combine(legacyModulesDir, "aspire.ts"));

99if (File.Exists(mtsPath)) 101File.Delete(mtsPath); 112File.WriteAllText(Path.Combine(projectRoot, "apphost.ts"), """ 123var configJson = JsonNode.Parse(File.ReadAllText(configPath))!.AsObject(); 126File.WriteAllText( 130File.WriteAllText(Path.Combine(projectRoot, "tsconfig.apphost.json"), """ 158if (File.Exists(legacyAppHost)) 166if (!File.Exists(modernAppHost)) 172var appHostContent = File.ReadAllText(modernAppHost); 199if (!File.Exists(filePath)) 206var aspireMts = File.ReadAllText(Path.Combine(modernModulesDir, "aspire.mts")); 215var tsconfig = JsonNode.Parse(File.ReadAllText(Path.Combine(projectRoot, "tsconfig.apphost.json")))!.AsObject();

92File.WriteAllText(appHostPath, newContent);

111File.WriteAllText(appHostPath, newContent); 123File.Exists(appHostLockFilePath), 130File.Exists(viteLockFilePath), 207File.WriteAllText(appHostPath, """ 229File.Exists(appHostLockFilePath), 236File.Exists(guestLockFilePath), 285File.Exists(lockFilePath), 330File.WriteAllText( 353var packageJson = JsonNode.Parse(File.ReadAllText(Path.Combine(projectRoot, "package.json")))!.AsObject(); 359originalTsConfig = File.ReadAllText(Path.Combine(projectRoot, "tsconfig.json")); 361File.WriteAllText(Path.Combine(projectRoot, "package.json"), packageJson.ToJsonString(new JsonSerializerOptions { WriteIndented = true })); 384packageJson = JsonNode.Parse(File.ReadAllText(Path.Combine(projectRoot, "package.json")))!.AsObject(); 401Assert.Equal(originalTsConfig, File.ReadAllText(Path.Combine(projectRoot, "tsconfig.json"))); 402Assert.False(File.Exists(Path.Combine(projectRoot, "tsconfig.apphost.json"))); 403Assert.False(File.Exists(Path.Combine(projectRoot, "apphost.mts"))); 407Assert.True(File.Exists(appHostPath)); 409var appHostPackageJson = JsonNode.Parse(File.ReadAllText(Path.Combine(appHostDirectory, "package.json")))!.AsObject(); 421Assert.True(File.Exists(Path.Combine(appHostDirectory, "tsconfig.apphost.json"))); 425var config = JsonNode.Parse(File.ReadAllText(configPath))!.AsObject(); 447File.WriteAllText(appHostPath, newContent);

80File.WriteAllText(appHostPath, newContent); 148var composeContent = await File.ReadAllTextAsync(Path.Combine(artifactsPath, "docker-compose.yaml")); 256File.WriteAllText(appHostPath, newContent); 267Assert.True(File.Exists(dockerComposePath), $"Expected docker-compose output at {dockerComposePath}"); 269var dockerComposeContent = await File.ReadAllTextAsync(dockerComposePath); 334File.WriteAllText(appHostPath, newContent); 345Assert.True(File.Exists(envFilePath), $"Expected env file at {envFilePath}"); 347var envFileContent = await File.ReadAllTextAsync(envFilePath); 355File.WriteAllText(appHostPath, """ 395Assert.True(File.Exists(dockerfilePath), $"Expected Dockerfile for resource '{resourceName}' at {dockerfilePath}"); 397var content = File.ReadAllText(dockerfilePath);

45Assert.True(File.Exists(appAppHostPath), $"Expected the CLI-created app to contain {appAppHostPath}."); 58Assert.False(File.Exists(helperAppHostPath), $"Config-only helper package unexpectedly contained {helperAppHostPath}."); 71Assert.Contains("addRedis", File.ReadAllText(Path.Combine(helperModulesDirectory, "aspire.mts"))); 94using var doc = JsonDocument.Parse(File.ReadAllText(configPath)); 101File.WriteAllText(Path.Combine(appDirectory.FullName, "apphost.mts"), """ 113File.WriteAllText(Path.Combine(appDirectory.FullName, "tsconfig.json"), """ 141File.WriteAllText(Path.Combine(helperDirectory.FullName, "aspire.config.json"), $$""" 155File.WriteAllText(Path.Combine(helperDirectory.FullName, "package.json"), """ 171File.WriteAllText(Path.Combine(helperDirectory.FullName, "tsconfig.json"), """ 194File.WriteAllText(Path.Combine(helperSourceDirectory.FullName, "index.ts"), """

55File.WriteAllText(appHostPath, """

60if (!File.Exists(aspireModulePath)) 101if (!File.Exists(configPath)) 106using var doc = JsonDocument.Parse(File.ReadAllText(configPath));

47if (!File.Exists(aspireModulePath))

99Assert.True(File.Exists(appHostCsPath), $"Expected apphost.cs at: {appHostCsPath}"); 100Assert.True(File.Exists(aspireConfigPath), $"Expected aspire.config.json at: {aspireConfigPath}"); 111await File.WriteAllTextAsync(appHostCsPath, 128await File.WriteAllTextAsync(nugetConfigPath, 165var updatedAppHostCs = await File.ReadAllTextAsync(appHostCsPath); 166var updatedNuGetConfig = await File.ReadAllTextAsync(nugetConfigPath);

508=> File.WriteAllText(Path.Combine(directory, InstallSidecarReader.SidecarFileName), json);

73File.WriteAllText(sidecarPath, "{\"source\":\"script\"}"); 74var originalMode = File.GetUnixFileMode(sidecarPath); 78File.SetUnixFileMode(sidecarPath, UnixFileMode.None); 93File.SetUnixFileMode(sidecarPath, originalMode | UnixFileMode.UserRead | UnixFileMode.UserWrite); 105File.WriteAllText(sidecarPath, "{not valid json"); 131File.WriteAllText(Path.Combine(binDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"script\"}"); 279File.WriteAllText(Path.Combine(prDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"pr\"}"); 303File.WriteAllText(Path.Combine(binDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"script\"}"); 328File.WriteAllText(Path.Combine(binDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"script\"}"); 369File.WriteAllText(Path.Combine(prDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"pr\"}"); 403File.WriteAllText(Path.Combine(prDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"pr\"}"); 438File.WriteAllText(Path.Combine(brewDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"brew\"}"); 474File.WriteAllText(Path.Combine(brewDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"brew\"}"); 639var originalMode = File.GetUnixFileMode(dogfoodRoot); 643File.SetUnixFileMode(dogfoodRoot, UnixFileMode.None); 666File.SetUnixFileMode(dogfoodRoot, originalMode | UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 682var originalMode = File.GetUnixFileMode(toolStore); 686File.SetUnixFileMode(toolStore, UnixFileMode.None); 716File.SetUnixFileMode(toolStore, originalMode | UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 765File.WriteAllText(Path.Combine(releaseBinDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"script\"}"); 795File.WriteAllText(Path.Combine(releaseBinDir, InstallSidecarReader.SidecarFileName), "{\"source\":\"localhive\"}"); 862Assert.True(File.Exists(firmlinkedProcessPath), "firmlinked /private/var path should resolve to the same file"); 957var resolved = File.ResolveLinkTarget(path, returnFinalTarget: true); 1010File.WriteAllBytes(path, [0x00]); // existence is what matters 1016File.SetUnixFileMode(path, 1027File.WriteAllText(Path.Combine(dir, InstallSidecarReader.SidecarFileName), $"{{\"source\":\"{source}\"}}");

77var originalMode = File.GetUnixFileMode(sidecarPath); 81File.SetUnixFileMode(sidecarPath, UnixFileMode.None); 92File.SetUnixFileMode(sidecarPath, originalMode | UnixFileMode.UserRead | UnixFileMode.UserWrite); 191var originalMode = File.GetUnixFileMode(sidecarPath); 195File.SetUnixFileMode(sidecarPath, UnixFileMode.None); 203File.SetUnixFileMode(sidecarPath, originalMode | UnixFileMode.UserRead | UnixFileMode.UserWrite); 237File.WriteAllText(sidecarPath, $"{{\"source\":\"{oversized}\"}}"); 253File.WriteAllText(sidecarPath, $"{{\"source\":\"{oversized}\"}}"); 269File.WriteAllBytes(sidecarPath, bytes); 287File.WriteAllBytes(sidecarPath, bytes); 364File.WriteAllText(path, content);

16File.WriteAllText( 31using (var originalDocument = JsonDocument.Parse(File.ReadAllBytes(sidecarPath))) 38using var document = JsonDocument.Parse(File.ReadAllBytes(sidecarPath)); 56Assert.False(File.Exists(sidecarPath)); 65File.WriteAllText(sidecarPath, malformedContent); 69Assert.Equal(malformedContent, File.ReadAllText(sidecarPath)); 82File.WriteAllText(sidecarPath, originalContent); 89Assert.Equal(originalContent, File.ReadAllText(sidecarPath)); 99File.WriteAllText(sidecarPath, originalContent); 103Assert.Equal(originalContent, File.ReadAllText(sidecarPath));

92Assert.True(File.Exists(fakePeer.ArgvFile), $"Expected argv recorder file at {fakePeer.ArgvFile} to exist."); 93var argv = await File.ReadAllLinesAsync(fakePeer.ArgvFile, TestContext.Current.CancellationToken); 431if (File.Exists(pidFile)) 433var pidText = await File.ReadAllTextAsync(pidFile, cancellationToken); 527File.WriteAllText(path, content); 531File.SetUnixFileMode(path, 549File.WriteAllText(path, content); 555File.SetUnixFileMode(path,

26Assert.Equal(expectSidecar, File.Exists(sidecarPath)); 30using var doc = JsonDocument.Parse(File.ReadAllBytes(sidecarPath)); 52File.WriteAllText(sidecarPath, preSeededContent); 59Assert.Equal(preSeededContent, File.ReadAllText(sidecarPath)); 90Assert.True(File.Exists(sidecarPath)); 96using var doc = JsonDocument.Parse(File.ReadAllBytes(sidecarPath));

146await File.WriteAllTextAsync(skillPath, CreateSkillFileContent()); 189await File.WriteAllTextAsync(Path.Combine(skillDirectory, "SKILL.md"), CreateSkillFileContent()); 232await File.WriteAllTextAsync(Path.Combine(bundleDirectory, "skill-manifest.json"), "{"); 510await File.WriteAllTextAsync(Path.Combine(bundleDirectory, "skills", CommonAgentApplicators.AspireSkillName, "SKILL.md"), CreateSkillFileContent()); 558await File.WriteAllTextAsync(skillPath, CreateSkillFileContent()); 640await File.WriteAllTextAsync(skillPath, skillContent); 663await File.WriteAllTextAsync(Path.Combine(bundleDirectory, "skill-manifest.json"), manifestJson); 685await File.WriteAllTextAsync(skillPath, CreateSkillFileContent()); 805await File.WriteAllTextAsync(skillPath, "tampered"); 844await File.WriteAllTextAsync(fullPath, content); 885await File.WriteAllTextAsync(Path.Combine(skillDirectory, "SKILL.md"), content); 908return File.WriteAllTextAsync(Path.Combine(bundleDirectory, "skill-manifest.json"), manifestJson); 913using var stream = File.OpenRead(path); 919using var stream = File.OpenRead(path);

229Assert.True(File.Exists(Path.Combine( 282Assert.False(File.Exists(Path.Combine( 345await File.ReadAllTextAsync(Path.Combine( 350await File.ReadAllTextAsync(Path.Combine( 407await File.ReadAllTextAsync(Path.Combine( 457Assert.False(File.Exists(Path.Combine(cachedBundleDirectory, "skill-manifest.json"))); 464await File.ReadAllTextAsync(Path.Combine( 487await File.WriteAllTextAsync(Path.Combine(cachedBundleDirectory, "skill-manifest.json"), "{"); 560await File.WriteAllTextAsync( 878Assert.True(File.Exists(Path.Combine( 1037Assert.False(File.Exists($"{activeTemporaryDirectory}.lock")); 1460Assert.True(File.Exists(Path.Combine(targetDirectory, "skill-manifest.json"))); 1479await File.WriteAllBytesAsync(archivePath, archiveBytes); 1508await File.WriteAllBytesAsync(archivePath, archiveBytes); 1609await File.ReadAllTextAsync(Path.Combine( 1614await File.ReadAllTextAsync(Path.Combine( 1776Assert.False(File.Exists(Path.Combine( 2015await File.WriteAllTextAsync(skillPath, 2048await File.WriteAllTextAsync(Path.Combine(bundleDirectory, "skill-manifest.json"), manifestJson); 2052await File.WriteAllTextAsync(Path.Combine(bundleDirectory, AspireSkillsInstaller.ArchiveSha512FileName), archiveSha512); 2057await File.WriteAllTextAsync( 2064await File.WriteAllTextAsync( 2072return File.WriteAllTextAsync( 2101await File.WriteAllTextAsync( 2107await File.WriteAllTextAsync(Path.Combine(bundleDirectory, "skill-manifest.json"), "{"); 2111File.Delete(Path.Combine(bundleDirectory, "skills", CommonAgentApplicators.AspireSkillName, "SKILL.md")); 2135using var stream = File.OpenRead(path); 2286await File.WriteAllBytesAsync(archivePath, ArchiveBytes, cancellationToken); 2296File.Delete(archivePath);

26await File.WriteAllTextAsync(mcpJsonPath, "{ invalid json content"); 54await File.WriteAllTextAsync(mcpJsonPath, ""); 80await File.WriteAllTextAsync(mcpJsonPath, originalContent); 96var currentContent = await File.ReadAllTextAsync(mcpJsonPath);

58Assert.True(File.Exists(mcpConfigPath)); 60var content = await File.ReadAllTextAsync(mcpConfigPath); 111await File.WriteAllTextAsync(mcpConfigPath, existingConfig.ToJsonString()); 121var content = await File.ReadAllTextAsync(mcpConfigPath); 151await File.WriteAllTextAsync(mcpConfigPath, existingConfig.ToJsonString()); 209await File.WriteAllTextAsync(mcpConfigPath, "{ invalid json content"); 237await File.WriteAllTextAsync(mcpConfigPath, ""); 263await File.WriteAllTextAsync(mcpConfigPath, originalContent); 279var currentContent = await File.ReadAllTextAsync(mcpConfigPath);

24await File.WriteAllTextAsync(configPath, "{ invalid json content"); 50await File.WriteAllTextAsync(configPath, ""); 74await File.WriteAllTextAsync(configPath, originalContent); 89var currentContent = await File.ReadAllTextAsync(configPath);

196await File.WriteAllBytesAsync(tarballPath, content); 242await File.WriteAllBytesAsync(tarballPath, content); 287await File.WriteAllBytesAsync(tarballPath, content); 331await File.WriteAllBytesAsync(tarballPath, content); 380File.WriteAllBytes(tempPath, content); 471await File.WriteAllBytesAsync(tarballPath, [10, 20, 30]); 637File.WriteAllText(Path.Combine(skillDir, "SKILL.md"), "# Playwright CLI Skill"); 639File.WriteAllText(Path.Combine(skillDir, "subdir", "extra.md"), "Extra content"); 661Assert.True(File.Exists(Path.Combine(tempDir, ".agents", "skills", "playwright-cli", "SKILL.md"))); 662Assert.True(File.Exists(Path.Combine(tempDir, ".agents", "skills", "playwright-cli", "subdir", "extra.md"))); 663Assert.Equal("# Playwright CLI Skill", await File.ReadAllTextAsync(Path.Combine(tempDir, ".agents", "skills", "playwright-cli", "SKILL.md"))); 666Assert.True(File.Exists(Path.Combine(tempDir, ".github", "skills", "playwright-cli", "SKILL.md"))); 667Assert.True(File.Exists(Path.Combine(tempDir, ".github", "skills", "playwright-cli", "subdir", "extra.md"))); 689File.WriteAllText(Path.Combine(sourceDir, "keep.md"), "keep"); 693File.WriteAllText(Path.Combine(targetDir, "keep.md"), "old content"); 694File.WriteAllText(Path.Combine(targetDir, "stale.md"), "should be removed"); 696File.WriteAllText(Path.Combine(targetDir, "stale-dir", "old.md"), "should be removed"); 701Assert.Equal("keep", File.ReadAllText(Path.Combine(targetDir, "keep.md"))); 704Assert.False(File.Exists(Path.Combine(targetDir, "stale.md"))); 734File.WriteAllText(Path.Combine(skillDir, "SKILL.md"), "# Playwright CLI Skill"); 755Assert.True(File.Exists(Path.Combine(tempDir, ".agents", "skills", "playwright-cli", "SKILL.md"))); 780await File.WriteAllTextAsync(Path.Combine(preExistingDir, "SKILL.md"), "# User's existing skill"); 835File.WriteAllText(Path.Combine(skillDir, "SKILL.md"), "# Playwright CLI Skill"); 1025File.WriteAllBytes(PackResult, [1, 2, 3]);

28Assert.True(File.Exists(hookFile)); 30var root = JsonNode.Parse(await File.ReadAllTextAsync(hookFile).DefaultTimeout())!.AsObject(); 57Assert.True(File.Exists(Path.Combine(copilotHome.FullName, "hooks", "aspire-telemetry.json"))); 138await File.WriteAllTextAsync(settingsPath, existing.ToJsonString()).DefaultTimeout(); 143var root = JsonNode.Parse(await File.ReadAllTextAsync(settingsPath).DefaultTimeout())!.AsObject(); 159await File.WriteAllTextAsync(settingsPath, malformed).DefaultTimeout(); 167Assert.Equal(malformed, await File.ReadAllTextAsync(settingsPath).DefaultTimeout()); 178await File.WriteAllTextAsync(settingsPath, unexpected).DefaultTimeout(); 184Assert.Equal(unexpected, await File.ReadAllTextAsync(settingsPath).DefaultTimeout()); 198await File.WriteAllTextAsync(settingsPath, nonObjectRoot).DefaultTimeout(); 204Assert.Equal(nonObjectRoot, await File.ReadAllTextAsync(settingsPath).DefaultTimeout()); 229var root = JsonNode.Parse(await File.ReadAllTextAsync(settingsPath))!.AsObject();

25Assert.True(File.Exists(scripts.ShellScriptPath)); 26Assert.True(File.Exists(scripts.PowerShellScriptPath)); 38var bytes = await File.ReadAllBytesAsync(scripts.ShellScriptPath).DefaultTimeout(); 43var content = await File.ReadAllTextAsync(scripts.ShellScriptPath).DefaultTimeout(); 55var firstShellContent = await File.ReadAllTextAsync(first.ShellScriptPath).DefaultTimeout(); 58var secondShellContent = await File.ReadAllTextAsync(second.ShellScriptPath).DefaultTimeout(); 74await File.WriteAllTextAsync(shellPath, "stale-content").DefaultTimeout(); 78var content = await File.ReadAllTextAsync(scripts.ShellScriptPath).DefaultTimeout(); 97var mode = File.GetUnixFileMode(scripts.ShellScriptPath);

415File.WriteAllText(path, "#!/bin/bash\nprintf '%s\\n' \"$@\" > \"$ASPIRE_HOOK_TEST_CAPTURE_FILE\"\n"); 418File.SetUnixFileMode(path, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute 429File.WriteAllText(path, "$args | Set-Content -LiteralPath $env:ASPIRE_HOOK_TEST_CAPTURE_FILE\n"); 453=> File.Exists(capturePath) 454? File.ReadAllLines(capturePath).Where(line => line.Length > 0).ToArray()

127Assert.True(File.Exists(mcpJsonPath)); 144Assert.True(File.Exists(mcpJsonPath)); 146var content = await File.ReadAllTextAsync(mcpJsonPath); 189await File.WriteAllTextAsync(mcpJsonPath, existingConfig.ToJsonString()); 199var content = await File.ReadAllTextAsync(mcpJsonPath); 230await File.WriteAllTextAsync(mcpJsonPath, existingConfig.ToJsonString()); 245var content = await File.ReadAllTextAsync(mcpJsonPath); 282await File.WriteAllTextAsync(mcpJsonPath, "{ invalid json content"); 310await File.WriteAllTextAsync(mcpJsonPath, ""); 336await File.WriteAllTextAsync(mcpJsonPath, originalContent); 352var currentContent = await File.ReadAllTextAsync(mcpJsonPath);

42Assert.True(File.Exists(csprojPath), $"Expected csproj at {csprojPath}"); 61while (dir is not null && !File.Exists(Path.Combine(dir.FullName, "global.json")))

35await File.WriteAllBytesAsync(tempFile, new byte[2048]); // 2 KB exceeds the 1 KB limit 70await File.WriteAllBytesAsync(tempFile, new byte[1024]); // 1 KB, below the 4 KB limit

92Assert.False(File.Exists(socketPath)); 292File.WriteAllText(realProjectFile.FullName, "<Project />"); 324Assert.False(File.Exists(socketPath)); 515File.WriteAllText(projectFile.FullName, "<Project />"); 529File.WriteAllText(socketPath, "");

244Assert.False(File.Exists(socketPath)); 270Assert.True(File.Exists(socketPath)); 302Assert.True(File.Exists(throwingSocket)); 303Assert.False(File.Exists(okSocket)); 370File.WriteAllText(path, string.Empty);

23File.WriteAllText(managedPath, "old"); 24File.SetLastWriteTimeUtc(managedPath, new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc)); 28File.WriteAllText(managedPath, "new-content"); 29File.SetLastWriteTimeUtc(managedPath, new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc));

75File.WriteAllText(processPath, "fake-binary"); 85File.WriteAllText(sidecarPath, content);

37File.WriteAllText(binaryPath, string.Empty); 38File.WriteAllText(Path.Combine(binDir, SidecarFileName), $"{{\"source\":\"{source}\"}}"); 60File.WriteAllText(binaryPath, string.Empty); 61File.WriteAllText(Path.Combine(binDir, SidecarFileName), "{\"source\":\"pr\"}"); 80File.WriteAllText(binaryPath, string.Empty); 81File.WriteAllText(Path.Combine(installDir, SidecarFileName), "{\"source\":\"winget\"}"); 106File.WriteAllText(cellarBinary, string.Empty); 107File.WriteAllText(Path.Combine(cellarDir, SidecarFileName), "{\"source\":\"brew\"}"); 112File.CreateSymbolicLink(symlinkPath, cellarBinary); 145File.WriteAllText(binaryPath, string.Empty); 146File.WriteAllText(Path.Combine(ridDir, SidecarFileName), "{\"source\":\"dotnet-tool\"}"); 165File.WriteAllText(binaryPath, string.Empty);

65Assert.True(File.Exists(managedExe), $"managed exe should exist at {managedExe}"); 119File.SetLastWriteTimeUtc(v2BinaryPath, File.GetLastWriteTimeUtc(v1BinaryPath).AddHours(1)); 154var content = File.ReadAllText(managedExe); 223File.WriteAllText(lockedFilePath, "locked"); 254File.SetLastWriteTimeUtc(v2BinaryPath, File.GetLastWriteTimeUtc(v1BinaryPath).AddHours(1)); 259File.WriteAllText(Path.Combine(binDir, ".aspire-install.json"), "{\"source\":\"script\"}"); 319File.WriteAllText(Path.Combine(leasesDir, "orphan.lease"), "{}"); 363File.WriteAllText(Path.Combine(ridDir, ".aspire-install.json"), "{\"source\":\"dotnet-tool\"}"); 379Assert.True(File.Exists(managedExe), $"managed exe should exist at {managedExe}"); 444Assert.True(File.Exists(managedExe), $"managed exe should exist at {managedExe}"); 493Assert.True(File.Exists(managedExe)); 495var content = File.ReadAllText(managedExe); 515File.SetLastWriteTimeUtc(v2BinaryPath, File.GetLastWriteTimeUtc(v1BinaryPath).AddHours(1)); 615File.WriteAllText(path, content); 634if (!Directory.Exists(managedDir) || !File.Exists(managedExe) || !Directory.Exists(dcpDir) || !File.Exists(dcpExe))

78File.WriteAllText(processPath, "old"); 79File.SetLastWriteTimeUtc(processPath, new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc)); 83File.WriteAllText(processPath, "new-content"); 84File.SetLastWriteTimeUtc(processPath, new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc)); 133File.Delete(managedExe); 137File.WriteAllBytes(managedExe, []); 159File.Delete(BundleDiscovery.GetDcpExecutablePath(Path.Combine(dir, BundleDiscovery.DcpDirectoryName))); 233File.WriteAllText( 239File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDir), "dcp");

37File.WriteAllText(path, "<Project Sdk=\"Microsoft.NET.Sdk\" />"); 116using var document = JsonDocument.Parse(await File.ReadAllTextAsync(cachePath)); 152File.WriteAllText(projectFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\" />\n<!-- edit -->"); 153File.SetLastWriteTimeUtc(projectFile.FullName, DateTime.UtcNow.AddSeconds(2)); 172File.WriteAllText(assetsPath, "{}"); 189File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "Directory.Packages.props"), "<Project />"); 199File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), """ 267File.WriteAllText(projectFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\" />\n<!-- edit -->"); 268File.SetLastWriteTimeUtc(projectFile.FullName, DateTime.UtcNow.AddSeconds(2)); 290File.WriteAllText(projectFile.FullName, """ 297File.WriteAllText(commonProps, "<Project />"); 302File.WriteAllText(commonProps, """ 309File.SetLastWriteTimeUtc(commonProps, DateTime.UtcNow.AddSeconds(2)); 325File.WriteAllText(projectFile.FullName, """ 354File.WriteAllText(projectFile.FullName, """ 358File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "repo", "Directory.Build.props"), """ 366File.WriteAllText(sharedProps, "<Project />"); 371File.WriteAllText(sharedProps, """ 378File.SetLastWriteTimeUtc(sharedProps, DateTime.UtcNow.AddSeconds(2)); 391File.WriteAllText(projectFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\" />"); 392File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "repo", "Directory.Build.props"), """ 400File.WriteAllText(sharedProps, "<Project />"); 405File.WriteAllText(sharedProps, """ 412File.SetLastWriteTimeUtc(sharedProps, DateTime.UtcNow.AddSeconds(2)); 424File.WriteAllText(projectFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\" />"); 425File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "repo", "Directory.Build.props"), """ 449File.WriteAllText(projectFile.FullName, """ 453File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "repo", "Directory.Build.props"), """ 478File.WriteAllText(projectFile.FullName, """ 484File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "Aspire.Common"), ""); 486File.WriteAllText(commonProps, "<Project />"); 491File.WriteAllText(commonProps, """ 498File.SetLastWriteTimeUtc(commonProps, DateTime.UtcNow.AddSeconds(2)); 513File.WriteAllText(projectFile.FullName, """ 532File.WriteAllText(projectFile.FullName, """ 558File.WriteAllText(projectFile.FullName, """ 562File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "Directory.Build.props"), """ 567File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "repo", "Directory.Build.props"), """ 594File.WriteAllText(projectFile.FullName, """ 600File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "Repo.marker"), ""); 602File.WriteAllText(customProps, "<Project />"); 607File.WriteAllText(customProps, """ 614File.SetLastWriteTimeUtc(customProps, DateTime.UtcNow.AddSeconds(2)); 630File.WriteAllText(projectFile.FullName, """ 654File.WriteAllText(projectFile.FullName, """ 729File.WriteAllText(projectFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\" />"); 732File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "Directory.Build.props"), "<Project />"); 744File.WriteAllText(parentImport, "<Project />"); 747File.WriteAllText( 753File.WriteAllText(projectFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\" />"); 757File.WriteAllText(parentImport, "<Project><!-- above git boundary edit --></Project>"); 758File.SetLastWriteTimeUtc(parentImport, DateTime.UtcNow.AddSeconds(2));

126File.Move(current, oldName, overwrite: true); 131Assert.False(File.Exists(oldName));

37File.WriteAllBytes(onDiskPfxPath, certificate.Export(X509ContentType.Pfx)); 45Assert.True(File.Exists(cachedPfxPath)); 46Assert.True(File.Exists(cachedKeyPath)); 49Assert.StartsWith("-----BEGIN PRIVATE KEY-----", File.ReadAllText(cachedKeyPath), StringComparison.Ordinal);

103File.SetLastWriteTimeUtc(firstResult, lastWriteTime); 104lastWriteTime = File.GetLastWriteTimeUtc(firstResult); 109Assert.Equal(pemContents, File.ReadAllText(firstResult)); 110Assert.Equal(lastWriteTime, File.GetLastWriteTimeUtc(secondResult)); 122File.GetUnixFileMode(outputDirectory)); 125File.GetUnixFileMode(firstResult));

126File.WriteAllText(certificatePath, "not a certificate"); 161File.WriteAllText(Path.Combine(corruptOpenSslDirectory.FullName, certificateFileName), "not a certificate"); 162File.WriteAllText(Path.Combine(validOpenSslDirectory.FullName, certificateFileName), certificate.ExportCertificatePem()); 197File.WriteAllText(certificatePath, "not a certificate"); 202Assert.False(File.Exists(certificatePath)); 256await File.WriteAllTextAsync(certUtilFile.FullName, script); 257File.SetUnixFileMode( 281await File.WriteAllTextAsync(certUtilFile.FullName, script); 282File.SetUnixFileMode(

265File.WriteAllText(binaryPath, string.Empty); 267File.WriteAllText(Path.Combine(binaryDir, InstallSidecarReader.SidecarFileName), $$"""{"source":"{{source}}"{{channelField}}}""");

109File.WriteAllText(Path.Combine(hivesDir.FullName, "README.md"), "stray"); 110File.WriteAllText(Path.Combine(hivesDir.FullName, ".DS_Store"), string.Empty);

389File.WriteAllText(appHostFile.FullName, string.Empty); 390File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), """ 462File.WriteAllText(appHostFile.FullName, string.Empty); 463File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), """ 543File.WriteAllText(appHostFile.FullName, string.Empty); 544File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), """ 642File.WriteAllText(appHostFile.FullName, string.Empty); 645File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), $$""" 726File.WriteAllText(appHostFile.FullName, string.Empty); 727File.WriteAllText(Path.Combine(projectDirectory.FullName, AspireConfigFile.FileName), """ 770File.WriteAllText(appHostFile.FullName, string.Empty); 843File.WriteAllText(appHostFile.FullName, string.Empty); 844File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), """ 2491File.WriteAllText(appHostFile.FullName, isTypeScript ? string.Empty : "<Project />"); 2495File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), $$""" 2600File.WriteAllText(appHostFile.FullName, string.Empty); 2601File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), """ 2814File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.Hosting.{cliVersion}.nupkg"), string.Empty); 2815File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.Hosting.Redis.{cliVersion}.nupkg"), string.Empty); 2852File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.Hosting.{cliVersion}.nupkg"), string.Empty); 2853File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.Hosting.Redis.{cliVersion}.nupkg"), string.Empty); 2855File.WriteAllText(Path.Combine(prPackagesDir.FullName, $"Aspire.Hosting.{staleVersion}.nupkg"), string.Empty); 2856File.WriteAllText(Path.Combine(prPackagesDir.FullName, $"Aspire.Hosting.Redis.{staleVersion}.nupkg"), string.Empty); 2882File.WriteAllText(Path.Combine(identityPackagesDir.FullName, $"Aspire.Hosting.{cliVersion}.nupkg"), string.Empty); 2883File.WriteAllText(Path.Combine(identityPackagesDir.FullName, $"Aspire.Hosting.Redis.{cliVersion}.nupkg"), string.Empty); 3011File.WriteAllText(appHostFile.FullName, string.Empty); 3061File.WriteAllText(appHostFile.FullName, string.Empty); 3111File.WriteAllText(appHostFile.FullName, string.Empty); 3165File.WriteAllText(appHostFile.FullName, string.Empty); 3213File.WriteAllText(appHostFile.FullName, string.Empty); 3261File.WriteAllText(appHostFile.FullName, string.Empty); 3309File.WriteAllText(appHostFile.FullName, string.Empty); 3361File.WriteAllText(appHostFile.FullName, string.Empty); 3412File.WriteAllText(appHostFile.FullName, string.Empty); 3470File.WriteAllText(appHostFile.FullName, string.Empty);

103await File.WriteAllTextAsync(blockedSkillParentPath, "blocked").DefaultTimeout(); 836Assert.True(File.Exists(skillPath), $"Expected skill file at {skillPath}"); 850await File.WriteAllTextAsync(skillPath, $$""" 887await File.WriteAllTextAsync(manifestPath, manifestJson); 895using var stream = File.OpenRead(path); 918Assert.True(File.Exists(hookFile), $"Expected telemetry hook at {hookFile}");

89File.WriteAllText(realProjectPath, "<Project />"); 397Assert.False(File.Exists(socketPath)); 962await File.WriteAllLinesAsync(childLogFile, [ 990await File.WriteAllLinesAsync(childLogFile, [ 1013await File.WriteAllLinesAsync(childLogFile, [ 1075await File.WriteAllLinesAsync(childLogFile, [ 1167File.WriteAllText(appHostFile.FullName, "<Project />"); 1258File.WriteAllText(socketPath, ""); 1346File.WriteAllLines(childLogFile, ChildLogLines);

49File.WriteAllText(Path.Combine(restoreDir.FullName, "test.dll"), "fake"); 63Assert.False(File.Exists(Path.Combine(restoreDir.FullName, "test.dll"))); 73await File.WriteAllTextAsync(cacheEntry, "{}").DefaultTimeout(); 84Assert.False(File.Exists(cacheEntry)); 105await File.WriteAllTextAsync(Path.Combine(firstBuildCache.FullName, "Aspire.Hosting.dll"), "fake").DefaultTimeout(); 106await File.WriteAllTextAsync(Path.Combine(secondBuildCache.FullName, "Aspire.Hosting.dll"), "fake").DefaultTimeout(); 171File.WriteAllText(Path.Combine(tempDir.FullName, "root.txt"), "root"); 172File.WriteAllText(Path.Combine(subDir.FullName, "nested.txt"), "nested"); 198File.WriteAllText(keepFile, "keep"); 199File.WriteAllText(deleteFile, "delete"); 206Assert.True(File.Exists(keepFile)); 207Assert.False(File.Exists(deleteFile));

123Assert.True(File.Exists(settingsPath)); 125var json = await File.ReadAllTextAsync(settingsPath); 150var settingsJson = await File.ReadAllTextAsync(settingsPath); 183Assert.True(File.Exists(settingsPath)); 185var json = await File.ReadAllTextAsync(settingsPath); 208Assert.True(File.Exists(settingsPath)); 210var json = await File.ReadAllTextAsync(settingsPath); 242var json = await File.ReadAllTextAsync(settingsPath); 362var json = await File.ReadAllTextAsync(settingsPath); 691var json = await File.ReadAllTextAsync(settingsPath); 723var json = await File.ReadAllTextAsync(settingsPath); 754var json = await File.ReadAllTextAsync(settingsPath); 785var json = await File.ReadAllTextAsync(settingsPath); 801await File.WriteAllTextAsync(settingsPath, """ 815var json = await File.ReadAllTextAsync(settingsPath); 834await File.WriteAllTextAsync(settingsPath, """ 848var json = await File.ReadAllTextAsync(settingsPath); 874var json = await File.ReadAllTextAsync(configPath); 891await File.WriteAllTextAsync(legacySettingsPath, """{ "channel": "daily" }"""); 904var json = await File.ReadAllTextAsync(configPath); 937if (File.Exists(settingsPath)) 939var json = await File.ReadAllTextAsync(settingsPath); 961var json = await File.ReadAllTextAsync(settingsPath); 1001Assert.False(File.Exists(configPath)); 1019var json = await File.ReadAllTextAsync(settingsPath);

634File.WriteAllText(managedPath, "fake");

88await File.WriteAllTextAsync(appHostFile.FullName, "<Project />");

85Assert.SkipUnless(File.Exists("/etc/os-release"), "Linux /etc/os-release is required for this test."); 88await File.ReadAllTextAsync("/etc/os-release", TestContext.Current.CancellationToken)); 167await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 194await File.WriteAllTextAsync(appHostFile.FullName, "export {};"); 195await File.WriteAllTextAsync( 243await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 270await File.WriteAllTextAsync(projectFile.FullName, "<Project />"); 298await File.WriteAllTextAsync(projectFile.FullName, "<Project />"); 301await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 323await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, "AppHost.csproj"), "<Project />"); 324await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, "AppHost.fsproj"), "<Project />"); 351await File.WriteAllTextAsync(appHostFile.FullName, "export {};"); 405await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 406await File.WriteAllTextAsync( 496await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 497await File.WriteAllTextAsync( 527await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 528await File.WriteAllTextAsync( 561await File.WriteAllTextAsync(appHostFile.FullName, "<Project />");

105await File.WriteAllTextAsync(filePath, "");

66Assert.True(File.Exists(outputPath), "Export zip file should be created"); 137Assert.True(File.Exists(outputPath), $"Export zip file should be created at the specified path: {outputPath}"); 155File.WriteAllText(appHostProjectPath, "<Project />"); 172Assert.False(File.Exists(outputPath), "No zip should be created when the AppHost is not running"); 285Assert.True(File.Exists(outputPath), "Export zip file should be created"); 347Assert.True(File.Exists(outputPath), "Export zip file should be created"); 465Assert.True(File.Exists(outputPath), "Export zip file should be created"); 523Assert.True(File.Exists(outputPath), "Export zip file should be created"); 583Assert.True(File.Exists(outputPath), "Export zip file should be created"); 633Assert.True(File.Exists(outputPath)); 675Assert.True(File.Exists(outputPath)); 719Assert.True(File.Exists(outputPath)); 755Assert.False(File.Exists(outputPath), "No zip should be created when the resource doesn't exist"); 794Assert.True(File.Exists(outputPath), "Export zip file should be created"); 841Assert.True(File.Exists(outputPath), "Export zip file should be created even without dashboard");

103await File.WriteAllTextAsync(projectFile.FullName, """

67File.WriteAllText(solutionFile.FullName, "Fake solution file"); 70File.WriteAllText(projectFile.FullName, "<Project />"); 109Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "aspire.config.json"))); 118File.WriteAllText(solutionFile.FullName, "Fake solution file"); 150Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "aspire.config.json"))); 166Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.cs"))); 168var config = JsonNode.Parse(File.ReadAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "aspire.config.json")))!.AsObject(); 194Assert.True(File.Exists(runJsonPath), "apphost.run.json should be created so `dotnet run apphost.cs` works."); 196var runJson = JsonNode.Parse(File.ReadAllText(runJsonPath))!.AsObject(); 220var aspireConfig = JsonNode.Parse(File.ReadAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "aspire.config.json")))!.AsObject(); 263File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "aspire.config.json"), existingAspireConfig); 274var runJson = JsonNode.Parse(File.ReadAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.run.json")))!.AsObject(); 314File.WriteAllText(aspireConfigPath, customAspireConfig); 327var aspireConfig = JsonNode.Parse(File.ReadAllText(aspireConfigPath))!.AsObject(); 338Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.run.json"))); 362Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.cs"))); 397Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.mts"))); 399var config = JsonNode.Parse(File.ReadAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "aspire.config.json")))!.AsObject(); 412File.WriteAllText(existingAppHostPath, existingAppHostContent); 413File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "package.json"), """{ "type": "commonjs" }"""); 427Assert.Equal(existingAppHostContent, File.ReadAllText(existingAppHostPath)); 428Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.mts"))); 429Assert.Equal("""{ "type": "commonjs" }""", File.ReadAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "package.json"))); 436File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "package.json"), "{}"); 445File.WriteAllText(Path.Combine(scaffoldDirectory.FullName, context.Language.AppHostFileName!), string.Empty); 475Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.mts"))); 476Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "aspire-apphost", "apphost.mts"))); 587Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.cs"))); 609Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.cs"))); 629Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.cs"))); 632Assert.True(File.Exists(aspireSkillPath), $"Expected aspire skill file at {aspireSkillPath}"); 654var appHostContent = await File.ReadAllTextAsync(appHostPath); 677await File.WriteAllTextAsync(configPath, existingConfig.ToJsonString()); 688var merged = JsonNode.Parse(await File.ReadAllTextAsync(configPath))!.AsObject(); 705await File.WriteAllTextAsync(configPath, "{ this is not json"); 725await File.WriteAllTextAsync(appHostPath, preExistingContent); 735Assert.Equal(preExistingContent, await File.ReadAllTextAsync(appHostPath)); 744File.WriteAllText(solutionFile.FullName, "Fake solution file"); 787File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "nuget.config")), 797File.WriteAllText(solutionFile.FullName, "Fake solution file"); 874File.WriteAllText(solutionFile.FullName, "Fake solution file"); 940File.WriteAllText(solutionFile.FullName, "Fake solution file"); 989File.WriteAllText(solutionFile.FullName, "Fake solution file"); 1058Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.cs"))); 1061Assert.True(File.Exists(nugetConfigPath), $"nuget.config should be created in workspace for channel '{contextChannel}'."); 1093Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.cs"))); 1096Assert.False(File.Exists(nugetConfigPath), "stable-identity init must not drop a nuget.config (stable packages resolve from ambient nuget.org)."); 1131Assert.True(File.Exists(configPath)); 1133var config = JsonNode.Parse(File.ReadAllText(configPath))!.AsObject(); 1156await File.WriteAllTextAsync(configPath, existing.ToJsonString()); 1172var config = JsonNode.Parse(await File.ReadAllTextAsync(configPath))!.AsObject(); 1204var config = JsonNode.Parse(File.ReadAllText(configPath))!.AsObject(); 1248var config = JsonNode.Parse(File.ReadAllText(configPath))!.AsObject(); 1364await File.WriteAllTextAsync(configPath, existing.ToJsonString()); 1470File.WriteAllText(solutionFile.FullName, "Fake solution file"); 1549File.WriteAllText(solutionFile.FullName, "Fake solution file"); 1637File.WriteAllText(solutionFile.FullName, "Fake solution file"); 1658nugetConfigContentAtNewProjectTime = File.Exists(nugetConfigPath) 1659? File.ReadAllText(nugetConfigPath) 1676Assert.True(File.Exists(nugetConfigPath), $"nuget.config should be created in the solution directory for channel '{contextChannel}'."); 1698File.WriteAllText(solutionFile.FullName, "Fake solution file"); 1727Assert.False(File.Exists(nugetConfigPath), "stable-identity init must not drop a nuget.config (stable packages resolve from ambient nuget.org)."); 1745File.WriteAllText(solutionFile.FullName, "Fake solution file"); 1750Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "nuget.config"))); 1772Assert.True(File.Exists(nugetConfigPath), "rerun must create the workspace nuget.config even though the AppHost dir already exists."); 1790File.WriteAllText(appHostPath, "#:sdk Aspire.AppHost.Sdk@13.4.0-staging.x\nbuilder.Build().Run();"); 1791Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "nuget.config"))); 1809Assert.True(File.Exists(nugetConfigPath), "rerun must create the workspace nuget.config even though apphost.cs already exists."); 1828File.WriteAllText(solutionFile.FullName, "Fake solution file"); 1857Assert.True(File.Exists(Path.Combine(solutionDir.FullName, "nuget.config")), 1859Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "nuget.config")), 1878File.WriteAllText(solutionFile.FullName, "Fake solution file"); 1890File.WriteAllText(nugetConfigPath, nugetConfigContent); 1920var merged = File.ReadAllText(nugetConfigPath); 1939File.WriteAllText(solutionFile.FullName, "Fake solution file"); 1971var content = File.ReadAllText(nugetConfigPath); 1994File.WriteAllText(solutionFile.FullName, "Fake solution file"); 2038File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "nuget.config")), 2055File.WriteAllText(solutionFile.FullName, """<Solution />"""); 2085Assert.True(File.Exists(nugetConfigPath)); 2188File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, appHostFileName), string.Empty); 2198File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, AspireConfigFile.FileName), config.ToJsonString());

61File.WriteAllText(projectPath, content);

175await File.WriteAllTextAsync(configuredAppHost.FullName, "Not a real apphost"); 176await File.WriteAllTextAsync(Path.Combine(workingDirectory.FullName, "aspire.config.json"), JsonSerializer.Serialize(new

681File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.ProjectTemplates.{version}.nupkg"), string.Empty);

260File.WriteAllText(Path.Combine(outputPath, $"{name}.generated"), templateName); 302Assert.True(File.Exists(appHostFile)); 303Assert.Contains(s_prVersion, await File.ReadAllTextAsync(appHostFile)); 310var csharpNuGetConfig = await File.ReadAllTextAsync(Path.Combine(outputDirectory, "nuget.config")); 334var dotNetNuGetConfig = await File.ReadAllTextAsync(Path.Combine(outputDirectory, "nuget.config")); 524File.WriteAllText(processPath, string.Empty); 527File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.ProjectTemplates.{s_prVersion}.nupkg"), string.Empty);

150Assert.True(File.Exists(nugetConfigPath)); 152var nugetConfig = await File.ReadAllTextAsync(nugetConfigPath); 966File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "apphost.mts"), "// test apphost"); 983Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "output", "apphost.mts"))); 984Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "output", "aspire.config.json"))); 1132File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "AppHost.java"), "package aspire;"); 1157File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "aspire.config.json"), """ 1195File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "AppHost.java"), "package aspire;"); 1223File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "apphost.mts"), "// test apphost"); 1235Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "output", "apphost.mts"))); 1312File.WriteAllText(Path.Combine(nestedDirectory.FullName, "Aspire.ProjectTemplates.9.2.0.nupkg"), string.Empty); 1357File.WriteAllText(Path.Combine(sourceOverride, "Aspire.ProjectTemplates.9.2.0.nupkg"), string.Empty); 1380File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, scaffoldFileName), "// test apphost"); 1405File.WriteAllText(Path.Combine(sourceOverride, "Aspire.ProjectTemplates.9.2.0.nupkg"), string.Empty); 1506File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "apphost.mts"), "// test apphost"); 1545File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "AppHost.java"), "package aspire;"); 1557Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "output", "AppHost.java"))); 1581File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "apphost.py"), "# test apphost"); 1593Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "output", "apphost.py"))); 1609Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "output", "apphost.cs"))); 1639var appHostCreated = File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "output", "apphost.cs")); 1668Assert.True(File.Exists(aspireConfigPath)); 1669Assert.True(File.Exists(appHostRunJsonPath), "apphost.run.json must be emitted alongside aspire.config.json so dotnet run picks up matching URLs."); 1671var aspireConfig = await File.ReadAllTextAsync(aspireConfigPath); 1672var appHostRunJson = await File.ReadAllTextAsync(appHostRunJsonPath); 1702Assert.True(File.Exists(aspireConfigPath)); 1703Assert.True(File.Exists(appHostRunJsonPath), "apphost.run.json must be emitted alongside aspire.config.json so dotnet run picks up matching URLs."); 1705var aspireConfig = await File.ReadAllTextAsync(aspireConfigPath); 1706var appHostRunJson = await File.ReadAllTextAsync(appHostRunJsonPath); 1776Assert.True(File.Exists(aspireConfigPath)); 1777var aspireConfig = await File.ReadAllTextAsync(aspireConfigPath); 1783Assert.True(File.Exists(appHostRunJsonPath)); 1784var appHostRunJson = await File.ReadAllTextAsync(appHostRunJsonPath); 1952await File.WriteAllTextAsync(Path.Combine(context.TargetDirectory.FullName, "aspire.config.json"), """ 1983var configContent = await File.ReadAllTextAsync(configPath); 2047File.WriteAllText(Path.Combine(modulesDir.FullName, "aspire.mts"), "// generated sdk"); 2062Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "output", LanguageInfo.GeneratedFolderName, "aspire.mts"))); 2136File.WriteAllText(Path.Combine(sourceOverride, "Aspire.ProjectTemplates.9.2.0.nupkg"), string.Empty); 2171File.WriteAllText(Path.Combine(modulesDir.FullName, "aspire.ts"), "// generated sdk"); 2246File.WriteAllText(Path.Combine(sourceOverride, "Aspire.ProjectTemplates.9.2.0.nupkg"), string.Empty); 2368Assert.True(File.Exists(aspireSkillPath), $"Expected aspire skill file at {aspireSkillPath}"); 2509Assert.True(File.Exists(skillPath)); 2549Assert.False(File.Exists(skillPath)); 2914File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "apphost.ts"), "// test apphost"); 2930Assert.True(File.Exists(Path.Combine(expectedPath, "apphost.ts"))); 2940File.WriteAllText(Path.Combine(selectedParent.FullName, "existing.txt"), "existing content"); 2977File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "apphost.ts"), "// test apphost"); 2994Assert.True(File.Exists(Path.Combine(expectedPath, "apphost.ts"))); 3005File.WriteAllText(Path.Combine(collidingProject.FullName, "existing.txt"), "existing content"); 3130File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "apphost.ts"), "// test apphost"); 3147Assert.True(File.Exists(Path.Combine(expectedPath, "apphost.ts"))); 3199File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "apphost.ts"), "// test apphost"); 3215Assert.True(File.Exists(Path.Combine(selectedOutputPath.FullName, "apphost.ts"))); 3216Assert.False(File.Exists(Path.Combine(selectedOutputPath.FullName, projectName, "apphost.ts"))); 3253File.WriteAllText(Path.Combine(context.TargetDirectory.FullName, "apphost.ts"), "// test apphost"); 3269Assert.True(File.Exists(Path.Combine(expectedPath, "apphost.ts"))); 3295Assert.False(File.Exists(skillPath)); 3321Assert.True(File.Exists(skillPath)); 3323Assert.False(File.Exists(aspireifySkillPath)); 3349Assert.True(File.Exists(skillPath)); 3351Assert.False(File.Exists(aspireifySkillPath)); 3361File.WriteAllText(Path.Combine(existingDir.FullName, "file.txt"), "content"); 3410File.WriteAllText(Path.Combine(existingDir.FullName, "file.txt"), "content");

263await File.WriteAllTextAsync(selectedFile, "artifact"); 804await File.WriteAllTextAsync(oversizedFile, new string('x', 100)); 807await File.WriteAllTextAsync(validFile, "ok"); 850await File.WriteAllTextAsync(wrongExtFile, "not a pem"); 853await File.WriteAllTextAsync(correctFile, "pem content"); 896await File.WriteAllTextAsync(validFile, "zip content"); 942await File.WriteAllTextAsync(validFile, "gzip content");

199File.WriteAllText(appHostProjectFile.FullName, "<Project />");

19await File.WriteAllTextAsync(appHostFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\" />"); 53await File.WriteAllTextAsync(appHostFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\" />");

145Assert.True(File.Exists(socketPath), "Validation should happen before existing AppHost instances are stopped."); 158File.WriteAllText(Path.Combine(propertiesDirectory.FullName, "launchSettings.json"), """ 207File.WriteAllText(Path.Combine(propertiesDirectory.FullName, "launchSettings.json"), $$""" 374await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 438await File.WriteAllTextAsync(appHostFile.FullName, "<Project />", TestContext.Current.CancellationToken); 526await File.WriteAllTextAsync(appHostFile.FullName, "<Project />", TestContext.Current.CancellationToken); 631await File.WriteAllTextAsync(appHostFile.FullName, "<Project />", TestContext.Current.CancellationToken); 787await File.WriteAllTextAsync(Path.Combine(appHost1Dir.FullName, "AppHost1.csproj"), "fake"); 790await File.WriteAllTextAsync(Path.Combine(appHost2Dir.FullName, "AppHost2.csproj"), "fake"); 855File.WriteAllText(projectFile.FullName, """ 920await File.WriteAllTextAsync( 1088await File.WriteAllTextAsync(appHostFile.FullName, "<Project />", TestContext.Current.CancellationToken); 1161File.WriteAllText(Path.Combine(propertiesDirectory.FullName, "launchSettings.json"), """ 1313await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1389await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1453await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1515await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1573await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1635await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1696await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1759await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1820await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1882await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 2567File.WriteAllText(appHostProjectFile.FullName, "<Project></Project>"); 3207await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 3255await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 3299await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 3347await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 3390await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 3434await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 3478await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 3621File.WriteAllText(originalSecretsPath, """{"TestSecret": "TestValue"}"""); 3708if (File.Exists(originalSecretsPath)) 3710File.Delete(originalSecretsPath); 3811var lines = await File.ReadAllLinesAsync(logFilePath); 3848var lines = await File.ReadAllLinesAsync(logFilePath); 3891await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 3940File.WriteAllText(appHostFile.FullName, "<Project />"); 4007File.WriteAllText(appHostFile.FullName, "<Project />"); 4035File.WriteAllText(appHostFile.FullName, "<Project />"); 4283File.WriteAllText(appHostFile.FullName, "<Project />"); 4324File.WriteAllText(appHostFile.FullName, "<Project />"); 4340File.WriteAllText(socketPath, "");

262Assert.True(File.Exists(projectPath), $"Could not find Aspire.Hosting project at '{projectPath}'."); 282var output = await File.ReadAllTextAsync(outputPath); 384if (File.Exists(Path.Combine(currentDirectory.FullName, "Aspire.slnx")))

29await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, "AppHost.csproj"), projectContent); 116await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, "AppHost.csproj"), projectContent); 154await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, "AppHost.csproj"), projectContent);

25await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 51await File.WriteAllTextAsync(appHostFile.FullName, "export {};");

158Assert.True(File.Exists(socketPath), "Validation should happen before existing AppHost instances are stopped."); 217File.WriteAllText(Path.Combine(propertiesDirectory.FullName, "launchSettings.json"), """ 268await File.WriteAllTextAsync(Path.Combine(appHost1Dir.FullName, "AppHost1.csproj"), "fake"); 271await File.WriteAllTextAsync(Path.Combine(appHost2Dir.FullName, "AppHost2.csproj"), "fake"); 299await File.WriteAllTextAsync(Path.Combine(appHost1Dir.FullName, "AppHost1.csproj"), "fake"); 302await File.WriteAllTextAsync(Path.Combine(appHost2Dir.FullName, "AppHost2.csproj"), "fake"); 331await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 384File.WriteAllText(appHostFile.FullName, "<Project />"); 668File.WriteAllText(appHostFile.FullName, "<Project />"); 684File.WriteAllText(socketPath, "");

270Assert.False(File.Exists(primaryConnection.SocketPath)); 271Assert.True(File.Exists(nestedConnection.SocketPath)); 281await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 348Assert.True(File.Exists(connection.SocketPath)); 388Assert.False(File.Exists(connection.SocketPath)); 475await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 509await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 541await File.WriteAllTextAsync(runningAppHostFile.FullName, "<Project />"); 544await File.WriteAllTextAsync(discoveredAppHostFile.FullName, "<Project />"); 593await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 625await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 660await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 700await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 735await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 775await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 815await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 854await File.WriteAllTextAsync(appHostFile.FullName, ""); 900await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 937await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 982await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1020await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1058await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1126await File.WriteAllTextAsync(appHostFile.FullName, "<Project />"); 1192Assert.True(File.Exists(socketPath)); 1213Assert.False(File.Exists(socketPath)); 1228File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDirectory.FullName), ""); 1309File.WriteAllText(socketPath, "");

155await File.WriteAllTextAsync( 174File.WriteAllText(appHostPath, "await Promise.resolve();"); 175File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "package.json"), packageJsonContent);

89await File.WriteAllTextAsync(appHostProjectFile.FullName, """ 192File.WriteAllText(oldBackup1, "test"); 193File.WriteAllText(oldBackup2, "test"); 194File.WriteAllText(otherFile, "test"); 200Assert.False(File.Exists(oldBackup1), "Old backup file should be deleted"); 201Assert.False(File.Exists(oldBackup2), "Old backup file should be deleted"); 202Assert.True(File.Exists(otherFile), "Other files should not be deleted"); 213File.WriteAllText(oldBackup, "test"); 223Assert.True(File.Exists(oldBackup), "Locked file should still exist on Windows"); 227Assert.False(File.Exists(oldBackup), "Locked file should be deleted on Mac/Linux"); 377File.WriteAllText(appHostPath, "// test apphost"); 440File.WriteAllText(appHostPath, "// test apphost"); 495File.WriteAllText(appHostPath, "// test apphost"); 1265File.WriteAllText(appHostPath, "// test apphost"); 1467File.WriteAllText(archivePath, "fake archive"); 1493await File.WriteAllTextAsync(processPath, "#!/bin/sh\nexit 0\n"); 1497await File.WriteAllTextAsync( 1518using var document = JsonDocument.Parse(await File.ReadAllBytesAsync(sidecarPath)); 1536await File.WriteAllTextAsync(processPath, originalExecutable); 1541await File.WriteAllTextAsync(sidecarPath, originalSidecar); 1562Assert.Equal(originalExecutable, await File.ReadAllTextAsync(processPath)); 1563Assert.Equal(originalSidecar, await File.ReadAllTextAsync(sidecarPath)); 1592File.WriteAllText(archivePath, "fake archive"); 1633File.WriteAllText(archivePath, "fake archive"); 2032File.WriteAllText(localConfigPath, """{ "channel": "staging" }"""); 2053File.WriteAllText(globalSettingsPath, """{ "channel": "staging" }"""); 2071File.WriteAllText(localConfigPath, """{ "channel": "staging" }"""); 2090File.WriteAllText(Path.Combine(globalDir, "settings.global.json"), """{ "channel": "daily" }"""); 2093File.WriteAllText(localConfigPath, """{ "channel": "staging" }"""); 2114File.WriteAllText(Path.Combine(globalDir, "settings.global.json"), """{ "channel": "staging" }"""); 2134File.WriteAllText(localConfigPath, """{ "channel": "no-such-channel" }"""); 2250File.WriteAllText(projectConfigPath, """{ "channel": "staging" }"""); 2267File.WriteAllText( 2273File.WriteAllText(Path.Combine(globalDir, "settings.global.json"), """{ "channel": "staging" }"""); 2295File.WriteAllText( 2300File.WriteAllText( 2321File.WriteAllText( 2327File.WriteAllText(Path.Combine(globalDir, "settings.global.json"), """{ "channel": "staging" }"""); 2330File.WriteAllText( 2378File.WriteAllText( 2631File.WriteAllText(appHostFile.FullName, string.Empty); 2632File.WriteAllText( 2775File.WriteAllText( 2960File.WriteAllText(archivePath, "fake archive"); 3005File.WriteAllText(archivePath, "fake archive"); 3050File.WriteAllText(archivePath, "fake archive"); 3083File.WriteAllText(archivePath, "fake archive"); 3270File.WriteAllText(archivePath, "fake archive"); 3295await File.WriteAllTextAsync( 3313await using var tarStream = File.OpenRead(tarPath); 3314await using var archiveStream = File.Create(archivePath); 3330File.SetUnixFileMode( 3354File.WriteAllText(processPath, string.Empty); 3355File.WriteAllText(storeExecutablePath, string.Empty); 3366File.WriteAllText(processPath, string.Empty); 3367File.WriteAllText(Path.Combine(binaryDir, InstallSidecarReader.SidecarFileName), """{"source":"nix"}"""); 3436File.WriteAllText(archivePath, "fake archive");

41File.WriteAllText(path, json); 55File.WriteAllText(path, json); 65File.WriteAllText(path, """{ "appHost": { "language": "typescript/nodejs" }, "channel": "daily" }"""); 77File.WriteAllText(path, """{ "appHost": { "path": "AppHost.csproj" }""");

27File.WriteAllText(configPath, """ 47File.WriteAllText(configPath, """ 71File.WriteAllText(configPath, """ 95File.WriteAllText(configPath, """ 118File.WriteAllText(configPath, """ 137File.WriteAllText(configPath, "{ invalid json content }"); 151File.WriteAllText(configPath, """{ "appHost": { "path": """); 164File.WriteAllText(configPath, "{}"); 187Assert.True(File.Exists(filePath)); 189var content = File.ReadAllText(filePath); 204Assert.True(File.Exists(Path.Combine(subDir, AspireConfigFile.FileName))); 220File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), "{}"); 362File.WriteAllText(configPath, """ 383File.WriteAllText(configPath, """ 458File.WriteAllText(settingsPath, """ 480File.WriteAllText(settingsPath, """ 503File.WriteAllText(settingsPath, """ 521File.WriteAllText(settingsPath, """ 532Assert.True(File.Exists(configPath)); 548File.WriteAllText(settingsPath, $$""" 569File.WriteAllText(settingsPath, """ 589File.WriteAllText(settingsPath, """ 609File.WriteAllText(settingsPath, """ 629File.WriteAllText(settingsPath, """ 650File.WriteAllText(settingsPath, """ 670File.WriteAllText(settingsPath, """ 688File.WriteAllText(settingsPath, """ 708File.WriteAllText(settingsPath, $$"""

18File.WriteAllText(settingsPath, content); 120File.WriteAllText(settingsPath, """ 131var json = JsonNode.Parse(File.ReadAllText(settingsPath)); 151File.WriteAllText(Path.Combine(configRoot.FullName, AspireConfigFile.FileName), "{}"); 192File.WriteAllText(legacySettingsPath, """ 200Assert.False(File.Exists(aspireConfigPath), "Precondition: aspire.config.json should not yet exist."); 209File.Exists(aspireConfigPath), 236File.WriteAllText(aspireConfigPath, existingContent); 240File.WriteAllText(legacySettingsPath, """ 250Assert.Equal(existingContent, File.ReadAllText(aspireConfigPath)); 264File.WriteAllText(legacySettingsPath, "{ this is not valid json"); 277Assert.False(File.Exists(migratedPath), "Unparseable legacy file must not produce an aspire.config.json on disk.");

25File.WriteAllText(settingsFilePath, existingContent); 57var result = File.ReadAllText(settingsFilePath); 80var result = File.ReadAllText(settingsFilePath); 102var result = File.ReadAllText(settingsFilePath); 119Assert.True(File.Exists(legacySettingsPath)); 120var result = File.ReadAllText(legacySettingsPath); 133var result = File.ReadAllText(settingsFilePath); 155var result = File.ReadAllText(settingsFilePath); 223await File.WriteAllTextAsync( 252await File.WriteAllTextAsync( 294var result = File.ReadAllText(settingsFilePath); 310var json = JsonNode.Parse(File.ReadAllText(settingsFilePath)); 333var json = JsonNode.Parse(File.ReadAllText(settingsFilePath)); 353var json = JsonNode.Parse(File.ReadAllText(settingsFilePath));

72Assert.False(File.Exists(Path.Combine(appPath, AspireConfigFile.FileName)));

64Assert.False(File.Exists(Path.Combine(appHostDirectory.FullName, AspireConfigFile.FileName)));

46await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 95await File.WriteAllTextAsync(appHostFile.FullName, "Not a real AppHost."); 134await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 170await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 212await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 251await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 279await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 313File.WriteAllText(cliPath, string.Empty); 314File.WriteAllText(Path.Combine(cliDirectory.FullName, "aspire.dll"), string.Empty); 326File.WriteAllText(cliPath, string.Empty); 327File.WriteAllText(Path.Combine(cliDirectory.FullName, "aspire.dll"), string.Empty); 331File.CreateSymbolicLink(linkPath, cliPath); 342File.WriteAllText(dotnetPath, string.Empty); 353File.WriteAllText(cliPath, string.Empty); 354File.WriteAllText(Path.Combine(cliDirectory.FullName, "aspire.dll"), string.Empty); 355File.WriteAllText(Path.Combine(cliDirectory.FullName, ".aspire-install.json"), """{"source":"script"}"""); 366File.WriteAllText(cliPath, string.Empty); 367File.WriteAllText(Path.Combine(cliDirectory.FullName, "aspire.dll"), string.Empty); 370File.WriteAllText(Path.Combine(cliDirectory.FullName, "dcp", OperatingSystem.IsWindows() ? "dcp.exe" : "dcp"), string.Empty); 371File.WriteAllText(Path.Combine(cliDirectory.FullName, "managed", OperatingSystem.IsWindows() ? "aspire-managed.exe" : "aspire-managed"), string.Empty); 381await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 409await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 446await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 475await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 504await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 577await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 614await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 655await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 700await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 755await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 852await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 892await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 934await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 981await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1044await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1090await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1132await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1174await File.WriteAllTextAsync(appHostFile.FullName, "// Single-file AppHost"); 1227await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 1294await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 1360await File.WriteAllTextAsync(projectFile.FullName, "<Project></Project>"); 1433await File.WriteAllTextAsync(solutionFile.FullName, "Not a real solution file."); 1438await File.WriteAllTextAsync(project1File.FullName, "Not a real project file."); 1442await File.WriteAllTextAsync(project2File.FullName, "Not a real project file."); 1480await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1483await File.WriteAllTextAsync(referencedProject.FullName, "Not a real project file."); 1513await File.WriteAllTextAsync(appHostFile.FullName, "// Single-file AppHost"); 1560await File.WriteAllTextAsync(appHostFile.FullName, "// Single-file AppHost"); 1606await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1643await File.WriteAllTextAsync(appHostFile.FullName, "// Single-file AppHost"); 1680await File.WriteAllTextAsync(appHostFile.FullName, "// Single-file AppHost"); 1721await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1766await File.WriteAllTextAsync(appHostFile.FullName, "// Single-file AppHost"); 1818await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1867await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1915await File.WriteAllTextAsync(appHostFile.FullName, "// Single-file AppHost"); 1952await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1987await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2030await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2072await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2112await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2152await File.WriteAllTextAsync(projectFile.FullName, """ 2162await File.WriteAllTextAsync(Path.Combine(projectDirectory.FullName, "Program.cs"), "Console.WriteLine(\"Hello\");"); 2197await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2418await File.WriteAllTextAsync(packagePath, string.Empty); 2488await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2526await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2564await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2604await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2643await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file.");

55await File.WriteAllTextAsync(dcpPath, """ 87File.SetUnixFileMode(dcpPath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 115], await File.ReadAllLinesAsync(capturePath)); 137await File.WriteAllTextAsync(dcpPath, """ 155File.SetUnixFileMode(dcpPath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 218await File.WriteAllTextAsync(dcpPath, """ 235File.SetUnixFileMode(dcpPath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 257await File.WriteAllTextAsync(dcpPath, """ 277File.SetUnixFileMode(dcpPath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 291var childPid = int.Parse(await File.ReadAllTextAsync(capturePath), CultureInfo.InvariantCulture); 311await File.WriteAllTextAsync(dcpPath, """ 328File.SetUnixFileMode(dcpPath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 352Assert.Equal(Path.GetFullPath(versionDirectory.FullName), (await File.ReadAllTextAsync(capturePath)).Trim()); 366await File.WriteAllTextAsync(dcpPath, """ 382File.SetUnixFileMode(dcpPath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 416await File.WriteAllTextAsync(dcpPath, """ 432File.SetUnixFileMode(dcpPath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); 474while (!File.Exists(path))

41await File.WriteAllTextAsync(outputFile.FullName, CreateJsonPayload(lineCount: 400)); 101await File.WriteAllTextAsync(outputFile.FullName, CreateJsonPayload(lineCount: 400)); 294await File.WriteAllTextAsync(scriptFile.FullName, content); 303await File.WriteAllTextAsync(scriptFile.FullName, content); 305File.SetUnixFileMode( 327await File.WriteAllTextAsync(scriptFile.FullName, content); 338await File.WriteAllTextAsync(scriptFile.FullName, content); 340File.SetUnixFileMode( 358await File.WriteAllTextAsync(scriptFile.FullName, content); 367await File.WriteAllTextAsync(scriptFile.FullName, content); 369File.SetUnixFileMode(

335await File.WriteAllTextAsync(scriptFile, script); 359await File.WriteAllTextAsync(shellFile, shellScript); 360File.SetUnixFileMode(

42await File.WriteAllTextAsync(trackedFile, "Not a real project file."); 47await File.WriteAllTextAsync(untrackedFile, "Not a real project file."); 51await File.WriteAllTextAsync(gitignorePath, "bin/\n"); 56await File.WriteAllTextAsync(ignoredFile, "Not a real project file."); 83await File.WriteAllTextAsync(trackedFile, "Not a real project file."); 89File.Delete(trackedFile); 110await File.WriteAllTextAsync(trackedFile, "Not a real project file.");

162File.WriteAllText( 185File.WriteAllText( 203File.WriteAllText( 224File.WriteAllText( 229var expectedRoot = File.Exists(caseVariantGitFile) 262File.WriteAllText( 302File.WriteAllText( 321File.WriteAllText(

44File.WriteAllText(realBinary, "stub"); 49File.CreateSymbolicLink(linkPath, realBinary); 75File.WriteAllText(realBinary, "stub"); 78File.CreateSymbolicLink(linkPath, realBinary); 102File.WriteAllText( 105File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(versionedDcp), "stub"); 142File.WriteAllText(binaryPath, "stub"); 186File.WriteAllText(binaryPath, "stub"); 227File.WriteAllText( 231File.WriteAllText(binaryPath, "stub"); 250File.WriteAllText( 253File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDir), "stub");

289while (dir is not null && !File.Exists(Path.Combine(dir.FullName, "Aspire.slnx"))) 301if (!File.Exists(cliProjectPath))

55await File.WriteAllTextAsync(appHostPath, "import { createBuilder } from './.modules/aspire.js';"); 70await File.WriteAllTextAsync( 83await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.ts"), "// legacy"); 84await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.mts"), "// modern"); 95await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.cs"), "// csharp"); 152await File.WriteAllTextAsync(Path.Combine(root.FullName, "apphost.ts"), LegacyAppHostContent); 153await File.WriteAllTextAsync( 162await File.WriteAllTextAsync( 170await File.WriteAllTextAsync( 181await File.WriteAllTextAsync(Path.Combine(root.FullName, "eslint.config.mjs"), LegacyEslintConfigContent); 184await File.WriteAllTextAsync(Path.Combine(modulesDir.FullName, "aspire.ts"), "// generated"); 189var config = JsonNode.Parse(await File.ReadAllTextAsync(Path.Combine(root.FullName, "aspire.config.json")))!; 192var tsconfig = JsonNode.Parse(await File.ReadAllTextAsync(Path.Combine(root.FullName, "tsconfig.apphost.json")))!; 196var packageJson = JsonNode.Parse(await File.ReadAllTextAsync(Path.Combine(root.FullName, "package.json")))!; 201var eslintConfig = await File.ReadAllTextAsync(Path.Combine(root.FullName, "eslint.config.mjs")); 214Assert.False(File.Exists(Path.Combine(root.FullName, "apphost.ts"))); 217var modernContent = await File.ReadAllTextAsync(Path.Combine(root.FullName, "apphost.mts")); 234Assert.False(File.Exists(Path.Combine(appHostDirectory.FullName, "apphost.ts"))); 236Assert.Equal(ExpectedModernAppHostContent, await File.ReadAllTextAsync(Path.Combine(appHostDirectory.FullName, "apphost.mts"))); 278var migratedContent = await File.ReadAllTextAsync(Path.Combine(root.FullName, "apphost.mts")); 282Assert.Equal(migratedContent, await File.ReadAllTextAsync(Path.Combine(root.FullName, "apphost.mts")));

44File.WriteAllText(layout.RidPackageJsonPath, "{ not valid json"); 67File.WriteAllText(monkeyPatchScript, """ 96File.WriteAllText(monkeyPatchScript, """ 139Assert.True(File.Exists(cachedBinaryPath), $"Expected cached binary at {cachedBinaryPath}"); 151File.WriteAllText(probeScript, $$""" 173File.WriteAllText(probeScript, $$""" 186var scriptContent = File.ReadAllText(scriptPath); 245File.WriteAllText( 252File.Copy(realLauncherPath, launcherScript); 256File.WriteAllText( 266File.WriteAllText( 275File.WriteAllText(probeScript, """ 292File.Copy(GetNodeExecutablePath(), binaryPath); 300File.WriteAllText(binaryPath, """ 408while (current is not null && !File.Exists(Path.Combine(current, "Aspire.slnx")))

180await File.ReadAllLinesAsync(argumentsPath, TestContext.Current.CancellationToken)); 251File.WriteAllText( 266File.WriteAllText( 272File.SetUnixFileMode(

31await File.WriteAllTextAsync(managedPath!, string.Empty); 86await File.WriteAllTextAsync(managedPath!, string.Empty); 135await File.WriteAllTextAsync(managedPath!, string.Empty);

27File.WriteAllText(managedPath, string.Empty); 68File.WriteAllText(managedPath, string.Empty); 102File.WriteAllText(managedPath, string.Empty); 105File.WriteAllText(nugetConfigPath, "<configuration />"); 139File.WriteAllText(managedPath, string.Empty); 151File.WriteAllText(manifestPath, "{}"); 183File.WriteAllText(managedPath, string.Empty); 195File.WriteAllText(manifestPath, "{ invalid json"); 205File.WriteAllText(manifestPath, """{"managedAssemblies":[],"nativeLibraries":[]}"""); 236File.WriteAllText(managedPath, "v1"); 250File.WriteAllText(managedPath, "v2-changed"); 271File.WriteAllText(managedPath, string.Empty); 315File.WriteAllText(managedPath, string.Empty); 343await File.WriteAllTextAsync( 386File.WriteAllText(managedPath, string.Empty); 394File.WriteAllText(lockedFilePath, "legacy");

35await File.WriteAllTextAsync(path, content);

25await File.WriteAllTextAsync(path, content); 47Assert.True(File.Exists(targetConfigPath)); 50var expected = await File.ReadAllTextAsync(tempConfig.ConfigFile.FullName); 51var actual = await File.ReadAllTextAsync(targetConfigPath); 71Assert.True(File.Exists(targetConfigPath)); 760Assert.True(File.Exists(targetConfigPath)); 790Assert.False(File.Exists(targetConfigPath)); 840Assert.True(File.Exists(targetConfigPath)); 861var originalContent = await File.ReadAllTextAsync(Path.Combine(root.FullName, "nuget.config")).DefaultTimeout(); 883var currentContent = await File.ReadAllTextAsync(targetConfigPath); 905Assert.True(File.Exists(targetConfigPath));

146File.WriteAllText( 178File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.ProjectTemplates.13.5.0.nupkg"), string.Empty); 182File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.ProjectTemplates.{pinnedVersion}.nupkg"), string.Empty); 225File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.ProjectTemplates.13.5.0.nupkg"), string.Empty); 228File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.ProjectTemplates.{pinnedVersion}.nupkg"), string.Empty); 266File.WriteAllText(Path.Combine(channelPackagesDirectory.FullName, "Aspire.ProjectTemplates.13.4.0-preview.1.nupkg"), string.Empty); 270File.WriteAllText(Path.Combine(nestedDirectory.FullName, "Aspire.ProjectTemplates.13.5.0-preview.2.nupkg"), string.Empty); 305File.WriteAllText(Path.Combine(nestedDirectory.FullName, "Aspire.ProjectTemplates.13.5.0-preview.2.nupkg"), string.Empty); 332File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.Redis.{pinnedVersion}.nupkg"), string.Empty); 333File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.PostgreSQL.{pinnedVersion}.nupkg"), string.Empty); 334File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"CommunityToolkit.Aspire.Hosting.NodeJS.{pinnedVersion}.nupkg"), string.Empty); 337File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.SqlServer.13.3.0.nupkg"), string.Empty); 340File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.ProjectTemplates.{pinnedVersion}.nupkg"), string.Empty); 347File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.AppHost.{pinnedVersion}.nupkg"), string.Empty); 348File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.Sdk.{pinnedVersion}.nupkg"), string.Empty); 349File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.Orchestration.linux-arm64.{pinnedVersion}.nupkg"), string.Empty); 350File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.Testing.{pinnedVersion}.nupkg"), string.Empty); 351File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.Msi.{pinnedVersion}.nupkg"), string.Empty); 352File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.Integration.Analyzers.{pinnedVersion}.nupkg"), string.Empty); 355File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.Dapr.{pinnedVersion}.nupkg"), string.Empty); 356File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.GitHub.Models.{pinnedVersion}.nupkg"), string.Empty); 357File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.Hosting.NodeJs.{pinnedVersion}.nupkg"), string.Empty); 640File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Redis.13.4.0.nupkg"), string.Empty); 641File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Redis.13.5.0-preview.1.nupkg"), string.Empty); 642File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.PostgreSQL.13.4.0-preview.1.nupkg"), string.Empty); 659File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Redis.13.4.0.nupkg"), string.Empty); 660File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Redis.13.5.0-preview.1.nupkg"), string.Empty); 661File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.PostgreSQL.13.4.0.nupkg"), string.Empty); 678File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Redis.13.5.0.nupkg"), string.Empty); 679File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Redis.13.6.0-preview.1.nupkg"), string.Empty); 680File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Azure.Kubernetes.13.6.0-pr.19404.gf51e8e1d.nupkg"), string.Empty); 709File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Dapr.13.4.0.nupkg"), string.Empty); 710File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Sql.13.4.0.nupkg"), string.Empty); 729File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Dapr.13.4.0.nupkg"), string.Empty); 730File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.Hosting.Sql.13.4.0.nupkg"), string.Empty);

1122Assert.True(File.Exists(nugetConfigPath)); 1124var configContent = await File.ReadAllTextAsync(nugetConfigPath); 1377Assert.True(File.Exists(nugetConfigPath)); 1379var configContent = await File.ReadAllTextAsync(nugetConfigPath); 1492File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.ProjectTemplates.{localVersion}.nupkg"), string.Empty); 1493File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.Hosting.{localVersion}.nupkg"), string.Empty); 1516File.WriteAllText(processPath, string.Empty); 1519File.WriteAllText(Path.Combine(packagesDirectory.FullName, $"Aspire.ProjectTemplates.{prVersion}.nupkg"), string.Empty); 1558File.WriteAllText(Path.Combine(defaultPackagesDirectory.FullName, $"Aspire.ProjectTemplates.{defaultHiveVersion}.nupkg"), string.Empty); 1563File.WriteAllText(processPath, string.Empty); 1566File.WriteAllText(Path.Combine(dogfoodPackagesDirectory.FullName, $"Aspire.ProjectTemplates.{dogfoodHiveVersion}.nupkg"), string.Empty); 1599File.WriteAllText(processPath, string.Empty); 1602File.WriteAllText(Path.Combine(packagesDirectory.FullName, "Aspire.ProjectTemplates.not-a-semver.nupkg"), string.Empty); 1635File.WriteAllText(processPath, string.Empty); 1665File.WriteAllText(processPath, string.Empty); 1721File.WriteAllText(processPath, string.Empty); 1757File.WriteAllText(processPath, string.Empty); 1780File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.ProjectTemplates.{localVersion}.nupkg"), string.Empty); 1972File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.ProjectTemplates.{pinnedVersion}.nupkg"), string.Empty); 2005File.WriteAllText(Path.Combine(runPackagesDir.FullName, $"Aspire.ProjectTemplates.{pinnedVersion}.nupkg"), string.Empty); 2040File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.Hosting.{localVersion}.nupkg"), string.Empty); 2042File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.Hosting.Redis.{localVersion}.nupkg"), string.Empty); 2043File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.Hosting.JavaScript.{localVersion}.nupkg"), string.Empty); 2045File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.ProjectTemplates.{localVersion}.nupkg"), string.Empty); 2046File.WriteAllText(Path.Combine(localPackagesDir.FullName, $"Aspire.AppHost.Sdk.{localVersion}.nupkg"), string.Empty); 2077File.WriteAllText(Path.Combine(localPackagesDir.FullName, "Aspire.Hosting.13.4.0-pr.16820.g1a99aa46.nupkg"), string.Empty); 2169File.WriteAllText(Path.Combine(packagesOverrideDir.FullName, $"Aspire.ProjectTemplates.{overrideVersion}.nupkg"), string.Empty); 2170File.WriteAllText(Path.Combine(packagesOverrideDir.FullName, $"Aspire.Hosting.{overrideVersion}.nupkg"), string.Empty); 2197File.WriteAllText(Path.Combine(staleHiveDir.FullName, "Aspire.Hosting.13.4.0.nupkg"), string.Empty); 2201File.WriteAllText(Path.Combine(packagesOverrideDir.FullName, $"Aspire.Hosting.{overrideVersion}.nupkg"), string.Empty); 2227File.WriteAllText(Path.Combine(packagesOverrideDir.FullName, "Aspire.Hosting.13.4.1.nupkg"), string.Empty); 2228File.WriteAllText(Path.Combine(packagesOverrideDir.FullName, "Aspire.Hosting.13.4.2.nupkg"), string.Empty); 2230File.WriteAllText(Path.Combine(packagesOverrideDir.FullName, "Aspire.ProjectTemplates.13.4.2.nupkg"), string.Empty); 2255File.WriteAllText(Path.Combine(packagesOverrideDir.FullName, "Aspire.Hosting.13.4.1.nupkg"), string.Empty); 2257File.WriteAllText(Path.Combine(nestedDir.FullName, "Aspire.Hosting.13.4.2.nupkg"), string.Empty); 2259File.WriteAllText(Path.Combine(nestedDir.FullName, "Aspire.ProjectTemplates.13.4.2.nupkg"), string.Empty); 2260File.WriteAllText(Path.Combine(packagesOverrideDir.FullName, "Aspire.ProjectTemplates.13.4.2.nupkg"), string.Empty);

26var configContent = await File.ReadAllTextAsync(tempConfig.ConfigFile.FullName); 65var configContent = await File.ReadAllTextAsync(tempConfig.ConfigFile.FullName); 96var configContent = await File.ReadAllTextAsync(tempConfig.ConfigFile.FullName); 119var configContent = await File.ReadAllTextAsync(tempConfig.ConfigFile.FullName); 141var configContent = await File.ReadAllTextAsync(tempConfig.ConfigFile.FullName); 160var configContent = await File.ReadAllTextAsync(tempConfig.ConfigFile.FullName); 194xmlDoc.LoadXml(await File.ReadAllTextAsync(tempConfig.ConfigFile.FullName));

25File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDirectory.FullName), string.Empty); 62File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDirectory.FullName), string.Empty); 87File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(mutableDcpDirectory.FullName), string.Empty); 92File.WriteAllText(leasedDcpPath, string.Empty); 150File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDirectory.FullName), string.Empty); 206File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDirectory.FullName), string.Empty); 245File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDirectory.FullName), string.Empty); 284File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDirectory.FullName), string.Empty);

120File.WriteAllText(expectedManagedPath, string.Empty); 141File.WriteAllText(expectedManagedPath, string.Empty);

94File.WriteAllText(managedPath, string.Empty); 337Assert.True(File.Exists(outputPath)); 373Assert.True(File.Exists(options.OutputPath)); 394Assert.False(File.Exists(options.OutputPath)); 410Assert.False(File.Exists(options.OutputPath)); 464File.WriteAllText(managedPath, string.Empty); 676File.WriteAllText(path, string.Empty);

94File.WriteAllText(settingsPath, """{ "appHost": { "path": "AppHost.csproj" } }"""); 111File.WriteAllText(settingsPath, """{ "channel": "daily" }"""); 128File.WriteAllText(settingsPath, content);

541await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, ".gitignore"), "legacy/\n"); 609await File.WriteAllTextAsync(fullPath, "Not a real project file.");

207File.WriteAllText(path, "<Project Sdk=\"Microsoft.NET.Sdk;Aspire.AppHost.Sdk/9.5.0\" />");

64var content = await File.ReadAllTextAsync(appSettingsPath); 85var content = await File.ReadAllTextAsync(programCsPath); 107Assert.True(File.Exists(programCs)); 109var content = await File.ReadAllTextAsync(programCs); 130Assert.True(File.Exists(appSettingsPath)); 132var content = await File.ReadAllTextAsync(appSettingsPath); 213await File.WriteAllTextAsync(integrationProjectPath, "<Project />"); 321await File.WriteAllTextAsync(aspireConfigPath, """ 401Assert.True(File.Exists(projectFilePath), $"Project file should be created at {projectFilePath}"); 403var projectContent = await File.ReadAllTextAsync(projectFilePath); 425await File.WriteAllTextAsync(aspireConfigPath, """ 479await File.WriteAllTextAsync(aspireConfigPath, """

450File.WriteAllText(integrationCachePathBlockedByFile, string.Empty);

15File.WriteAllText(target.FullName, "<Project />"); 32File.WriteAllText(target.FullName, "<Project />"); 50File.WriteAllText(target.FullName, "<Project />"); 62File.WriteAllText(target.FullName, "<Project />"); 82File.WriteAllText(target.FullName, "<Project />"); 97File.CreateSymbolicLink(linkPath, targetPath);

198File.WriteAllText(appHostPath, "void main(String[] args) { }");

266File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "apphost.run.json"), """ 395Assert.False(File.Exists(socketPath)); 412Assert.True(File.Exists(socketPath)); 483File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(customDcpDirectory.FullName), ""); 487File.WriteAllText(customDashboardPath, ""); 536File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(inheritedDcpDirectory), ""); 538File.WriteAllText(inheritedDashboardPath, ""); 698File.Delete(BundleDiscovery.GetDcpExecutablePath(layout.GetDcpPath()!)); 699File.Delete(layout.GetManagedPath()!); 871File.WriteAllText(repoLocalManaged, "fake"); 986File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 1081File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 1165File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 1251File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 1293File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 1337File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), $$""" 1384File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 1429File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 1549File.WriteAllText(targetPath, string.Empty); 1633File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 1700File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), $$""" 1803File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "AppHost.run.json"), """ 1869File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "My Project", "launchSettings.json"), """ 1930File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 1995File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 2052File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "Properties", "launchSettings.json"), """ 2176File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "apphost.run.json"), """ 2378File.WriteAllText(Path.Combine(appHostFile.DirectoryName!, "apphost.run.json"), """ 2534File.WriteAllText(appHostPath, """ 2556File.WriteAllText(socketPath, ""); 2564File.WriteAllText(targetPath, string.Empty); 2565File.WriteAllText(Path.ChangeExtension(targetPath, ".runtimeconfig.json"), "{}"); 2573File.WriteAllText(commandPath, string.Empty); 4155while (dir is not null && !File.Exists(Path.Combine(dir.FullName, "Aspire.slnx"))) 4179File.WriteAllText(path, content); 4209File.WriteAllText(appHostPath, """ 4226File.WriteAllText(projectPath, """ 4242File.WriteAllText(BundleDiscovery.GetDcpExecutablePath(dcpDirectory.FullName), ""); 4243File.WriteAllText( 4299=> File.WriteAllText(Path.Combine(directory, "aspire.config.json"), content);

36Assert.True(File.Exists(assetsPath), 60Assert.False(File.Exists(assetsPath), 63var csproj = await File.ReadAllTextAsync( 83File.Delete(programPath); 87Assert.True(File.Exists(programPath), "Program.cs was not restored after being deleted."); 106File.WriteAllText(stalePath, "partial restore"); 110Assert.False(File.Exists(stalePath), 132Assert.Contains(firstProject, await File.ReadAllTextAsync(csprojPath)); 137Assert.False(File.Exists(assetsPath), 139Assert.Contains(secondProject, await File.ReadAllTextAsync(csprojPath)); 152File.WriteAllText(assetsPath, "{}");

31await File.WriteAllTextAsync(projectFile, projectContent); 56await File.WriteAllTextAsync(projectFile, projectContent); 81await File.WriteAllTextAsync(projectFile, projectContent); 106await File.WriteAllTextAsync(projectFile, projectContent); 132await File.WriteAllTextAsync(projectFile, projectContent); 158await File.WriteAllTextAsync(projectFile, projectContent); 195await File.WriteAllTextAsync(projectFile, invalidProjectContent); 217await File.WriteAllTextAsync(projectFile, projectContent); 247await File.WriteAllTextAsync(projectFile, projectContent); 270await File.WriteAllTextAsync(projectFile, projectContent); 294await File.WriteAllTextAsync(projectFile, projectContent); 317await File.WriteAllTextAsync(projectFile, projectContent); 339await File.WriteAllTextAsync(projectFile, projectContent); 357await File.WriteAllTextAsync(projectFile, projectContent);

55await File.WriteAllTextAsync(kept, "class Kept { }"); 56await File.WriteAllTextAsync(obsolete, "class RemovedResource { }"); 72Assert.True(File.Exists(kept)); 73Assert.False(File.Exists(obsolete)); 82await File.WriteAllTextAsync(handWritten, "class HandWritten { }"); 89Assert.True(File.Exists(handWritten)); 96await File.WriteAllTextAsync(filePath, "class Generated { }"); 98File.SetLastWriteTimeUtc(filePath, originalWriteTime); 105Assert.Equal(originalWriteTime, File.GetLastWriteTimeUtc(filePath)); 112await File.WriteAllTextAsync(filePath, "class Generated { }"); 113File.SetLastWriteTimeUtc(filePath, new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc)); 118Assert.Equal("class Generated { int x; }", await File.ReadAllTextAsync(filePath)); 119Assert.True(File.GetLastWriteTimeUtc(filePath) > new DateTime(2020, 1, 2, 0, 0, 0, DateTimeKind.Utc)); 130Assert.Equal("class New { }", await File.ReadAllTextAsync(filePath)); 137await File.WriteAllTextAsync(filePath, "def add_redis(): ..."); 139File.SetLastWriteTimeUtc(filePath, originalWriteTime); 147Assert.True(File.GetLastWriteTimeUtc(filePath) > originalWriteTime); 179File.WriteAllText(settingsPath, """ 199File.WriteAllText(settingsPath, """ 385File.WriteAllText(settingsPath, """ 403var json = File.ReadAllText(settingsPath); 432var content = await File.ReadAllTextAsync(settingsPath); 445File.WriteAllText(launchSettingsPath, """ 534File.WriteAllText(aspireConfigPath, """ 726await File.WriteAllTextAsync(configPath, """ 734await File.WriteAllTextAsync(appHostPath, "// test apphost"); 779await File.WriteAllTextAsync(configPath, """ 787await File.WriteAllTextAsync(appHostPath, "// test apphost"); 820await File.WriteAllTextAsync(appHostPath, "// test apphost"); 837Assert.False(File.Exists(socketPath)); 844await File.WriteAllTextAsync(configPath, """ 853await File.WriteAllTextAsync(appHostPath, "// test apphost"); 900await File.WriteAllTextAsync(configPath, """ 908await File.WriteAllTextAsync(appHostPath, "// test apphost"); 955await File.WriteAllTextAsync(configPath, """ 964await File.WriteAllTextAsync(appHostPath, "// test apphost"); 1039await File.WriteAllTextAsync(configPath, seededJson); 1042await File.WriteAllTextAsync(appHostPath, "// test apphost"); 1139await File.WriteAllTextAsync(appHostPath, "// test apphost"); 1181await File.WriteAllTextAsync(appHostPath, "// test apphost"); 1260await File.WriteAllTextAsync(configPath, $$""" 1268await File.WriteAllTextAsync(appHostPath, "// test apphost"); 1349await File.WriteAllTextAsync(configPath, $$""" 1357await File.WriteAllTextAsync(appHostPath, "// test apphost"); 1446File.WriteAllText(socketPath, ""); 1585await File.WriteAllTextAsync(existingBundlePath, "existing certificate", TestContext.Current.CancellationToken); 1586await File.WriteAllTextAsync(devCertificatePath, "development certificate", TestContext.Current.CancellationToken); 1587var expectedDevCertificateContents = await File.ReadAllBytesAsync(devCertificatePath, TestContext.Current.CancellationToken); 1588var expectedExistingBundleContents = await File.ReadAllBytesAsync(existingBundlePath, TestContext.Current.CancellationToken); 1607await File.ReadAllBytesAsync(envVars["NODE_EXTRA_CA_CERTS"], TestContext.Current.CancellationToken)); 1641await File.WriteAllTextAsync(existingBundlePath, existingBundleContents, TestContext.Current.CancellationToken); 1642await File.WriteAllTextAsync(inheritedBundlePath, inheritedBundleContents, TestContext.Current.CancellationToken); 1643await File.WriteAllTextAsync(devCertificatePath, devCertificateContents, TestContext.Current.CancellationToken); 1674Assert.Equal(expectedBundleContents, await File.ReadAllBytesAsync(expectedBundlePath, TestContext.Current.CancellationToken)); 1677File.SetLastWriteTimeUtc(expectedBundlePath, cachedWriteTime); 1678cachedWriteTime = File.GetLastWriteTimeUtc(expectedBundlePath); 1689Assert.Equal(cachedWriteTime, File.GetLastWriteTimeUtc(expectedBundlePath)); 1696File.GetUnixFileMode(Path.GetDirectoryName(expectedBundlePath)!)); 1699File.GetUnixFileMode(expectedBundlePath)); 1709await File.WriteAllTextAsync(devCertificatePath, "dev certificate", TestContext.Current.CancellationToken);

755Assert.True(File.Exists(logFilePath), "Log file should exist"); 756var logContents = await File.ReadAllTextAsync(logFilePath); 765if (File.Exists(logFilePath)) 767File.Delete(logFilePath); 976Assert.False(File.Exists(migrationFilePath)); 981Assert.True(File.Exists(migrationFilePath)); 982var writtenContent = await File.ReadAllTextAsync(migrationFilePath); 998await File.WriteAllTextAsync(migrationFilePath, existingContent); 1025var writtenContent = await File.ReadAllTextAsync(migrationFilePath); 1059Assert.True(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "classes", ".aspire-compile-stamp"))); 1090File.SetLastWriteTimeUtc(input, DateTime.UtcNow.AddMinutes(1)); 1111File.WriteAllText(classFile, ""); 1113File.SetLastWriteTimeUtc(classFile, DateTime.UtcNow.AddMinutes(1)); 1138File.Delete(Path.Combine(workspace.WorkspaceRoot.FullName, relativeInput.Replace('/', Path.DirectorySeparatorChar))); 1154File.WriteAllText(pom, "<project/>"); 1160File.SetLastWriteTimeUtc(pom, DateTime.UtcNow.AddMinutes(1)); 1177File.WriteAllText(Path.Combine(dependencies, "guava-32.0.0.jar"), ""); 1188File.Delete(Path.Combine(dependencies, "guava-32.0.0.jar")); 1189File.WriteAllText(Path.Combine(dependencies, "guava-33.0.0.jar"), ""); 1207File.WriteAllText(jar, ""); 1213File.SetLastWriteTimeUtc(jar, DateTime.UtcNow.AddMinutes(1)); 1235File.WriteAllText(unrelated, ""); 1237File.SetLastWriteTimeUtc(unrelated, DateTime.UtcNow.AddMinutes(1)); 1277File.WriteAllText(nested, "class Resources { }"); 1279File.SetLastWriteTimeUtc(nested, DateTime.UtcNow.AddMinutes(1)); 1307File.WriteAllText(path, ""); 1318File.SetLastWriteTimeUtc(path, DateTime.UtcNow.AddMinutes(1)); 1348File.WriteAllText(Path.Combine(unreadable, "Hidden.java"), "class Hidden { }"); 1373File.SetUnixFileMode(path, mode); 1389Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, "classes", ".aspire-compile-stamp"))); 1415File.WriteAllText(appHostFile.FullName, "class AppHost { }"); 1416File.WriteAllText(Path.Combine(root.FullName, "Helper.java"), "class Helper { }"); 1420File.WriteAllText(Path.Combine(generated, "Generated.java"), "class Generated { }"); 1424File.WriteAllText(Path.Combine(sources, "Service.java"), "class Service { }"); 1439File.SetLastWriteTimeUtc(file, timestampUtc); 1455File.WriteAllText(stamp, ""); 1456File.SetLastWriteTimeUtc(stamp, timestampUtc);

14File.WriteAllText(path, ""); 81File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 92File.WriteAllText(Path.Combine(workspace.Path, buildFileName), ""); 101File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 102File.WriteAllText(Path.Combine(workspace.Path, "build.gradle"), ""); 111File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 135File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 183File.WriteAllText(Path.Combine(workspace.Path, buildFileName), ""); 234File.WriteAllText(Path.Combine(workspace.Path, "build.gradle"), ""); 272File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 307File.WriteAllText(wrapperPath, ""); 344File.WriteAllText(rootWrapperPath, ""); 347File.WriteAllText(Path.Combine(moduleDirectory.FullName, useMaven ? "pom.xml" : "build.gradle"), ""); 372File.WriteAllText(Path.Combine(workspace.Path, OperatingSystem.IsWindows() ? windowsWrapperName : wrapperName), ""); 376File.WriteAllText(Path.Combine(innerCheckout.FullName, useMaven ? "pom.xml" : "build.gradle"), ""); 388File.WriteAllText(Path.Combine(directory, "pom.xml"), ""); 392File.WriteAllText(Path.Combine(directory, "settings.gradle"), ""); 400File.WriteAllText(Path.Combine(workspace.Path, "build.gradle"), ""); 407Assert.Contains("aspireCopyDependencies", await File.ReadAllTextAsync(scriptPath)); 409await File.WriteAllTextAsync(scriptPath, "// stale"); 412Assert.Contains("aspireCopyDependencies", await File.ReadAllTextAsync(scriptPath)); 419File.WriteAllText(Path.Combine(workspace.Path, "build.gradle"), ""); 424var script = await File.ReadAllTextAsync(Path.Combine(workspace.Path, ".aspire", "aspire-gradle-init.gradle")); 435File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 439await File.WriteAllTextAsync(Path.Combine(dependencyDirectory, "library-1.0.jar"), ""); 452File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 463File.WriteAllText(Path.Combine(workspace.Path, "build.gradle"), ""); 468await File.WriteAllTextAsync(Path.Combine(dependencyDirectory, "library-1.0.jar"), ""); 485File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 502File.WriteAllText(Path.Combine(workspace.Path, buildFileName), ""); 517File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 527File.WriteAllText(Path.Combine(workspace.Path, "pom.xml"), "<project />"); 569File.WriteAllText(Path.Combine(workspace.Path, "build.gradle"), ""); 579Assert.Contains("aspireCopyDependencies", await File.ReadAllTextAsync(scriptPath));

65File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.ts"), ""); 76File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "MyApp.csproj"), ""); 89File.WriteAllText(Path.Combine(nested, "apphost.cs"), ""); 103File.WriteAllText(Path.Combine(deep, "apphost.cs"), "");

14File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.ts"), "// legacy"); 23File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.ts"), "// legacy"); 24File.WriteAllText(Path.Combine(workspace.WorkspaceRoot.FullName, "apphost.mts"), "// modern");

33var firstWrite = File.GetLastWriteTimeUtc(path); 36File.SetLastWriteTimeUtc(path, firstWrite.AddMinutes(-5)); 37var backdated = File.GetLastWriteTimeUtc(path); 40Assert.Equal(backdated, File.GetLastWriteTimeUtc(path)); 41Assert.Equal("<Project />", await File.ReadAllTextAsync(path)); 52Assert.Equal("<Project Sdk=\"Microsoft.NET.Sdk\" />", await File.ReadAllTextAsync(path)); 62await File.WriteAllTextAsync(path, "<Project />"); 69File.SetUnixFileMode(path, UnixFileMode.UserWrite); 76File.SetUnixFileMode(path, UnixFileMode.UserRead | UnixFileMode.UserWrite); 79Assert.Equal("<Project Sdk=\"Microsoft.NET.Sdk\" />", await File.ReadAllTextAsync(path)); 122await File.WriteAllTextAsync(referencedProject, """<Project><ItemGroup><PackageReference Include="Aspire.Hosting" Version="13.5.0" /></ItemGroup></Project>"""); 129await File.WriteAllTextAsync(referencedProject, """<Project><ItemGroup><PackageReference Include="Aspire.Hosting" Version="13.6.0-dev" /></ItemGroup></Project>"""); 143await File.WriteAllTextAsync(referencedProject, """<Project><ItemGroup><PackageReference Include="Aspire.Hosting" /></ItemGroup></Project>"""); 145await File.WriteAllTextAsync(packagesProps, """<Project><ItemGroup><PackageVersion Include="Aspire.Hosting" Version="13.5.0" /></ItemGroup></Project>"""); 150await File.WriteAllTextAsync(packagesProps, """<Project><ItemGroup><PackageVersion Include="Aspire.Hosting" Version="13.6.0-dev" /></ItemGroup></Project>"""); 161await File.WriteAllTextAsync(leaf, """<Project><ItemGroup><PackageReference Include="Aspire.Hosting" Version="13.5.0" /></ItemGroup></Project>"""); 163await File.WriteAllTextAsync(referencedProject, """<Project><ItemGroup><ProjectReference Include="Leaf.csproj" /></ItemGroup></Project>"""); 170await File.WriteAllTextAsync(leaf, """<Project><ItemGroup><PackageReference Include="Aspire.Hosting" Version="13.6.0-dev" /></ItemGroup></Project>"""); 181await File.WriteAllTextAsync(leaf, """<Project><ItemGroup><PackageReference Include="Some.Package" Version="13.4.*" /></ItemGroup></Project>"""); 183await File.WriteAllTextAsync(referencedProject, """<Project><ItemGroup><ProjectReference Include="Leaf.csproj" /></ItemGroup></Project>"""); 199await File.WriteAllTextAsync(first, """<Project><ItemGroup><ProjectReference Include="Second.csproj" /></ItemGroup></Project>"""); 200await File.WriteAllTextAsync(second, """<Project><ItemGroup><ProjectReference Include="First.csproj" /></ItemGroup></Project>"""); 213await File.WriteAllTextAsync(referencedProject, "<Project />"); 229await File.WriteAllTextAsync(referencedProject, """<Project><ItemGroup><PackageReference Include="Some.Package" Version="13.4.*" /></ItemGroup></Project>"""); 242await File.WriteAllTextAsync(referencedProject, """<Project ToolsVersion="4.0"><ItemGroup><PackageReference Include="Some.Package" Version="13.5.0" /></ItemGroup></Project>"""); 356File.WriteAllText(Path.Combine(objDir, "project.assets.json"), "{}"); 359File.WriteAllText(Path.Combine(objDir, "aspire-restore.stamp"), fingerprint); 1373await File.WriteAllTextAsync(aspireConfigPath, """ 1403Assert.True(File.Exists(appSettingsPath)); 1405var appSettingsContent = await File.ReadAllTextAsync(appSettingsPath); 1564await File.WriteAllTextAsync(aspireConfigPath, $$""" 1623await File.WriteAllTextAsync(aspireConfigPath, """ 1683await File.WriteAllTextAsync(aspireConfigPath, """ 1742await File.WriteAllTextAsync(aspireConfigPath, """ 1802await File.WriteAllTextAsync(aspireConfigPath, $$""" 1857await File.WriteAllTextAsync(aspireConfigPath, """ 1922await File.WriteAllTextAsync(aspireConfigPath, """ 2005await File.WriteAllTextAsync(aspireConfigPath, """ 2094await File.WriteAllTextAsync(aspireConfigPath, """ 2176await File.WriteAllTextAsync(aspireConfigPath, """ 2252restoreConfigFileExistedDuringBuild = restoreConfigFile is not null && File.Exists(restoreConfigFile); 2317temporaryNuGetConfigContent = File.ReadAllText(GetArgumentValue(args, "--nuget-config")); 2399Assert.True(File.Exists(Path.Combine(layoutPath, "libs", "MyIntegration.dll"))); 2473await using var probeManifestStream = File.OpenRead(probeManifestPath); 2527await using var probeManifestStream = File.OpenRead(probeManifestPath); 2611await File.WriteAllTextAsync(copiedFilePath, "corrupt"); 2617Assert.Equal("integration-v1", await File.ReadAllTextAsync(copiedFilePath)); 2658Assert.True(File.Exists(lockedFilePath)); 2659Assert.True(File.Exists(Path.Combine(secondLayoutPath, "libs", "MyIntegration.dll"))); 2678File.WriteAllText(firstSourcePath, "redis"); 2679File.WriteAllText(secondSourcePath, "redis"); 2724File.WriteAllText(firstPackagePath, "redis"); 2725File.WriteAllText(secondPackagePath, "redis"); 2726File.WriteAllText(projectPath, "integration"); 2785File.SetLastWriteTimeUtc(packageSourcePath, File.GetLastWriteTimeUtc(packageSourcePath).AddMinutes(5)); 2858File.WriteAllText( 2887if (!File.Exists(sourcePath) || File.ReadAllText(sourcePath) != content) 2889File.WriteAllText(sourcePath, content); 2900File.WriteAllLines(Path.Combine(restoreDirectory.FullName, PrebuiltAppHostServer.ClosureMetadataFileName), metadataLines); 2901File.WriteAllLines(Path.Combine(restoreDirectory.FullName, PrebuiltAppHostServer.ClosureSourcesFileName), sourcePaths); 2902File.WriteAllLines(Path.Combine(restoreDirectory.FullName, PrebuiltAppHostServer.ClosureTargetsFileName), targetPaths); 2903File.WriteAllLines(Path.Combine(restoreDirectory.FullName, PrebuiltAppHostServer.ProjectRefAssemblyNamesFileName), projectReferenceAssemblyNames); 2946File.WriteAllText(Path.Combine(objDirectory.FullName, "project.assets.json"), projectAssetsContent);

341await File.WriteAllTextAsync(scriptFile.FullName, content); 352await File.WriteAllTextAsync(shellFile.FullName, shellContent); 353File.SetUnixFileMode(

49await File.WriteAllTextAsync( 65await File.WriteAllTextAsync(firstAppHostProjectFile.FullName, "Not a real apphost"); 69await File.WriteAllTextAsync(secondAppHostProjectFile.FullName, "Not a real apphost"); 73await File.WriteAllTextAsync(configPath, originalConfig); 86Assert.Equal(originalConfig, await File.ReadAllTextAsync(configPath)); 96await File.WriteAllTextAsync(firstAppHostProjectFile.FullName, "Not a real apphost"); 100await File.WriteAllTextAsync(secondAppHostProjectFile.FullName, "Not a real apphost"); 104await File.WriteAllTextAsync(configPath, originalConfig); 115Assert.Equal(originalConfig, await File.ReadAllTextAsync(configPath)); 125await File.WriteAllTextAsync(firstAppHostProjectFile.FullName, "Not a real apphost"); 129await File.WriteAllTextAsync(secondAppHostProjectFile.FullName, "Not a real apphost"); 133await File.WriteAllTextAsync(configPath, originalConfig); 146Assert.Equal(originalConfig, await File.ReadAllTextAsync(configPath)); 158await File.WriteAllTextAsync(firstAppHostProjectFile.FullName, "Not a real apphost"); 162await File.WriteAllTextAsync(secondAppHostProjectFile.FullName, "Not a real apphost"); 165await File.WriteAllTextAsync(configPath, """{"appHost":{"path":"FirstAppHost/FirstAppHost.csproj"}}"""); 191await File.WriteAllTextAsync(firstAppHostProjectFile.FullName, "Not a real apphost"); 195await File.WriteAllTextAsync(firstAlternative.FullName, "Not a real apphost"); 197await File.WriteAllTextAsync(secondAlternative.FullName, "Not a real apphost"); 200await File.WriteAllTextAsync(configPath, """{"appHost":{"path":"FirstAppHost/FirstAppHost.csproj"}}"""); 224await File.WriteAllTextAsync(firstAppHostProjectFile.FullName, "Not a real apphost"); 228await File.WriteAllTextAsync(alternativeAppHost.FullName, "Not a real apphost"); 232await File.WriteAllTextAsync(configPath, originalConfig); 243Assert.Equal(originalConfig, await File.ReadAllTextAsync(configPath)); 253await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real apphost"); 277await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real apphost"); 302await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real apphost"); 307await File.WriteAllTextAsync(configPath, """{"sdk":{"version":"9.9.9"}}"""); 341using (var document = JsonDocument.Parse(await File.ReadAllTextAsync(configPath))) 372await File.WriteAllTextAsync(firstAppHostProjectFile.FullName, "Not a real apphost"); 376await File.WriteAllTextAsync(secondAppHostProjectFile.FullName, "Not a real apphost"); 379await File.WriteAllTextAsync(configPath, """{"appHost":{"path":"FirstAppHost/FirstAppHost.csproj"}}"""); 403await File.WriteAllTextAsync(firstAppHostProjectFile.FullName, "Not a real apphost"); 407await File.WriteAllTextAsync(secondAppHostProjectFile.FullName, "Not a real apphost"); 411await File.WriteAllTextAsync(configPath, originalConfig); 429Assert.Equal(originalConfig, await File.ReadAllTextAsync(configPath)); 439await File.WriteAllTextAsync(firstAppHostProjectFile.FullName, "Not a real apphost"); 443await File.WriteAllTextAsync(secondAppHostProjectFile.FullName, "Not a real apphost"); 446await File.WriteAllTextAsync(configPath, """{"appHost":{"path":"FirstAppHost/FirstAppHost.csproj"}}"""); 478using var document = JsonDocument.Parse(File.ReadAllText(configPath)); 509await File.WriteAllTextAsync(projectFile.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 529Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName))); 541await File.WriteAllTextAsync(brokenAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 545await File.WriteAllTextAsync(decoyAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 550await File.WriteAllTextAsync(aspireSettingsFile.FullName, JsonSerializer.Serialize(new 579Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName))); 591await File.WriteAllTextAsync(outsideAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 595await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 629await File.WriteAllTextAsync(appHostFile.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 692await File.WriteAllTextAsync(projectFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk.Web\"></Project>"); 721await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 725await File.WriteAllTextAsync(otherAppHostProjectFile.FullName, "Not a real apphost"); 754await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 785await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 812await File.WriteAllTextAsync(realAppHostProjectFile.FullName, "Not a real apphost project"); 853await File.WriteAllTextAsync(staleProjectFile.FullName, "Not a real apphost project"); 856await File.WriteAllTextAsync(realAppHostProjectFile.FullName, "Not a real apphost project"); 906await File.WriteAllTextAsync(aspireSettingsFile.FullName, JsonSerializer.Serialize(new 929await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 964await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 968await File.WriteAllTextAsync(decoyAppHostProjectFile.FullName, "Not a real apphost"); 971await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 1002await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 1006await File.WriteAllTextAsync(decoyAppHostProjectFile.FullName, "Not a real apphost"); 1009await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 1039await File.WriteAllTextAsync(guestAppHostFile.FullName, "// guest apphost"); 1042await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 1076await File.WriteAllTextAsync(configuredAppHostProjectFile.FullName, "Not a real apphost"); 1079await File.WriteAllTextAsync(realAppHostProjectFile.FullName, "Not a real apphost"); 1082await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 1129await File.WriteAllTextAsync(configuredAppHostProjectFile.FullName, "Not a real apphost"); 1132await File.WriteAllTextAsync(realAppHostProjectFile.FullName, "Not a real apphost"); 1135await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 1181await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 1185await File.WriteAllTextAsync(otherAppHostProjectFile.FullName, "Not a real apphost"); 1188await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 1218await File.WriteAllTextAsync(settingsAppHostFile.FullName, "Not a real apphost"); 1224await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 1257await File.WriteAllTextAsync(settingsAppHostFile.FullName, "Not a supported apphost type"); 1260await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 1292await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 1322await File.WriteAllTextAsync(projectFile1.FullName, "Not a real project file."); 1325await File.WriteAllTextAsync(projectFile2.FullName, "Not a real project file."); 1340await File.WriteAllTextAsync(appHostProject.FullName, "Not a real apphost project."); 1343await File.WriteAllTextAsync(webProject.FullName, "Not a real web project."); 1386await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1404await File.WriteAllTextAsync(onDiskProjectFile.FullName, "Not a real project file."); 1413Assert.True(File.Exists(mismatchedCasePath)); 1433await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1449await File.WriteAllTextAsync(appHostFile.FullName, "// TypeScript AppHost"); 1451await File.WriteAllTextAsync(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName), JsonSerializer.Serialize(new 1487await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real project file."); 1509var settingsJson = await File.ReadAllTextAsync(settingsFile.FullName); 1524await File.WriteAllTextAsync(appHostFile.FullName, "// TypeScript apphost"); 1527await File.WriteAllTextAsync( 1571Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName))); 1573var adjacentConfigJson = await File.ReadAllTextAsync(adjacentConfigPath); 1591await File.WriteAllTextAsync(appHost1File.FullName, "// TypeScript apphost"); 1593await File.WriteAllTextAsync(appHost1ConfigPath, """ 1603await File.WriteAllTextAsync(appHost2File.FullName, "// TypeScript apphost"); 1605await File.WriteAllTextAsync(appHost2ConfigPath, """ 1641Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName))); 1643var appHost1ConfigJson = await File.ReadAllTextAsync(appHost1ConfigPath); 1648var appHost2ConfigJson = await File.ReadAllTextAsync(appHost2ConfigPath); 1661await File.WriteAllTextAsync(appHostFile.FullName, "// TypeScript apphost"); 1695Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName))); 1710await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real apphost"); 1721await File.WriteAllTextAsync(aspireSettingsFile.FullName, JsonSerializer.Serialize(new { appHostPath = relativeAppHostPath })); 1740Assert.True(File.Exists(aspireConfigFilePath), "aspire.config.json should have been created by migration from .aspire/settings.json"); 1742var configJson = await File.ReadAllTextAsync(aspireConfigFilePath); 1754await File.WriteAllTextAsync( 1779await File.WriteAllTextAsync( 1805await File.WriteAllTextAsync( 1815await File.WriteAllTextAsync(csprojFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\"></Project>"); 1820await File.WriteAllTextAsync( 1860await File.WriteAllTextAsync(appHostFile.FullName, @"using Aspire.Hosting 1880await File.WriteAllTextAsync(csprojFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\"></Project>"); 1885await File.WriteAllTextAsync( 1921await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 1948await File.WriteAllTextAsync( 1972await File.WriteAllTextAsync(appHostFile.FullName, @"using Aspire.Hosting; 1993await File.WriteAllTextAsync(appHostFile.FullName, "using Aspire.Hosting;"); 1996await File.WriteAllTextAsync(projectFile.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2019await File.WriteAllTextAsync( 2030await File.WriteAllTextAsync(csprojFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\"></Project>"); 2045await File.WriteAllTextAsync(txtFile.FullName, "Some text file"); 2065await File.WriteAllTextAsync(csprojFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\"></Project>"); 2070await File.WriteAllTextAsync( 2257await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2312await File.WriteAllTextAsync(projectFile.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2329Assert.False(File.Exists(Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName))); 2342await File.WriteAllTextAsync(first.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2345await File.WriteAllTextAsync(second.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2382await File.WriteAllTextAsync(brokenAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2387await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 2424await File.WriteAllTextAsync(healthyAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2429await File.WriteAllTextAsync(brokenAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2432await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 2465await File.WriteAllTextAsync(configuredAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2470await File.WriteAllTextAsync(firstAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2473await File.WriteAllTextAsync(secondAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2476await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 2510await File.WriteAllTextAsync(unsupportedAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2515await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 2564await File.WriteAllTextAsync(brokenAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2568await File.WriteAllTextAsync(firstHealthy.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2572await File.WriteAllTextAsync(secondHealthy.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 2575await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 2614await File.WriteAllTextAsync(projectFile1.FullName, "Not a real project file."); 2616await File.WriteAllTextAsync(projectFile2.FullName, "Not a real project file."); 2651await File.WriteAllTextAsync( 2679await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2718await File.WriteAllTextAsync(csprojFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\"></Project>"); 2723await File.WriteAllTextAsync(appHostCsFile.FullName, """ 2761await File.WriteAllTextAsync(csprojFile.FullName, "<Project Sdk=\"Microsoft.NET.Sdk\"></Project>"); 2765await File.WriteAllTextAsync(appHostCsFile.FullName, """ 2803await File.WriteAllTextAsync(appHostCsFile.FullName, """ 2826await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2847await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2869await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 2922await File.WriteAllTextAsync(normalProject.FullName, "Not a real project file."); 2929await File.WriteAllTextAsync(cachedProject.FullName, "Not a real project file."); 2959await File.WriteAllTextAsync(project1.FullName, "Not a real project file."); 2963await File.WriteAllTextAsync(project2.FullName, "Not a real project file."); 2990await File.WriteAllTextAsync(normalProject.FullName, "Not a real project file."); 2997await File.WriteAllTextAsync(cachedProject.FullName, "Not a real project file."); 3031await File.WriteAllTextAsync(siblingProject.FullName, "Not a real project file."); 3037await File.WriteAllTextAsync(cachedProject.FullName, "Not a real project file."); 3067await File.WriteAllTextAsync(appHostFile.FullName, "Not a real apphost"); 3090await File.WriteAllTextAsync(appHost1File.FullName, "Not a real apphost"); 3096await File.WriteAllTextAsync(appHost2File.FullName, "Not a real apphost"); 3120await File.WriteAllTextAsync(appHostFile.FullName, "Not a real apphost"); 3143await File.WriteAllTextAsync(Path.Combine(appHost1Dir.FullName, "AppHost1.csproj"), "Not a real apphost"); 3146await File.WriteAllTextAsync(Path.Combine(appHost2Dir.FullName, "AppHost2.csproj"), "Not a real apphost"); 3165await File.WriteAllTextAsync(appHost1File.FullName, "Not a real apphost"); 3168await File.WriteAllTextAsync(appHost2File.FullName, "Not a real apphost"); 3171await File.WriteAllTextAsync(slowValidationFile.FullName, "Not a real apphost"); 3224await File.WriteAllTextAsync(appHost1File.FullName, "Not a real apphost"); 3228await File.WriteAllTextAsync(appHost2File.FullName, "Not a real apphost"); 3237await File.WriteAllTextAsync(aspireSettingsFile.FullName, JsonSerializer.Serialize(new { appHostPath = relativeAppHostPath })); 3257await File.WriteAllTextAsync(appHost1File.FullName, "Not a real apphost"); 3261await File.WriteAllTextAsync(appHost2File.FullName, "Not a real apphost"); 3270await File.WriteAllTextAsync(aspireSettingsFile.FullName, JsonSerializer.Serialize(new { appHostPath = relativeAppHostPath })); 3292await File.WriteAllTextAsync(realAppHost.FullName, "Not a real project file."); 3297await File.WriteAllTextAsync(staleAppHost.FullName, "Not a real project file."); 3320await File.WriteAllTextAsync(realAppHost.FullName, "Not a real project file."); 3324await File.WriteAllTextAsync(staleAppHost.FullName, "Not a real project file."); 3349await File.WriteAllTextAsync(realAppHost.FullName, "Not a real project file."); 3353await File.WriteAllTextAsync(skipListedAppHost.FullName, "Not a real project file."); 3378await File.WriteAllTextAsync(buildableAppHost.FullName, "Not a real project file."); 3382await File.WriteAllTextAsync(unbuildableAppHost.FullName, "Not a real project file."); 3417await File.WriteAllTextAsync(realAppHost.FullName, "Not a real project file."); 3422await File.WriteAllTextAsync(staleAppHost.FullName, "Not a real project file."); 3456await File.WriteAllTextAsync(configuredAppHost.FullName, "<Project Sdk=\"Aspire.AppHost.Sdk\"></Project>"); 3460await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new 3492await File.WriteAllTextAsync(trackedAppHost.FullName, "Not a real project file."); 3496await File.WriteAllTextAsync(ignoredAppHost.FullName, "Not a real project file."); 3527await File.WriteAllTextAsync(realAppHost.FullName, "Not a real project file."); 3532await File.WriteAllTextAsync(nodeModulesAppHost.FullName, "Not a real project file."); 3564await File.WriteAllTextAsync(realAppHost.FullName, "Not a real project file."); 3620await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real apphost"); 3687await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real apphost"); 3720await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real apphost"); 3806await File.WriteAllTextAsync(configPath, """ 3834await File.WriteAllTextAsync(aspireSettingsFile.FullName, """ 3861await File.WriteAllTextAsync(configPath, """ 3886await File.WriteAllTextAsync(aspireSettingsFile.FullName, """ 3911await File.WriteAllTextAsync(configPath, """ 3941await File.WriteAllTextAsync(settingsPath, """ 3968await File.WriteAllTextAsync(settingsPath, """ 3995await File.WriteAllTextAsync(settingsPath, """ 4033await File.WriteAllTextAsync(realAppHost.FullName, "Not a real project file."); 4057Assert.True(File.Exists(pathThroughLink), "Symlinked path should resolve to the real apphost file."); 4095await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real project file."); 4098if (!File.Exists(differentlyCasedPath)) 4106await File.WriteAllTextAsync(configPath, $$""" 4130await File.WriteAllTextAsync(configuredAppHost.FullName, "Not a real project file."); 4133await File.WriteAllTextAsync(configPath, JsonSerializer.Serialize(new