using Xunit;
using System;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;

namespace ConsoleApp
{
    public class ProgramTests
    {
        [Fact(DisplayName = "Main prints correct greetings")]
        public void Main_PrintsCorrectGreetings()
        {
            var originalOut = Console.Out;
            try
            {
                using var sw = new StringWriter();
                Console.SetOut(sw);

                Program.TestMain(Array.Empty<string>());

                var text = sw.ToString();

                // Read lines safely (no split strings that can break in some environments)
                using var sr = new StringReader(text);
                var lines = sr.ReadToEnd()
                              .Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
                              .Select(l => l.Trim())
                              .ToArray();

                // If Environment.NewLine split returns 1 line (some runners normalize newlines),
                // fallback to reading line-by-line:
                if (lines.Length == 1)
                {
                    sr.Dispose();
                    using var sr2 = new StringReader(text);
                    var list = new System.Collections.Generic.List<string>();
                    string? line;
                    while ((line = sr2.ReadLine()) != null)
                    {
                        if (!string.IsNullOrWhiteSpace(line))
                            list.Add(line.Trim());
                    }
                    lines = list.ToArray();
                }

                Assert.Equal(2, lines.Length);
                Assert.Equal("Hello, Alice! Welcome to the program", lines[0]);
                Assert.Equal("Hello, Alice! Welcome to the program", lines[1]);
            }
            finally
            {
                Console.SetOut(originalOut);
            }
        }

        [Fact(DisplayName = "Solution uses concatenation and interpolation in code")]
        public void Main_UsesConcatenationAndInterpolation_InSource()
        {
            var code = ReadProgramSource();

            // Remove comments to reduce false positives
            code = Regex.Replace(code, @"//.*?$", "", RegexOptions.Multiline);
            code = Regex.Replace(code, @"/\*.*?\*/", "", RegexOptions.Singleline);

            // Concatenation: "Hello, " + name + "! Welcome to the program"
            var concatPattern = new Regex(
                @"""Hello,\s*""\s*\+\s*name\s*\+\s*""!\s*Welcome\s*to\s*the\s*program""",
                RegexOptions.Multiline);

            // Interpolation: $"Hello, {name}! Welcome to the program"
            var interpolationPattern = new Regex(
                @"\$\s*""Hello,\s*\{name\}!\s*Welcome\s*to\s*the\s*program""",
                RegexOptions.Multiline);

            Assert.Matches(concatPattern, code);
            Assert.Matches(interpolationPattern, code);
        }

        private static string ReadProgramSource()
        {
            var dir = AppContext.BaseDirectory;

            for (int i = 0; i < 8; i++)
            {
                string[] files;
                try
                {
                    files = Directory.GetFiles(dir, "Program.cs", SearchOption.AllDirectories);
                }
                catch
                {
                    files = Array.Empty<string>();
                }

                if (files.Length > 0)
                    return File.ReadAllText(files[0]);

                var parent = Directory.GetParent(dir);
                if (parent == null) break;
                dir = parent.FullName;
            }

            throw new FileNotFoundException("Program.cs not found for source inspection.");
        }
    }
}


ProgramTests.cs

Master the essentials of string manipulation, text parsing, and efficient text processing in C#. This course guides you from the basics of working with strings to advanced text analysis and formatting, using engaging real-world examples and hands-on challenges.

Explore the basics of strings in C#, including creation, concatenation, and essential properties. Practice manipulating and analyzing text with beginner-friendly challenges.

Advance your skills with string formatting, splitting, trimming, and replacing text. Tackle real-world parsing and formatting tasks.

Apply your string skills to analyze text, check for palindromes, perform frequency analysis, and implement basic ciphers.

Challenge: Greeting Generator

Løsning