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)

    {

        // Calculate vocabulary size

        var vocabulary = new HashSet<string>();

        foreach (var sentimentData in trainingData.Values)

        {

            foreach (var word in sentimentData.Keys)

            {

                vocabulary.Add(word);

            }

        }

        int vocabularySize = vocabulary.Count;

​

        // Calculate prior probabilities and word counts for each sentiment

        var sentiments = trainingData.Keys.ToList();

        var priorProbabilities = new Dictionary<string, double>();

        var totalSentimentCounts = new Dictionary<string, int>();

​

        foreach (var sentiment in sentiments)

        {

            totalSentimentCounts[sentiment] = trainingData[sentiment].Values.Sum();

            priorProbabilities[sentiment] = (double)trainingData[sentiment].Count / trainingData.Values.Sum(x => x.Count);

        }

        // Calculate log probabilities for the input text

        var textWords = text.Split(' ');

        var logProbabilities = new Dictionary<string, double>();

​

        foreach (var sentiment in sentiments)

        {

            logProbabilities[sentiment] = Math.Log(priorProbabilities[sentiment]);

​

            foreach (var word in textWords)

            {

                if (trainingData[sentiment].ContainsKey(word))

                {

                    // Laplace smoothing

                    double wordProbability = (double)(trainingData[sentiment][word] + 1) / (totalSentimentCounts[sentiment] + vocabularySize);

                    logProbabilities[sentiment] += Math.Log(wordProbability);

                }

            }

        }

​

        // Predict sentiment (return "positive" in case of a tie).

        string predictedSentiment = "positive";

        if (logProbabilities["negative"] > logProbabilities["positive"])

        {

            predictedSentiment = "negative";

        }

​

        return predictedSentiment;

    }

​

    public static void Main()

    {

        Console.WriteLine("🔍 Discovering and Running Tests...\n");

​

        int totalPassed = 0, totalFailed = 0;

​

        // Get all classes in the assembly with the [TestClass] attribute

        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

            {

                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);

    }

}

​

[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 = "this is a good and great movie";

        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);

        Assert.AreEqual("positive", sentiment);

    }

​

    [TestMethod]

    public void ClassifyText_NegativeText_ReturnsNegative()

    {

        string text = "this is a bad and terrible movie";

        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);

        Assert.AreEqual("negative", sentiment);

    }

​

    [TestMethod]

    public void ClassifyText_NegativeText2_ReturnsNegative()

    {

        string text = "this movie is awful";

        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);

        Assert.AreEqual("negative", sentiment);

    }

    [TestMethod]

    public void ClassifyText_UnknownWords_ReturnsPositive()

    {

        string text = "unknown words test";  //All words are unknown

        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);

        Assert.AreEqual("positive", sentiment); //Default is positive

    }

​

    [TestMethod]

    public void ClassifyText_MixedWords_ReturnsPositive()

    {

        string text = "good bad unknown"; // Mixed positive and negative word + 1 unknown.

        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);

        Assert.AreEqual("positive", sentiment);

    }

    [TestMethod]

    public void ClassifyText_EmptyText_ReturnsPositive()

    {

        string text = "";

        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);

        Assert.AreEqual("positive", sentiment);

    }

​

    [TestMethod]

    public void ClassifyText_TextWithOnlySpaces_ReturnsPositive()

    {

        string text = "   ";

        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);

        Assert.AreEqual("positive", sentiment);

    }

}