Task 395 | Step 2 Unit Test Execution | C# Online Compiler

Task 395 | Step 2 Unit Test Execution by Jomo Lumina

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

public class SentimentAnalyzer
{
    public static string ClassifyText(string text, Dictionary<string, Dictionary<string, int>> trainingData)
    {
        // Input validation
        if (string.IsNullOrWhiteSpace(text))
        {
            throw new ArgumentException("Text cannot be null or empty.", nameof(text));
        }

        if (trainingData == null || trainingData.Count == 0)
        {
            throw new ArgumentException("Training data cannot be null or empty.", nameof(trainingData));
        }

        if (!trainingData.ContainsKey("positive") || !trainingData.ContainsKey("negative"))
        {
            throw new ArgumentException("Training data must contain 'positive' and 'negative' sentiments.", nameof(trainingData));
        }

        // Calculate probabilities for each sentiment
        var sentiments = trainingData.Keys.ToList();
        var probabilities = new Dictionary<string, double>();

        // Pre-calculate vocabulary size and total word counts per sentiment
        var vocabulary = new HashSet<string>();
        var totalWordsPerSentiment = new Dictionary<string, int>();

        foreach (var sentiment in sentiments)
        {
            totalWordsPerSentiment[sentiment] = 0;
            foreach (var wordCount in trainingData[sentiment])
            {
                vocabulary.Add(wordCount.Key);
                totalWordsPerSentiment[sentiment] += wordCount.Value;
            }
        }

        int vocabularySize = vocabulary.Count;

        foreach (var sentiment in sentiments)
        {
            double logLikelihood = 0.0;
            string[] words = text.Split(' ');

            foreach (var word in words)
            {
                if (trainingData[sentiment].ContainsKey(word))
                {
                    // Laplace smoothing
                    logLikelihood += Math.Log((double)(trainingData[sentiment][word] + 1) / (totalWordsPerSentiment[sentiment] + vocabularySize));
                }
                else
                {
                    // Laplace smoothing for unseen words
                    logLikelihood += Math.Log(1.0 / (totalWordsPerSentiment[sentiment] + vocabularySize));
                }
            }

            // Prior probability (assuming equal priors for simplicity) and store the log value
            probabilities[sentiment] = Math.Log(1.0 / sentiments.Count) + logLikelihood;
        }

        // Return the sentiment with the highest probability
        return probabilities["positive"] >= probabilities["negative"] ? "positive" : "negative";
    }
}

[TestClass]
public class SentimentAnalyzerTests
{
    private Dictionary<string, Dictionary<string, int>> _trainingData;

    [TestInitialize]
    public void Setup()
    {
        _trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            {
                "positive", new Dictionary<string, int>
                {
                    { "good", 10 },
                    { "great", 8 },
                    { "awesome", 5 },
                    { "bad", 2 }
                }
            },
            {
                "negative", new Dictionary<string, int>
                {
                    { "bad", 7 },
                    { "terrible", 5 },
                    { "awful", 3 },
                    { "good", 2 }
                }
            }
        };
    }

    [TestMethod]
    public void ClassifyText_PositiveText_ReturnsPositive()
    {
        string text = "good great awesome";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment);
    }

    [TestMethod]
    public void ClassifyText_NegativeText_ReturnsNegative()
    {
        string text = "bad terrible awful";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("negative", sentiment);
    }

    [TestMethod]
    public void ClassifyText_MixedText_ReturnsPositive()
    {
        string text = "good bad great";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment);
    }

    [TestMethod]
    public void ClassifyText_UnknownWords_ReturnsPositive()
    {
        string text = "unknown words test";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment); // Due to tie-breaking rule
    }

    [TestMethod]
    public void ClassifyText_MoreNegativeWords_ReturnsNegative()
    {
        string text = "bad bad terrible";
        var trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            { "positive", new Dictionary<string, int> { { "good", 1 } } },
            { "negative", new Dictionary<string, int> { { "bad", 2 }, { "terrible", 1 } } }
        };
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("negative", sentiment);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_NullText_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText(null, _trainingData);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_EmptyText_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("", _trainingData);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_NullTrainingData_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("good", null);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_EmptyTrainingData_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("good", new Dictionary<string, Dictionary<string, int>>());
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_MissingPositiveSentiment_ThrowsArgumentException()
    {
        var invalidTrainingData = new Dictionary<string, Dictionary<string, int>>
        {
            { "negative", new Dictionary<string, int> { { "bad", 7 } } }
        };
        SentimentAnalyzer.ClassifyText("good", invalidTrainingData);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_MissingNegativeSentiment_ThrowsArgumentException()
    {
        var invalidTrainingData = new Dictionary<string, Dictionary<string, int>>
        {
            { "positive", new Dictionary<string, int> { { "good", 10 } } }
        };
        SentimentAnalyzer.ClassifyText("good", invalidTrainingData);
    }
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("🔍 Discovering and Running Tests...\n");

        int totalPassed = 0, totalFailed = 0;

        var testClasses = Assembly.GetExecutingAssembly()
            .GetTypes()
            .Where(t => t.GetCustomAttribute<TestClassAttribute>() != null);

        foreach (var testClass in testClasses)
        {
            Console.WriteLine($"📌 Running tests in: {testClass.Name}");
            (int passed, int failed) = RunTests(testClass);
            totalPassed += passed;
            totalFailed += failed;
            Console.WriteLine();
        }

        Console.WriteLine("\n📊 FINAL SUMMARY:");
        Console.WriteLine($"✅ Total Passed: {totalPassed}");
        Console.WriteLine($"❌ Total Failed: {totalFailed}");
        Console.WriteLine($"📌 Total Tests: {totalPassed + totalFailed}");

        Console.WriteLine("\n✅ Test execution completed.");
    }

    private static (int passed, int failed) RunTests(Type testClassType)
    {
        object testInstance = Activator.CreateInstance(testClassType);

        // Find and invoke the Setup method if it exists
        MethodInfo setupMethod = testClassType
            .GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
            .FirstOrDefault(m => m.GetCustomAttribute<TestInitializeAttribute>() != null);

        MethodInfo[] testMethods = testClassType
            .GetMethods(BindingFlags.Instance | BindingFlags.Public)
            .Where(m => m.GetCustomAttribute<TestMethodAttribute>() != null)
            .ToArray();

        int passed = 0, failed = 0;

        foreach (var method in testMethods)
        {
            try
            {
                // Call Setup before each test
                setupMethod?.Invoke(testInstance, null);

                method.Invoke(testInstance, null);
                Console.WriteLine($"  ✅ {method.Name} PASSED");
                passed++;
            }
            catch (TargetInvocationException ex)
            {
                Console.WriteLine($"  ❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");
                failed++;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"  ⚠️ {method.Name} ERROR: {ex.Message}");
                failed++;
            }
        }

        return (passed, failed);
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Microsoft.VisualStudio.TestTools.UnitTesting;
​
public class SentimentAnalyzer
{
    public static string ClassifyText(string text, Dictionary<string, Dictionary<string, int>> trainingData)
    {
        // Input validation
        if (string.IsNullOrWhiteSpace(text))
        {
            throw new ArgumentException("Text cannot be null or empty.", nameof(text));
        }
​
        if (trainingData == null || trainingData.Count == 0)
        {
            throw new ArgumentException("Training data cannot be null or empty.", nameof(trainingData));
        }
​
        if (!trainingData.ContainsKey("positive") || !trainingData.ContainsKey("negative"))
        {
            throw new ArgumentException("Training data must contain 'positive' and 'negative' sentiments.", nameof(trainingData));
        }
​
        // Calculate probabilities for each sentiment
        var sentiments = trainingData.Keys.ToList();
        var probabilities = new Dictionary<string, double>();
​
        // Pre-calculate vocabulary size and total word counts per sentiment
        var vocabulary = new HashSet<string>();
        var totalWordsPerSentiment = new Dictionary<string, int>();
​
        foreach (var sentiment in sentiments)
        {
            totalWordsPerSentiment[sentiment] = 0;
            foreach (var wordCount in trainingData[sentiment])
            {
                vocabulary.Add(wordCount.Key);
                totalWordsPerSentiment[sentiment] += wordCount.Value;
            }
        }
​
        int vocabularySize = vocabulary.Count;
​
        foreach (var sentiment in sentiments)
        {
            double logLikelihood = 0.0;
            string[] words = text.Split(' ');
​
            foreach (var word in words)
            {
                if (trainingData[sentiment].ContainsKey(word))
                {
                    // Laplace smoothing
                    logLikelihood += Math.Log((double)(trainingData[sentiment][word] + 1) / (totalWordsPerSentiment[sentiment] + vocabularySize));
                }
                else
                {
                    // Laplace smoothing for unseen words
                    logLikelihood += Math.Log(1.0 / (totalWordsPerSentiment[sentiment] + vocabularySize));
                }
            }
​
            // Prior probability (assuming equal priors for simplicity) and store the log value
            probabilities[sentiment] = Math.Log(1.0 / sentiments.Count) + logLikelihood;
        }
​
        // Return the sentiment with the highest probability
        return probabilities["positive"] >= probabilities["negative"] ? "positive" : "negative";
    }
}
​
[TestClass]
public class SentimentAnalyzerTests
{
    private Dictionary<string, Dictionary<string, int>> _trainingData;
​
    [TestInitialize]
    public void Setup()
    {
        _trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            {
                "positive", new Dictionary<string, int>
                {
                    { "good", 10 },
                    { "great", 8 },
                    { "awesome", 5 },
                    { "bad", 2 }
                }
            },
            {
                "negative", new Dictionary<string, int>
                {
                    { "bad", 7 },
                    { "terrible", 5 },
                    { "awful", 3 },
                    { "good", 2 }
                }
            }
        };
    }
​
    [TestMethod]
    public void ClassifyText_PositiveText_ReturnsPositive()
    {
        string text = "good great awesome";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_NegativeText_ReturnsNegative()
    {
        string text = "bad terrible awful";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("negative", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_MixedText_ReturnsPositive()
    {
        string text = "good bad great";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_UnknownWords_ReturnsPositive()
    {
        string text = "unknown words test";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment); // Due to tie-breaking rule
    }
​
    [TestMethod]
    public void ClassifyText_MoreNegativeWords_ReturnsNegative()
    {
        string text = "bad bad terrible";
        var trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            { "positive", new Dictionary<string, int> { { "good", 1 } } },
            { "negative", new Dictionary<string, int> { { "bad", 2 }, { "terrible", 1 } } }
        };
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("negative", sentiment);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_NullText_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText(null, _trainingData);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_EmptyText_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("", _trainingData);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_NullTrainingData_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("good", null);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_EmptyTrainingData_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("good", new Dictionary<string, Dictionary<string, int>>());
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_MissingPositiveSentiment_ThrowsArgumentException()
    {
        var invalidTrainingData = new Dictionary<string, Dictionary<string, int>>
        {
            { "negative", new Dictionary<string, int> { { "bad", 7 } } }
        };
        SentimentAnalyzer.ClassifyText("good", invalidTrainingData);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_MissingNegativeSentiment_ThrowsArgumentException()
    {
        var invalidTrainingData = new Dictionary<string, Dictionary<string, int>>
        {
            { "positive", new Dictionary<string, int> { { "good", 10 } } }
        };
        SentimentAnalyzer.ClassifyText("good", invalidTrainingData);
    }
}
​
public class Program
{
    public static void Main()
    {
        Console.WriteLine("🔍 Discovering and Running Tests...\n");
​
        int totalPassed = 0, totalFailed = 0;
​
        var testClasses = Assembly.GetExecutingAssembly()
            .GetTypes()
            .Where(t => t.GetCustomAttribute<TestClassAttribute>() != null);
​
        foreach (var testClass in testClasses)
        {
            Console.WriteLine($"📌 Running tests in: {testClass.Name}");
            (int passed, int failed) = RunTests(testClass);
            totalPassed += passed;
            totalFailed += failed;
            Console.WriteLine();
        }
​
        Console.WriteLine("\n📊 FINAL SUMMARY:");
        Console.WriteLine($"✅ Total Passed: {totalPassed}");
        Console.WriteLine($"❌ Total Failed: {totalFailed}");
        Console.WriteLine($"📌 Total Tests: {totalPassed + totalFailed}");
​
        Console.WriteLine("\n✅ Test execution completed.");
    }
​
    private static (int passed, int failed) RunTests(Type testClassType)
    {
        object testInstance = Activator.CreateInstance(testClassType);
​
        // Find and invoke the Setup method if it exists
        MethodInfo setupMethod = testClassType
            .GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
            .FirstOrDefault(m => m.GetCustomAttribute<TestInitializeAttribute>() != null);
​
        MethodInfo[] testMethods = testClassType
            .GetMethods(BindingFlags.Instance | BindingFlags.Public)
            .Where(m => m.GetCustomAttribute<TestMethodAttribute>() != null)
            .ToArray();
​
        int passed = 0, failed = 0;
​
        foreach (var method in testMethods)
        {
            try
            {
                // Call Setup before each test
                setupMethod?.Invoke(testInstance, null);
​
                method.Invoke(testInstance, null);
                Console.WriteLine($"  ✅ {method.Name} PASSED");
                passed++;
            }
            catch (TargetInvocationException ex)
            {
                Console.WriteLine($"  ❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");
                failed++;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"  ⚠️ {method.Name} ERROR: {ex.Message}");
                failed++;
            }
        }
​
        return (passed, failed);
    }
}
​

View IL Code