using System;

using System.Collections.Generic;

​

​

using Xunit;

​

using System.Linq;

using System.Reflection;

​

class Program

{

    static int Main()

    {

        var testAssembly = Assembly.GetExecutingAssembly();

        return RunTests(testAssembly);

    }

​

    static int RunTests(Assembly testAssembly)

    {

        int failedTests = 0;

​

        Console.WriteLine("Starting xUnit tests...\n");

​

        var testClasses = testAssembly.GetTypes()

            .Where(t => t.GetMethods()

                         .Any(m => m.GetCustomAttributes(typeof(FactAttribute), false).Any()

                                 || m.GetCustomAttributes(typeof(TheoryAttribute), false).Any()));

​

        foreach (var testClass in testClasses)

        {

            Console.WriteLine($"Running tests in: {testClass.Name}");

            object testInstance = Activator.CreateInstance(testClass);

​

            var testMethods = testClass.GetMethods()

                .Where(m => m.GetCustomAttributes(typeof(FactAttribute), false).Any()

                         || m.GetCustomAttributes(typeof(TheoryAttribute), false).Any());

​

            foreach (var method in testMethods)

            {

                try

                {

                    var parameters = method.GetParameters();

                    if (parameters.Length == 0) 

                    {

                        // ✅ Directly invoke `Fact` tests

                        method.Invoke(testInstance, null);

                        Console.WriteLine($" ✅ {method.Name} PASSED");

                    }

                    else

                    {

                        // ✅ Handle `Theory` tests (Generate test cases using attributes)

                        var theoryData = method.GetCustomAttributes<InlineDataAttribute>();

                        foreach (var data in theoryData)

                        {

                            object[] testValues = data.GetData(method).FirstOrDefault();

                            method.Invoke(testInstance, testValues);

                            Console.WriteLine($" ✅ {method.Name}({string.Join(", ", testValues)}) PASSED");

                        }

                    }

                }

                catch (TargetInvocationException ex)

                {

                    failedTests++;

                    Console.WriteLine($" ❌ {method.Name} FAILED: {ex.InnerException?.Message}");

                }

            }

​

            Console.WriteLine();

        }

​

        Console.WriteLine(failedTests > 0 ? "Some tests failed!" : "All tests passed!");

        return failedTests > 0 ? 1 : 0;

    }

}

​

​

​

public class AuthenticationService

{

    private const string ActiveDirectoryDomain = "corp.example.com";

​

    // Simulate AD users for testing purposes

    private static readonly Dictionary<string, string> _testUsers = new Dictionary<string, string>()

    {

        {"user1", "password123"},

        {"test.user", "secure_password"},

        {"guest", "guest"}

    };

​

    public bool AuthenticateUser(string username, string password)

    {

        if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password))

        {

            return false; // Do not reveal the reason

        }

​

        try

        {

            // Simulate AD authentication

            if (_testUsers.ContainsKey(username) && _testUsers[username] == password)

            {

                return true;

            }

            else

            {

                return false; // Do not reveal the reason

            }

        }

        catch (Exception)

        {

            return false; // Do not reveal the reason

        }

    }

}

​

public class AuthenticationServiceTests

{

    private readonly AuthenticationService _authService;

​

    public AuthenticationServiceTests()

    {

        _authService = new AuthenticationService();

    }

​

    [Theory]

    [InlineData("user1", "password123", true)]

    [InlineData("test.user", "secure_password", true)]

    [InlineData("guest", "guest", true)]

    public void AuthenticateUser_ValidCredentials_ReturnsTrue(string username, string password, bool expected)

    {

        Assert.Equal(expected, _authService.AuthenticateUser(username, password));

    }

​

    [Theory]

    [InlineData("user1", "wrongpassword", false)]

    [InlineData("test.user", "incorrect", false)]

    [InlineData("guest", "guest123", false)]

    [InlineData("nonexistent", "anypassword", false)]

    public void AuthenticateUser_InvalidCredentials_ReturnsFalse(string username, string password, bool expected)

    {

        Assert.Equal(expected, _authService.AuthenticateUser(username, password));

    }

​

    [Theory]

    [InlineData("", "password", false)]

    [InlineData("user", "", false)]

    [InlineData(null, "password", false)]

    [InlineData("user", null, false)]

    [InlineData(" ", "password", false)]

    [InlineData("user", " ", false)]

    public void AuthenticateUser_EmptyOrNullCredentials_ReturnsFalse(string username, string password, bool expected)

    {

        Assert.Equal(expected, _authService.AuthenticateUser(username, password));

    }

}