[Fork] Task 395 | Step 4 Unit Test Execution | C# Online Compiler

[Fork] Task 395 | Step 4 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)
    {
        if (string.IsNullOrWhiteSpace(text) || trainingData == null || trainingData.Count == 0)
        {
            return "positive"; // Default to positive if no training data or empty text
        }

        var sentiments = trainingData.Keys.ToList();
        var probabilities = new Dictionary<string, double>();

        // Calculate vocabulary size (unique words across all sentiments)
        var vocabulary = new HashSet<string>();
        foreach (var sentimentData in trainingData.Values)
        {
            vocabulary.UnionWith(sentimentData.Keys);
        }
        int vocabularySize = vocabulary.Count;

        foreach (var sentiment in sentiments)
        {
            if (!trainingData.ContainsKey(sentiment)) continue;

            var wordsInSentiment = trainingData[sentiment];
            double totalWordsInSentiment = wordsInSentiment.Values.Sum();
            double logLikelihood = 0.0;

            // Prior probability
            double prior = Math.Log((double)trainingData[sentiment].Count / vocabularySize);

            var textWords = text.Split(' ');

            foreach (var word in textWords)
            {
                if (string.IsNullOrWhiteSpace(word)) continue;

                // Laplace smoothing
                double wordCountInSentiment = wordsInSentiment.ContainsKey(word) ? wordsInSentiment[word] : 0;
                double wordProbability = (wordCountInSentiment + 1) / (totalWordsInSentiment + vocabularySize);
                logLikelihood += Math.Log(wordProbability);
            }
            probabilities[sentiment] = prior + logLikelihood;
        }

        // Find sentiment with highest probability
        string predictedSentiment = "positive"; // Default to positive in case of a tie
        double maxProbability = double.NegativeInfinity;
        foreach (var kvp in probabilities)
        {
            if (kvp.Value > maxProbability)
            {
                maxProbability = kvp.Value;
                predictedSentiment = kvp.Key;
            }
        }

        return predictedSentiment;
    }
}

[TestClass]
public class SentimentAnalyzerTests
{
    private Dictionary<string, Dictionary<string, int>> GetTrainingData()
    {
        return 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()
    {
        var trainingData = GetTrainingData();
        string text = "this is a good and great movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }

    [TestMethod]
    public void ClassifyText_NegativeText_ReturnsNegative()
    {
        var trainingData = GetTrainingData();
        string text = "this is a bad and terrible movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("negative", sentiment);
    }

    [TestMethod]
    public void ClassifyText_MixedText_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string text = "this is a good and bad movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }

    [TestMethod]
    public void ClassifyText_UnknownWords_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string text = "unknown words test";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment); //Due to priors.
    }

    [TestMethod]
    public void ClassifyText_EmptyText_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string text = "";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }

    [TestMethod]
    public void ClassifyText_NullText_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string sentiment = SentimentAnalyzer.ClassifyText(null, trainingData);
        Assert.AreEqual("positive", sentiment);
    }

    [TestMethod]
    public void ClassifyText_EmptyTrainingData_ReturnsPositive()
    {
        var trainingData = new Dictionary<string, Dictionary<string, int>>();
        string text = "this is a good movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }

    [TestMethod]
    public void ClassifyText_NullTrainingData_ReturnsPositive()
    {
        string text = "this is a good movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, null);
        Assert.AreEqual("positive", sentiment);
    }

    [TestMethod]
    public void ClassifyText_OneSentimentMissing_ReturnsCorrectSentiment()
    {
        var trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            {
                "positive", new Dictionary<string, int>
                {
                    { "good", 10 },
                    { "great", 8 },
                    { "awesome", 5 },
                    { "bad", 2 }
                }
            }
        };
        string text = "bad terrible movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment); // No negative data, so defaults.

        trainingData = new Dictionary<string, Dictionary<string, int>>
        {
             {
                "negative", new Dictionary<string, int>
                {
                    { "bad", 7 },
                    { "terrible", 5 },
                    { "awful", 3 },
                    { "good", 2 }
                }
            }
        };

        text = "good great movie";
        sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("negative", sentiment);


        trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            {
                "positive", new Dictionary<string, int>
                {
                    { "good", 10 },
                    { "great", 8 },
                    { "awesome", 5 },
                    { "bad", 2 }
                }
            },
            {
                "neutral", new Dictionary<string, int>
                {
                    {"okay", 5},
                    {"alright", 4}
                }
            }

        };
         text = "this is okay";
         sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
         Assert.AreEqual("positive", sentiment);
    }

    [TestMethod]
    public void ClassifyText_WhitespaceText_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string text = "   ";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }
}

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)
    {
        if (string.IsNullOrWhiteSpace(text) || trainingData == null || trainingData.Count == 0)
        {
            return "positive"; // Default to positive if no training data or empty text
        }
​
        var sentiments = trainingData.Keys.ToList();
        var probabilities = new Dictionary<string, double>();
​
        // Calculate vocabulary size (unique words across all sentiments)
        var vocabulary = new HashSet<string>();
        foreach (var sentimentData in trainingData.Values)
        {
            vocabulary.UnionWith(sentimentData.Keys);
        }
        int vocabularySize = vocabulary.Count;
​
        foreach (var sentiment in sentiments)
        {
            if (!trainingData.ContainsKey(sentiment)) continue;
​
            var wordsInSentiment = trainingData[sentiment];
            double totalWordsInSentiment = wordsInSentiment.Values.Sum();
            double logLikelihood = 0.0;
​
            // Prior probability
            double prior = Math.Log((double)trainingData[sentiment].Count / vocabularySize);
​
            var textWords = text.Split(' ');
​
            foreach (var word in textWords)
            {
                if (string.IsNullOrWhiteSpace(word)) continue;
​
                // Laplace smoothing
                double wordCountInSentiment = wordsInSentiment.ContainsKey(word) ? wordsInSentiment[word] : 0;
                double wordProbability = (wordCountInSentiment + 1) / (totalWordsInSentiment + vocabularySize);
                logLikelihood += Math.Log(wordProbability);
            }
            probabilities[sentiment] = prior + logLikelihood;
        }
​
        // Find sentiment with highest probability
        string predictedSentiment = "positive"; // Default to positive in case of a tie
        double maxProbability = double.NegativeInfinity;
        foreach (var kvp in probabilities)
        {
            if (kvp.Value > maxProbability)
            {
                maxProbability = kvp.Value;
                predictedSentiment = kvp.Key;
            }
        }
​
        return predictedSentiment;
    }
}
​
[TestClass]
public class SentimentAnalyzerTests
{
    private Dictionary<string, Dictionary<string, int>> GetTrainingData()
    {
        return 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()
    {
        var trainingData = GetTrainingData();
        string text = "this is a good and great movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_NegativeText_ReturnsNegative()
    {
        var trainingData = GetTrainingData();
        string text = "this is a bad and terrible movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("negative", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_MixedText_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string text = "this is a good and bad movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_UnknownWords_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string text = "unknown words test";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment); //Due to priors.
    }
​
    [TestMethod]
    public void ClassifyText_EmptyText_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string text = "";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_NullText_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string sentiment = SentimentAnalyzer.ClassifyText(null, trainingData);
        Assert.AreEqual("positive", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_EmptyTrainingData_ReturnsPositive()
    {
        var trainingData = new Dictionary<string, Dictionary<string, int>>();
        string text = "this is a good movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_NullTrainingData_ReturnsPositive()
    {
        string text = "this is a good movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, null);
        Assert.AreEqual("positive", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_OneSentimentMissing_ReturnsCorrectSentiment()
    {
        var trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            {
                "positive", new Dictionary<string, int>
                {
                    { "good", 10 },
                    { "great", 8 },
                    { "awesome", 5 },
                    { "bad", 2 }
                }
            }
        };
        string text = "bad terrible movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment); // No negative data, so defaults.
​
        trainingData = new Dictionary<string, Dictionary<string, int>>
        {
             {
                "negative", new Dictionary<string, int>
                {
                    { "bad", 7 },
                    { "terrible", 5 },
                    { "awful", 3 },
                    { "good", 2 }
                }
            }
        };
​
        text = "good great movie";
        sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("negative", sentiment);
​
​
        trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            {
                "positive", new Dictionary<string, int>
                {
                    { "good", 10 },
                    { "great", 8 },
                    { "awesome", 5 },
                    { "bad", 2 }
                }
            },
            {
                "neutral", new Dictionary<string, int>
                {
                    {"okay", 5},
                    {"alright", 4}
                }
            }
​
        };
         text = "this is okay";
         sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
         Assert.AreEqual("positive", sentiment);
    }
​
    [TestMethod]
    public void ClassifyText_WhitespaceText_ReturnsPositive()
    {
        var trainingData = GetTrainingData();
        string text = "   ";
        string sentiment = SentimentAnalyzer.ClassifyText(text, trainingData);
        Assert.AreEqual("positive", sentiment);
    }
}
​
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