SDET, examples of test cases - realestateexplorer/relatedToCh GitHub Wiki

namespace MyMathLib
{
    public class SimpleCalculator
    {
        public int Add(int a, int b)
        {
            // A deliberate bug for our negative test case later!
            // This should throw an exception, but let's imagine
            // a junior dev wrote this check incorrectly.
            if (a == int.MaxValue || b == int.MaxValue)
            {
                // This is not the right way to handle overflow, but it's for demonstration.
                // A better way is a `checked` block.
            }

            return a + b;
        }

        public double Divide(double a, double b)
        {
            if (b == 0)
            {
                throw new ArgumentException("Cannot divide by zero.");
            }
            return a / b;
        }
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using MyMathLib; // Your project with the Calculator class

[TestClass] // This attribute marks the class as a container for tests.
public class CalculatorTests
{
    // Test Case 1: Positive Test Case (Happy Path)
    [TestMethod] // This attribute marks the method as a single test case.
    public void Add_TwoPositiveNumbers_ReturnsCorrectSum()
    {
        // Arrange
        var calculator = new SimpleCalculator();
        int number1 = 5;
        int number2 = 10;
        int expected = 15;

        // Act
        int actual = calculator.Add(number1, number2);

        // Assert
        Assert.AreEqual(expected, actual, "Adding 5 and 10 should result in 15.");
    }

    // Test Case 2: Edge/Boundary Case
    [TestMethod]
    public void Add_ZeroAndPositiveNumber_ReturnsThePositiveNumber()
    {
        // Arrange
        var calculator = new SimpleCalculator();
        int number1 = 0;
        int number2 = 7;
        int expected = 7;

        // Act
        int actual = calculator.Add(number1, number2);

        // Assert
        Assert.AreEqual(expected, actual, "Adding 0 to a number should not change it.");
    }

    // Test Case 3: Negative Test Case (Testing for an expected error)
    [TestMethod]
    public void Divide_ByZero_ThrowsArgumentException()
    {
        // Arrange
        var calculator = new SimpleCalculator();
        double number1 = 10;
        double number2 = 0;

        // Act & Assert
        // We expect this action to throw a specific exception.
        // If it does, the test passes. If it throws a different exception
        // or no exception, the test fails.
        Assert.ThrowsException<System.ArgumentException>(() => calculator.Divide(number1, number2));
    }

    // Test Case 4: Another Negative Test (Testing for overflow)
    // This test will FAIL because our original Add method has a bug!
    // Finding this failure is the entire point of testing.
    [TestMethod]
    public void Add_MaxValueAndOne_ThrowsOverflowException()
    {
        // Arrange
        var calculator = new SimpleCalculator();
        int number1 = int.MaxValue; // The largest possible integer
        int number2 = 1;

        // Act & Assert
        // We expect this to throw an OverflowException. In C#, adding 1 to
        // int.MaxValue inside a 'checked' block would do this.
        // Our current implementation will just wrap around to a negative number (a bug).
        Assert.ThrowsException<System.OverflowException>(() =>
        {
            // To properly test this, we should wrap the call in a checked context
            // if we expect an exception. Or the method itself should have it.
            checked
            {
                calculator.Add(number1, number2);
            }
        });
    }
}

namespace MyMathLib
{
    public class SimpleCalculator
    {
        public int Add(int a, int b)
        {
            // Contains the same deliberate bug to be caught by our tests.
            return a + b;
        }

        public double Divide(double a, double b)
        {
            if (b == 0)
            {
                throw new ArgumentException("Cannot divide by zero.");
            }
            return a / b;
        }
    }
}

using NUnit.Framework; // NUnit's main namespace
using MyMathLib;      // Your project with the Calculator class

[TestFixture] // In NUnit, [TestFixture] marks a class that contains tests.
public class CalculatorTests
{
    // Test Case 1: Positive Test Case (Happy Path)
    [Test] // In NUnit, [Test] marks a method as a single test case.
    public void Add_TwoPositiveNumbers_ReturnsCorrectSum()
    {
        // Arrange
        var calculator = new SimpleCalculator();
        int number1 = 5;
        int number2 = 10;
        int expected = 15;

        // Act
        int actual = calculator.Add(number1, number2);

        // Assert - NUnit uses a "constraint model" which is very readable.
        // It reads like a sentence: "Assert that actual is equal to expected."
        Assert.That(actual, Is.EqualTo(expected));
    }

    // Test Case 2: Negative Test Case (Testing for an expected error)
    [Test]
    public void Divide_ByZero_ThrowsArgumentException()
    {
        // Arrange
        var calculator = new SimpleCalculator();
        double number1 = 10;
        double number2 = 0;

        // Act & Assert
        // NUnit's syntax for asserting an exception is very clean.
        Assert.Throws<System.ArgumentException>(() => calculator.Divide(number1, number2));
    }

    // Test Case 3: A failing test that finds our bug
    [Test]
    public void Add_MaxValueAndOne_ThrowsOverflowException()
    {
        // Arrange
        var calculator = new SimpleCalculator();
        int number1 = int.MaxValue;
        int number2 = 1;

        // Act & Assert
        // This test will FAIL, because our simple `Add` method doesn't
        // handle overflow. It wraps around to a negative number.
        // The test correctly identifies this bug.
        Assert.Throws<System.OverflowException>(() =>
        {
            checked // Use a checked context to force an OverflowException on integer overflow
            {
                calculator.Add(number1, number2);
            }
        });
    }
}

[TestFixture]
public class AdvancedCalculatorTests
{
    // This single method represents FOUR different test cases.
    // NUnit will run this method four times, once for each [TestCase] attribute.
    [TestCase(5, 10, 15, TestName = "Add_TwoPositiveNumbers_ReturnsSum")]
    [TestCase(-2, -8, -10, TestName = "Add_TwoNegativeNumbers_ReturnsSum")]
    [TestCase(-5, 10, 5, TestName = "Add_PositiveAndNegative_ReturnsSum")]
    [TestCase(100, 0, 100, TestName = "Add_NumberAndZero_ReturnsNumber")]
    public void Add_WithVariousInputs_ReturnsCorrectSum(int a, int b, int expectedResult)
    {
        // Arrange
        var calculator = new SimpleCalculator();

        // Act
        int actualResult = calculator.Add(a, b);

        // Assert
        Assert.That(actualResult, Is.EqualTo(expectedResult));
    }
}

// In your main application project (e.g., MyWebApp.Core)
public enum CustomerType
{
    Standard,
    Premium,
    Vip
}

public class CustomerDiscountCalculator
{
    public decimal CalculateDiscount(decimal orderTotal, CustomerType type)
    {
        if (orderTotal <= 0)
        {
            throw new ArgumentException("Order total must be positive.", nameof(orderTotal));
        }

        decimal discount = 0;
        switch (type)
        {
            case CustomerType.Standard:
                discount = orderTotal > 100 ? 0.05m : 0; // 5% if over $100
                break;
            case CustomerType.Premium:
                discount = 0.10m; // Flat 10%
                break;
            case CustomerType.Vip:
                discount = 0.20m; // Flat 20%
                break;
        }
        return orderTotal * discount;
    }
}

using NUnit.Framework;
using System;

// Assume the SUT classes are referenced from the main project
// using MyWebApp.Core;

[TestFixture]
public class CustomerDiscountCalculatorTests
{
    private CustomerDiscountCalculator _calculator;

    [SetUp]
    public void Setup()
    {
        // ARRANGE: This runs before each test.
        _calculator = new CustomerDiscountCalculator();
    }

    // Test Case 1: A simple "happy path" test
    [Test]
    public void CalculateDiscount_PremiumCustomer_ReturnsCorrectDiscount()
    {
        // ARRANGE
        var orderTotal = 200m;
        var customerType = CustomerType.Premium;

        // ACT
        var discount = _calculator.CalculateDiscount(orderTotal, customerType);

        // ASSERT
        Assert.That(discount, Is.EqualTo(20.0m)); // 10% of 200 is 20
    }

    // Test Case 2: Using [TestCase] for data-driven testing (a key SDET skill)
    [TestCase(50.0, CustomerType.Standard, 0.0)] // Below threshold
    [TestCase(100.0, CustomerType.Standard, 0.0)] // At threshold
    [TestCase(100.01, CustomerType.Standard, 5.0005)] // Just above threshold
    [TestCase(200.0, CustomerType.Vip, 40.0)]
    public void CalculateDiscount_VariousScenarios_ReturnsExpectedDiscount(
        decimal orderTotal, CustomerType type, decimal expectedDiscount)
    {
        // ACT
        var discount = _calculator.CalculateDiscount(orderTotal, type);

        // ASSERT
        // Using a tolerance for decimal comparisons is a good practice
        Assert.That(discount, Is.EqualTo(expectedDiscount).Within(0.001));
    }

    // Test Case 3: Testing for expected exceptions (edge case)
    [Test]
    public void CalculateDiscount_NegativeOrderTotal_ThrowsArgumentException()
    {
        // ARRANGE
        var orderTotal = -50m;
        var customerType = CustomerType.Standard;

        // ACT & ASSERT
        // Verify that a specific exception is thrown
        var ex = Assert.Throws<ArgumentException>(() =>
            _calculator.CalculateDiscount(orderTotal, customerType));

        // Optionally, assert on the exception message for more specific tests
        Assert.That(ex.Message, Does.Contain("Order total must be positive."));
    }
}

// In your ASP.NET Core Web API project

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private static readonly Dictionary<int, User> _users = new()
    {
        [1] = new User { Id = 1, Name = "Alice", Email = "[email protected]" },
        [2] = new User { Id = 2, Name = "Bob", Email = "[email protected]" }
    };

    [HttpGet("{id}")]
    public IActionResult GetUser(int id)
    {
        if (_users.TryGetValue(id, out var user))
        {
            return Ok(user);
        }
        return NotFound();
    }
}

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

using NUnit.Framework;
using System.Net;
using System.Net.Http.Json; // Requires System.Net.Http.Json NuGet package
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Testing;

// using MyWebApp; // Reference to the API project

[TestFixture]
public class UsersControllerTests
{
    private WebApplicationFactory<Program> _factory; // Or WebApplicationFactory<Startup> for older .NET
    private HttpClient _client;

    [OneTimeSetUp]
    public void OneTimeSetup()
    {
        // ARRANGE: Create an in-memory test server once for all tests in this class
        _factory = new WebApplicationFactory<Program>();
    }

    [SetUp]
    public void Setup()
    {
        _client = _factory.CreateClient();
    }

    // Test Case 1: Successful GET request (Happy Path)
    [Test]
    public async Task GetUser_WithExistingId_ReturnsOkAndCorrectUser()
    {
        // ACT
        // Call the API endpoint
        var response = await _client.GetAsync("/api/users/1");

        // ASSERT - Status Code
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));

        // ASSERT - Response Body
        var user = await response.Content.ReadFromJsonAsync<User>();
        Assert.IsNotNull(user);
        Assert.That(user.Id, Is.EqualTo(1));
        Assert.That(user.Name, Is.EqualTo("Alice"));
    }

    // Test Case 2: Not Found GET request (Sad Path)
    [Test]
    public async Task GetUser_WithNonExistentId_ReturnsNotFound()
    {
        // ACT
        var response = await _client.GetAsync("/api/users/99");

        // ASSERT
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [TearDown]
    public void Teardown()
    {
        _client.Dispose();
    }

    [OneTimeTearDown]
    public void OneTimeTeardown()
    {
        _factory.Dispose();
    }
}

// In a folder like "PageObjects"

using OpenQA.Selenium;
using OpenQA.Selenium.Support.UI;

// Represents the Wikipedia Home Page
public class WikipediaHomePage
{
    private readonly IWebDriver _driver;
    private readonly WebDriverWait _wait;

    // Locators for elements on the page
    private By SearchInput => By.Id("searchInput");
    private By SearchButton => By.CssSelector("button[type='submit']");

    public WikipediaHomePage(IWebDriver driver)
    {
        _driver = driver;
        _wait = new WebDriverWait(_driver, TimeSpan.FromSeconds(10));
    }

    public void GoToPage()
    {
        _driver.Navigate().GoToUrl("https://www.wikipedia.org/");
    }

    public void Search(string searchText)
    {
        // Wait for the element to be visible before interacting
        _wait.Until(d => d.FindElement(SearchInput)).SendKeys(searchText);
        _driver.FindElement(SearchButton).Click();
    }
}

// Represents the Wikipedia Article Page (the result page)
public class WikipediaArticlePage
{
    private readonly IWebDriver _driver;

    private By FirstHeading => By.Id("firstHeading");

    public WikipediaArticlePage(IWebDriver driver)
    {
        _driver = driver;
    }

    public string GetArticleTitle()
    {
        // Wait for the page to load and the heading to be present
        new WebDriverWait(_driver, TimeSpan.FromSeconds(10))
            .Until(d => d.FindElement(FirstHeading));

        return _driver.FindElement(FirstHeading).Text;
    }
}

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

[TestFixture]
public class WikipediaSearchTests
{
    private IWebDriver _driver;
    private WikipediaHomePage _homePage;
    private WikipediaArticlePage _articlePage;

    [SetUp]
    public void Setup()
    {
        // ARRANGE: Initialize the WebDriver and Page Objects
        _driver = new ChromeDriver();
        _driver.Manage().Window.Maximize();
        _homePage = new WikipediaHomePage(_driver);
        _articlePage = new WikipediaArticlePage(_driver);
    }

    [Test]
    public void SearchForQuery_LoadsCorrectArticlePage()
    {
        // ARRANGE
        string searchQuery = "Software testing";
        _homePage.GoToPage();

        // ACT
        _homePage.Search(searchQuery);

        // ASSERT
        // The test asserts on the behavior, not the implementation details
        string articleTitle = _articlePage.GetArticleTitle();
        Assert.That(articleTitle, Is.EqualTo(searchQuery));
    }

    [TearDown]
    public void Teardown()
    {
        // Clean up the browser instance after each test
        _driver?.Quit();
        _driver?.Dispose();
    }
}

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Support.UI;
using WebDriverManager.DriverConfigs.Impl; // Add this for WebDriverManager

namespace SeleniumNunitProject
{
    [TestFixture] // Marks this class as a test suite
    public class GoogleSearchTests
    {
        private IWebDriver _driver;

        [SetUp] // Runs before each test method
        public void Setup()
        {
            // WebDriverManager automatically downloads and sets up the correct chromedriver
            new WebDriverManager.DriverManager().SetUpDriver(new ChromeConfig());
            
            // Initialize the Chrome driver
            _driver = new ChromeDriver();
            _driver.Manage().Window.Maximize();
        }

        [Test] // Marks this method as a test
        public void SearchForSeleniumHq_ShouldReturnResults()
        {
            // 1. Navigate to Google
            _driver.Navigate().GoToUrl("https://www.google.com");

            // 2. Find the search input element by its name attribute
            IWebElement searchBox = _driver.FindElement(By.Name("q"));

            // 3. Type "SeleniumHQ" into the search box and submit
            searchBox.SendKeys("SeleniumHQ");
            searchBox.Submit();

            // 4. Wait for the search results page to load and the title to contain "SeleniumHQ"
            // This is a good practice to avoid race conditions.
            WebDriverWait wait = new WebDriverWait(_driver, TimeSpan.FromSeconds(10));
            wait.Until(d => d.Title.Contains("SeleniumHQ"));

            // 5. Assert that the page title is correct
            Assert.That(_driver.Title, Does.Contain("SeleniumHQ"), "The page title did not contain the expected text.");
            
            // You can also add other assertions, for example:
            IWebElement firstResult = _driver.FindElement(By.CssSelector("h3"));
            Assert.That(firstResult.Text, Does.Contain("Selenium"), "The first result did not contain 'Selenium'.");
        }

        [TearDown] // Runs after each test method
        public void Teardown()
        {
            // Close the browser and dispose of the driver object
            _driver.Quit();
        }
    }
}

using OpenQA.Selenium;
using OpenQA.Selenium.Support.UI;

namespace SeleniumNunitProject.PageObjects
{
    public class GoogleHomePage
    {
        private readonly IWebDriver _driver;
        private readonly WebDriverWait _wait;

        // Constructor
        public GoogleHomePage(IWebDriver driver)
        {
            _driver = driver;
            // Set up an explicit wait that can be reused
            _wait = new WebDriverWait(_driver, TimeSpan.FromSeconds(10));
        }

        // Page Elements (Locators)
        private IWebElement SearchInput => _driver.FindElement(By.Name("q"));

        // Page Actions (Methods)
        public void Navigate()
        {
            _driver.Navigate().GoToUrl("https://www.google.com");
        }

        public void Search(string searchText)
        {
            SearchInput.SendKeys(searchText);
            SearchInput.Submit();
        }

        public void WaitForResultsPageToLoad(string searchText)
        {
            _wait.Until(d => d.Title.Contains(searchText));
        }
    }
}

using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using SeleniumNunitProject.PageObjects; // Add this using statement
using WebDriverManager.DriverConfigs.Impl;

namespace SeleniumNunitProject
{
    [TestFixture]
    public class GoogleSearchTests
    {
        private IWebDriver _driver;
        private GoogleHomePage _googleHomePage; // Add a variable for the page object

        [SetUp]
        public void Setup()
        {
            new WebDriverManager.DriverManager().SetUpDriver(new ChromeConfig());
            _driver = new ChromeDriver();
            _driver.Manage().Window.Maximize();
            
            // Initialize the page object
            _googleHomePage = new GoogleHomePage(_driver);
        }

        [Test]
        public void SearchForSeleniumHq_ShouldReturnResults_WithPOM()
        {
            string searchTerm = "SeleniumHQ";

            // The test is now a clean, readable set of actions
            _googleHomePage.Navigate();
            _googleHomePage.Search(searchTerm);
            _googleHomePage.WaitForResultsPageToLoad(searchTerm);

            // The assertion remains in the test
            Assert.That(_driver.Title, Does.Contain(searchTerm), "The page title did not contain the expected text.");
        }

        [TearDown]
        public void Teardown()
        {
            _driver.Quit();
        }
    }
}

// In MySimpleApi/Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

// --- Our API Endpoints ---

// In-memory data store
var products = new List<Product>
{
    new Product { Id = 1, Name = "Laptop", Price = 1200 },
    new Product { Id = 2, Name = "Keyboard", Price = 80 }
};

// GET /products/{id}
app.MapGet("/products/{id}", (int id) =>
{
    var product = products.FirstOrDefault(p => p.Id == id);
    return product is not null ? Results.Ok(product) : Results.NotFound();
});

// POST /products
app.MapPost("/products", (Product product) =>
{
    // Simple validation
    if (string.IsNullOrEmpty(product.Name))
    {
        return Results.BadRequest("Product name is required.");
    }
    product.Id = products.Max(p => p.Id) + 1; // Simulate generating a new ID
    products.Add(product);
    return Results.Created($"/products/{product.Id}", product);
});

app.Run();

// A simple record to represent our data model
public record Product
{
    public int Id { get; set; }
    public string? Name { get; set; }
    public decimal Price { get; set; }
}

// In MySimpleApi.Tests/ProductApiTests.cs
using System.Net;
using System.Net.Http.Json;
using Microsoft.AspNetCore.Mvc.Testing;
using NUnit.Framework;

namespace MySimpleApi.Tests;

[TestFixture]
public class ProductApiTests
{
    private HttpClient _client;
    private WebApplicationFactory<Program> _factory;

    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
        // This creates an in-memory version of our API for testing
        _factory = new WebApplicationFactory<Program>();
    }

    [SetUp]
    public void Setup()
    {
        // A new client is created for each test
        _client = _factory.CreateClient();
    }

    [Test]
    public async Task GetProduct_WhenIdExists_ReturnsOkAndProduct()
    {
        // Arrange
        var knownId = 1;

        // Act
        var response = await _client.GetAsync($"/products/{knownId}");
        
        // Assert
        // 1. Check for a success status code
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));

        // 2. Deserialize the response content to a Product object
        var product = await response.Content.ReadFromJsonAsync<Product>();

        // 3. Assert that the product is not null and has the correct data
        Assert.That(product, Is.Not.Null);
        Assert.That(product.Id, Is.EqualTo(knownId));
        Assert.That(product.Name, Is.EqualTo("Laptop"));
    }

    [OneTimeTearDown]
    public void OneTimeTearDown()
    {
        _client.Dispose();
        _factory.Dispose();
    }
}

// We need to define the Product record here too so we can deserialize into it.
// To avoid duplication, you could move the record from Program.cs to a separate
// file in the API project and make it public.
public record Product
{
    public int Id { get; set; }
    public string? Name { get; set; }
    public decimal Price { get; set; }
}

[Test]
public async Task GetProduct_WhenIdDoesNotExist_ReturnsNotFound()
{
    // Arrange
    var unknownId = 999;

    // Act
    var response = await _client.GetAsync($"/products/{unknownId}");

    // Assert
    Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
}

[Test]
public async Task PostProduct_WithValidData_ReturnsCreated()
{
    // Arrange
    var newProduct = new Product { Name = "Mouse", Price = 25 };
    
    // Act
    var response = await _client.PostAsJsonAsync("/products", newProduct);

    // Assert
    // 1. Check for a '201 Created' status code
    Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));

    // 2. Deserialize the returned product
    var createdProduct = await response.Content.ReadFromJsonAsync<Product>();

    // 3. Check the returned product has the correct data and a new ID
    Assert.That(createdProduct, Is.Not.Null);
    Assert.That(createdProduct.Name, Is.EqualTo(newProduct.Name));
    Assert.That(createdProduct.Id, Is.GreaterThan(0)); // Should have a server-generated ID

    // 4. Check the 'Location' header
    Assert.That(response.Headers.Location, Is.Not.Null);
    Assert.That(response.Headers.Location.OriginalString, Is.EqualTo($"/products/{createdProduct.Id}"));
}

using System;
using System.Collections.Generic;

public class StringUtils
{
    /// <summary>
    /// Determines if a string has all unique characters using a HashSet.
    /// This is a highly recommended and robust approach.
    /// </summary>
    /// <param name="str">The input string.</param>
    /// <returns>True if all characters are unique, false otherwise.</returns>
    /// <remarks>
    /// Time Complexity: O(n), where n is the length of the string.
    /// We iterate through the string once.
    /// Space Complexity: O(k), where k is the number of unique characters.
    /// In the worst case (all unique), this is O(n).
    /// </remarks>
    public static bool HasAllUniqueChars_HashSet(string str)
    {
        // 1. Handle null, empty, or single-character strings
        if (string.IsNullOrEmpty(str) || str.Length == 1)
        {
            return true;
        }

        // 2. Use a HashSet to store characters we've seen
        var seenCharacters = new HashSet<char>();

        // 3. Iterate through the string
        foreach (char c in str)
        {
            // The Add method returns false if the item already exists.
            if (!seenCharacters.Add(c))
            {
                // We found a duplicate character
                return false;
            }
        }

        // 4. If the loop completes, all characters were unique
        return true;
    }
}

using System;
using System.Linq;

public class StringUtils
{
    /// <summary>
    /// Determines if a string has all unique characters using LINQ.
    /// This is the most concise approach.
    /// </summary>
    /// <param name="str">The input string.</param>
    /// <returns>True if all characters are unique, false otherwise.</returns>
    /// <remarks>
    /// Time Complexity: O(n). Under the hood, Distinct() often uses a HashSet.
    /// Space Complexity: O(k), where k is the number of unique characters.
    /// </remarks>
    public static bool HasAllUniqueChars_Linq(string str)
    {
        if (string.IsNullOrEmpty(str))
        {
            return true;
        }

        return str.Distinct().Count() == str.Length;
    }
}

using System;

public class StringUtils
{
    /// <summary>
    /// Determines if a string has all unique characters using a boolean array.
    /// NOTE: This method assumes the string contains only 7-bit ASCII characters (0-127).
    /// </summary>
    /// <param name="str">The input string (ASCII only).</param>
    /// <returns>True if all characters are unique, false otherwise.</returns>
    /// <remarks>
    /// Time Complexity: O(n), but typically faster than HashSet due to no hashing overhead.
    /// Space Complexity: O(1), because the array size is fixed (128) and does not
    /// depend on the input string's length.
    /// </remarks>
    public static bool HasAllUniqueChars_AsciiArray(string str)
    {
        if (string.IsNullOrEmpty(str))
        {
            return true;
        }

        // Pigeonhole principle: If the string is longer than the number of
        // possible unique characters, it must have a duplicate.
        if (str.Length > 128)
        {
            return false;
        }

        // This array acts as a map for each ASCII character.
        bool[] seen = new bool[128]; // Defaults to all false

        foreach (char c in str)
        {
            // The character's integer value is the index.
            if (seen[c])
            {
                // If we've seen this character before, return false.
                return false;
            }
            
            // Mark this character as seen.
            seen[c] = true;
        }

        return true;
    }
}

using System;

public class ArrayMerger
{
    /// <summary>
    /// Merges two sorted arrays into a single sorted array using the efficient two-pointer method.
    /// </summary>
    /// <param name="arr1">The first sorted array.</param>
    /// <param name="arr2">The second sorted array.</param>
    /// <returns>A new array containing all elements from both input arrays in sorted order.</returns>
    /// <remarks>
    /// Time Complexity: O(m + n), where m and n are the lengths of the two arrays.
    /// We iterate through each element exactly once.
    /// Space Complexity: O(m + n), as we need to create a new array to store the result.
    /// </remarks>
    public static int[] MergeSortedArrays(int[] arr1, int[] arr2)
    {
        // Handle edge cases where one or both arrays are null or empty
        if (arr1 == null || arr1.Length == 0)
        {
            return arr2 ?? new int[0];
        }
        if (arr2 == null || arr2.Length == 0)
        {
            return arr1 ?? new int[0];
        }

        int n1 = arr1.Length;
        int n2 = arr2.Length;
        int[] merged = new int[n1 + n2];

        // Pointers for arr1, arr2, and the merged array
        int i = 0, j = 0, k = 0;

        // --- Main Merge Loop ---
        // Traverse both arrays and insert the smaller element into the merged array
        while (i < n1 && j < n2)
        {
            if (arr1[i] <= arr2[j])
            {
                merged[k++] = arr1[i++];
            }
            else
            {
                merged[k++] = arr2[j++];
            }
        }

        // --- Copy Remaining Elements ---
        // If there are remaining elements in arr1, they must be larger than all
        // elements copied so far.
        while (i < n1)
        {
            merged[k++] = arr1[i++];
        }

        // If there are remaining elements in arr2, they must be larger than all
        // elements copied so far.
        while (j < n2)
        {
            merged[k++] = arr2[j++];
        }

        return merged;
    }
}

using System;
using System.Collections.Generic;

public class ArrayMerger
{
    public static T[] MergeSortedArrays<T>(T[] arr1, T[] arr2) where T : IComparable<T>
    {
        if (arr1 == null || arr1.Length == 0) return arr2 ?? new T[0];
        if (arr2 == null || arr2.Length == 0) return arr1 ?? new T[0];

        int n1 = arr1.Length;
        int n2 = arr2.Length;
        T[] merged = new T[n1 + n2];

        int i = 0, j = 0, k = 0;

        while (i < n1 && j < n2)
        {
            // Use CompareTo for generic types
            if (arr1[i].CompareTo(arr2[j]) <= 0)
            {
                merged[k++] = arr1[i++];
            }
            else
            {
                merged[k++] = arr2[j++];
            }
        }

        while (i < n1)
        {
            merged[k++] = arr1[i++];
        }

        while (j < n2)
        {
            merged[k++] = arr2[j++];
        }

        return merged;
    }
}

using System;
using System.Linq;

public class ArrayMerger
{
    /// <summary>
    /// Merges two sorted arrays using LINQ. This is concise but less performant
    /// than the two-pointer algorithm.
    /// </summary>
    /// <remarks>
    /// Time Complexity: O(N log N) where N is (m + n). The OrderBy method
    /// must perform a full sort operation.
    /// Space Complexity: O(m + n) to store the new array.
    /// </remarks>
    public static int[] MergeSortedArrays_Linq(int[] arr1, int[] arr2)
    {
        // Handle nulls to avoid exceptions with Concat
        arr1 = arr1 ?? new int[0];
        arr2 = arr2 ?? new int[0];

        return arr1.Concat(arr2).OrderBy(x => x).ToArray();
    }
}

using System;
using System.Collections.Generic;

public class StringFinder
{
    /// <summary>
    /// Finds the first non-repeated character in a string using a two-pass dictionary approach.
    /// This is a robust and highly recommended method.
    /// </summary>
    /// <param name="str">The input string.</param>
    /// <returns>The first non-repeated character, or null if none exists.</returns>
    /// <remarks>
    /// Time Complexity: O(n), where n is the length of the string. We iterate the string twice.
    /// Space Complexity: O(k), where k is the number of unique characters in the string.
    /// In the worst case (all unique), this is O(n).
    /// </remarks>
    public static char? FindFirstNonRepeatedChar(string str)
    {
        // 1. Handle edge cases
        if (string.IsNullOrEmpty(str))
        {
            return null;
        }

        // 2. First Pass: Build the frequency map
        var characterCounts = new Dictionary<char, int>();
        foreach (char c in str)
        {
            if (characterCounts.ContainsKey(c))
            {
                characterCounts[c]++;
            }
            else
            {
                characterCounts[c] = 1;
            }
        }

        // 3. Second Pass: Find the first character with a count of 1
        foreach (char c in str)
        {
            if (characterCounts[c] == 1)
            {
                return c;
            }
        }

        // 4. If no character has a count of 1, return null
        return null;
    }
}

using System;
using System.Linq;

public class StringFinder
{
    /// <summary>
    /// Finds the first non-repeated character using a concise LINQ query.
    /// </summary>
    /// <param name="str">The input string.</param>
    /// <returns>The first non-repeated character, or null if none exists.</returns>
    /// <remarks>
    /// Time Complexity: O(n). GroupBy must iterate through the entire string.
    /// Space Complexity: O(k), where k is the number of unique characters.
    /// </remarks>
    public static char? FindFirstNonRepeatedChar_Linq(string str)
    {
        if (string.IsNullOrEmpty(str))
        {
            return null;
        }

        return str.GroupBy(c => c)
                  .FirstOrDefault(group => group.Count() == 1)?
                  .Key;
    }
}

using System;

public class StringFinder
{
    /// <summary>
    /// Finds the first non-repeated character, optimized for ASCII strings.
    /// NOTE: This method assumes the string contains only 8-bit ASCII characters.
    /// </summary>
    /// <param name="str">The input ASCII string.</param>
    /// <returns>The first non-repeated character, or the null character '\0' if none exists.</returns>
    /// <remarks>
    /// Time Complexity: O(n). Extremely fast due to direct array access.
    /// Space Complexity: O(1). The array size is fixed (256) and does not depend on input string length.
    /// </remarks>
    public static char FindFirstNonRepeatedChar_Ascii(string str)
    {
        if (string.IsNullOrEmpty(str))
        {
            return '\0'; // Using null character to indicate 'not found'
        }

        // Assuming Extended ASCII (256 characters)
        int[] counts = new int[256];

        // 1. First Pass: Populate counts
        foreach (char c in str)
        {
            counts[c]++;
        }

        // 2. Second Pass: Find the first with count == 1
        foreach (char c in str)
        {
            if (counts[c] == 1)
            {
                return c;
            }
        }

        return '\0';
    }
}

using System;
using System.Collections.Generic;

/// <summary>
/// Represents a generic Binary Search Tree.
/// </summary>
/// <typeparam name="T">The type of value in the tree, must implement IComparable.</typeparam>
public class BinarySearchTree<T> where T : IComparable<T>
{
    private class Node
    {
        public T Value { get; set; }
        public Node? Left { get; set; }
        public Node? Right { get; set; }

        public Node(T value)
        {
            Value = value;
        }
    }

    private Node? _root;
    public int Count { get; private set; }

    /// <summary>
    /// Inserts a new value into the BST. Duplicates are ignored.
    /// </summary>
    public void Insert(T value)
    {
        if (_root == null)
        {
            _root = new Node(value);
            Count++;
            return;
        }

        Node current = _root;
        while (true)
        {
            int comparison = value.CompareTo(current.Value);
            if (comparison < 0) // Go left
            {
                if (current.Left == null)
                {
                    current.Left = new Node(value);
                    Count++;
                    return;
                }
                current = current.Left;
            }
            else if (comparison > 0) // Go right
            {
                if (current.Right == null)
                {
                    current.Right = new Node(value);
                    Count++;
                    return;
                }
                current = current.Right;
            }
            else // Duplicate value, do nothing
            {
                return;
            }
        }
    }

    /// <summary>
    /// Checks if a value exists in the tree.
    /// </summary>
    public bool Contains(T value)
    {
        Node? current = _root;
        while (current != null)
        {
            int comparison = value.CompareTo(current.Value);
            if (comparison < 0)
            {
                current = current.Left;
            }
            else if (comparison > 0)
            {
                current = current.Right;
            }
            else // Found it
            {
                return true;
            }
        }
        return false; // Not found
    }

    /// <summary>
    /// Removes a value from the tree.
    /// </summary>
    /// <returns>True if the value was found and removed, false otherwise.</returns>
    public bool Remove(T value)
    {
        int initialCount = Count;
        _root = Remove(_root, value);
        return Count < initialCount;
    }

    private Node? Remove(Node? node, T value)
    {
        if (node == null) return null;

        int comparison = value.CompareTo(node.Value);
        if (comparison < 0)
        {
            node.Left = Remove(node.Left, value);
        }
        else if (comparison > 0)
        {
            node.Right = Remove(node.Right, value);
        }
        else // Found the node to remove
        {
            Count--;

            // Case 1: Node has no children (leaf)
            if (node.Left == null && node.Right == null)
            {
                return null;
            }
            // Case 2: Node has one child
            if (node.Left == null) return node.Right;
            if (node.Right == null) return node.Left;

            // Case 3: Node has two children
            // Find the inorder successor (smallest value in the right subtree)
            T smallestValue = FindSmallestValue(node.Right);
            // Replace the node's value with the successor's value
            node.Value = smallestValue;
            // Recursively remove the successor node from the right subtree
            node.Right = Remove(node.Right, smallestValue);
            
            // We already decremented count, but the recursive call will do it again.
            // So, we restore it here to avoid a double-decrement.
            Count++;
        }
        return node;
    }

    private T FindSmallestValue(Node node)
    {
        return node.Left == null ? node.Value : FindSmallestValue(node.Left);
    }

    /// <summary>
    /// Returns the elements of the tree in sorted order.
    /// </summary>
    public IEnumerable<T> GetInOrderTraversal()
    {
        var result = new List<T>();
        InOrderTraversal(_root, result);
        return result;
    }

    private void InOrderTraversal(Node? node, List<T> result)
    {
        if (node == null) return;
        InOrderTraversal(node.Left, result);
        result.Add(node.Value);
        InOrderTraversal(node.Right, result);
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Collections.Generic;

[TestClass]
public class BinarySearchTreeTests
{
    // Helper method to create a standard tree for testing
    // Tree structure:
    //        10
    //       /  \
    //      5    15
    //     / \   / \
    //    3   7 12  18
    private BinarySearchTree<int> CreateSampleTree()
    {
        var bst = new BinarySearchTree<int>();
        bst.Insert(10);
        bst.Insert(5);
        bst.Insert(15);
        bst.Insert(3);
        bst.Insert(7);
        bst.Insert(12);
        bst.Insert(18);
        return bst;
    }

    [TestMethod]
    public void Insert_EmptyTree_AddsRootAndIncrementsCount()
    {
        // Arrange
        var bst = new BinarySearchTree<int>();
        
        // Act
        bst.Insert(10);

        // Assert
        Assert.AreEqual(1, bst.Count);
        Assert.IsTrue(bst.Contains(10));
    }

    [TestMethod]
    public void Insert_DuplicateValue_IsIgnoredAndCountIsUnchanged()
    {
        // Arrange
        var bst = CreateSampleTree();
        int initialCount = bst.Count;

        // Act
        bst.Insert(7); // 7 already exists

        // Assert
        Assert.AreEqual(initialCount, bst.Count);
    }


    [TestMethod]
    public void Contains_ExistingValue_ReturnsTrue()
    {
        // Arrange
        var bst = CreateSampleTree();
        
        // Assert
        Assert.IsTrue(bst.Contains(10)); // Root
        Assert.IsTrue(bst.Contains(3));  // Left leaf
        Assert.IsTrue(bst.Contains(18)); // Right leaf
        Assert.IsTrue(bst.Contains(7));  // Internal node
    }

    [TestMethod]
    public void Contains_NonExistingValue_ReturnsFalse()
    {
        // Arrange
        var bst = CreateSampleTree();
        
        // Assert
        Assert.IsFalse(bst.Contains(99));
        Assert.IsFalse(bst.Contains(1));
    }

    [TestMethod]
    public void GetInOrderTraversal_OnSampleTree_ReturnsSortedList()
    {
        // Arrange
        var bst = CreateSampleTree();
        var expected = new List<int> { 3, 5, 7, 10, 12, 15, 18 };

        // Act
        var actual = bst.GetInOrderTraversal().ToList();

        // Assert
        CollectionAssert.AreEqual(expected, actual);
    }
    
    [TestMethod]
    public void Remove_LeafNode_CorrectlyRemoves()
    {
        // Arrange
        var bst = CreateSampleTree();
        var expected = new List<int> { 5, 7, 10, 12, 15, 18 };
        
        // Act
        bool removed = bst.Remove(3);

        // Assert
        Assert.IsTrue(removed);
        Assert.IsFalse(bst.Contains(3));
        Assert.AreEqual(6, bst.Count);
        CollectionAssert.AreEqual(expected, bst.GetInOrderTraversal().ToList());
    }

    [TestMethod]
    public void Remove_NodeWithOneChild_CorrectlyRemoves()
    {
        // Arrange
        var bst = CreateSampleTree();
        bst.Remove(3); // Remove 3 to make 5 have only one child (7)
        var expected = new List<int> { 7, 10, 12, 15, 18 };
        
        // Act
        bool removed = bst.Remove(5);
        
        // Assert
        Assert.IsTrue(removed);
        Assert.IsFalse(bst.Contains(5));
        Assert.AreEqual(5, bst.Count);
        CollectionAssert.AreEqual(expected, bst.GetInOrderTraversal().ToList());
    }
    
    [TestMethod]
    public void Remove_NodeWithTwoChildren_CorrectlyRemoves()
    {
        // Arrange
        var bst = CreateSampleTree();
        // After removing 5, its inorder successor (7) should replace it.
        var expected = new List<int> { 3, 7, 10, 12, 15, 18 };

        // Act
        bool removed = bst.Remove(5);

        // Assert
        Assert.IsTrue(removed);
        Assert.IsFalse(bst.Contains(5));
        Assert.AreEqual(6, bst.Count);
        CollectionAssert.AreEqual(expected, bst.GetInOrderTraversal().ToList());
    }

    [TestMethod]
    public void Remove_RootNode_CorrectlyRemoves()
    {
        // Arrange
        var bst = CreateSampleTree();
        // After removing 10, its inorder successor (12) should become the new root.
        var expected = new List<int> { 3, 5, 7, 12, 15, 18 };
        
        // Act
        bool removed = bst.Remove(10);

        // Assert
        Assert.IsTrue(removed);
        Assert.IsFalse(bst.Contains(10));
        Assert.AreEqual(6, bst.Count);
        CollectionAssert.AreEqual(expected, bst.GetInOrderTraversal().ToList());
    }

    [TestMethod]
    public void Remove_NonExistingValue_ReturnsFalseAndTreeIsUnchanged()
    {
        // Arrange
        var bst = CreateSampleTree();
        int initialCount = bst.Count;
        var expected = bst.GetInOrderTraversal().ToList();

        // Act
        bool removed = bst.Remove(99);

        // Assert
        Assert.IsFalse(removed);
        Assert.AreEqual(initialCount, bst.Count);
        CollectionAssert.AreEqual(expected, bst.GetInOrderTraversal().ToList());
    }
}

using System;
using System.Collections.Generic;

public class RegexParser
{
    // Memoization table to store results of subproblems
    // Key: A tuple of (textIndex, patternIndex)
    // Value: The boolean result of whether the sub-pattern matches the sub-text
    private Dictionary<(int, int), bool>? _memo;

    /// <summary>
    /// Determines if a text string matches a given simple regex pattern.
    /// The pattern supports '.' (matches any single character) and
    /// '*' (matches zero or more of the preceding element).
    /// </summary>
    /// <param name="text">The input string to match.</param>
    /// <param name="pattern">The regex pattern.</param>
    /// <returns>True if the entire text matches the pattern, false otherwise.</returns>
    public bool IsMatch(string text, string pattern)
    {
        _memo = new Dictionary<(int, int), bool>();
        // Start the recursive matching from the beginning of both strings
        return IsMatchRecursive(text, 0, pattern, 0);
    }

    private bool IsMatchRecursive(string text, int textIndex, string pattern, int patternIndex)
    {
        // 1. Check the cache first to see if we've already computed this result
        if (_memo!.ContainsKey((textIndex, patternIndex)))
        {
            return _memo[(textIndex, patternIndex)];
        }

        // 2. Base Case: If the pattern is exhausted, the match is successful
        //    only if the text is also exhausted.
        if (patternIndex == pattern.Length)
        {
            bool result = (textIndex == text.Length);
            _memo[(textIndex, patternIndex)] = result;
            return result;
        }

        // 3. Check if the current characters match.
        //    A match occurs if we are not at the end of the text AND
        //    (the pattern char is '.' OR the chars are identical).
        bool currentCharsMatch = (textIndex < text.Length) &&
                                 (pattern[patternIndex] == '.' || pattern[patternIndex] == text[textIndex]);

        bool finalResult;

        // 4. Handle the '*' special character.
        //    We look ahead to see if the next character in the pattern is a '*'.
        if (patternIndex + 1 < pattern.Length && pattern[patternIndex + 1] == '*')
        {
            // Case A: We treat '*' as matching ZERO instances of the preceding character.
            // This means we can skip over the 'p*' part of the pattern (patternIndex + 2)
            // and see if the rest of the pattern matches the current text.
            bool matchesZero = IsMatchRecursive(text, textIndex, pattern, patternIndex + 2);

            // Case B: We treat '*' as matching ONE or more instances.
            // This is only possible if the current characters match.
            // If they do, we "consume" one character from the text (textIndex + 1)
            // but stay at the SAME pattern position, because the '*' can match more characters.
            bool matchesOneOrMore = currentCharsMatch && IsMatchRecursive(text, textIndex + 1, pattern, patternIndex);
            
            finalResult = matchesZero || matchesOneOrMore;
        }
        else // 5. Standard character match (no '*' involved).
        {
            // If the current characters match, we move to the next character in both
            // the text and the pattern. Otherwise, it's a mismatch.
            if (currentCharsMatch)
            {
                finalResult = IsMatchRecursive(text, textIndex + 1, pattern, patternIndex + 1);
            }
            else
            {
                finalResult = false;
            }
        }
        
        // 6. Cache the result before returning
        _memo[(textIndex, patternIndex)] = finalResult;
        return finalResult;
    }
}