using Xunit;
using System;
using System.IO;
using System.Runtime.InteropServices;

namespace ConsoleApp
{
    public class ProgramTests
    {
        private static string CaptureConsoleOut(Action action)
        {
            var original = Console.Out;
            try
            {
                using var sw = new StringWriter();
                Console.SetOut(sw);
                action();
                return sw.ToString();
            }
            finally
            {
                Console.SetOut(original);
            }
        }

        [Theory(DisplayName = "Throws ArgumentException for null, empty, or whitespace filePath")]
        [InlineData(null)]
        [InlineData("")]
        [InlineData("   ")]
        public void RefactoredFileProcess_ThrowsArgumentException_OnInvalidFilePath(string filePath)
        {
            Assert.Throws<ArgumentException>(() => Program.RefactoredFileProcess(filePath));
        }

        [Fact(DisplayName = "Reads and prints file content if file exists and is accessible")]
        public void RefactoredFileProcess_PrintsContent_OnValidFile()
        {
            var testFile = Path.GetTempFileName();
            try
            {
                File.WriteAllText(testFile, "Hello World!");

                string output = CaptureConsoleOut(() => Program.RefactoredFileProcess(testFile));

                Assert.Contains("Hello World!", output);
            }
            finally
            {
                if (File.Exists(testFile)) File.Delete(testFile);
            }
        }

        [Fact(DisplayName = "Handles FileNotFoundException with correct message")]
        public void RefactoredFileProcess_HandlesFileNotFoundException()
        {
            string fakePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".txt");

            string output = CaptureConsoleOut(() => Program.RefactoredFileProcess(fakePath));

            Assert.Contains("The file was not found:", output);
        }

        [Fact(DisplayName = "Handles UnauthorizedAccessException with correct message (deterministic)")]
        public void RefactoredFileProcess_HandlesUnauthorizedAccessException()
        {
            // Deterministic approach: try to read a directory *as if it were a file*
            // On Windows this typically throws UnauthorizedAccessException.
            // On Linux/macOS it may throw UnauthorizedAccessException or IOException.
            // So we assert either "Access denied:" OR (fallback) "An IO error occurred:" depending on OS.
            string dirPath = Path.GetTempPath();

            string output = CaptureConsoleOut(() => Program.RefactoredFileProcess(dirPath));

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                Assert.Contains("Access denied:", output);
            }
            else
            {
                // Non-Windows can vary; accept either message to avoid flaky tests
                Assert.True(
                    output.Contains("Access denied:") || output.Contains("An IO error occurred:"),
                    $"Expected Access denied or IO error message, but got: {output}"
                );
            }
        }

        [Fact(DisplayName = "Handles IOException with correct message (deterministic)")]
        public void RefactoredFileProcess_HandlesIOException()
        {
            // Deterministic approach: use an invalid path that triggers an IO error across platforms.
            // '\0' in a path is invalid and causes an exception during File.ReadAllText.
            // Many runtimes throw ArgumentException for invalid chars; your Program catches IOException only.
            // So we make the test resilient: accept either IO message OR let it throw ArgumentException.
            string invalidPath = "bad\0path.txt";

            // Option A (strict, if you want to enforce program behavior):
            // Assert.Throws<ArgumentException>(() => Program.RefactoredFileProcess(invalidPath));

            // Option B (test current behavior without flakiness):
            try
            {
                string output = CaptureConsoleOut(() => Program.RefactoredFileProcess(invalidPath));
                Assert.Contains("An IO error occurred:", output);
            }
            catch (ArgumentException)
            {
                // Acceptable: invalid path is argument-level error in many environments.
                // If you want consistent behavior, update Program to catch ArgumentException separately.
            }
        }
    }
}

ProgramTests.cs

Master the art of robust C# programming by learning how to handle, create, and debug exceptions. This hands-on course guides you through real-world error handling scenarios, from basic try-catch to custom exceptions and safe file operations.

Learn the basics of exceptions in C#, how to use try-catch blocks, and why error handling is crucial for robust applications.

Learn to create your own exception types and use guard clauses to prevent invalid states in your code.

Master techniques for validating user input and safely parsing data to prevent runtime errors.

Handle file operations safely and learn to debug exceptions using stack traces and refactoring techniques.

Challenge: Refactor Broken Error Handling

Oplossing

Challenge: Refactor Broken Error Handling

Oplossing