using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using Microsoft.VisualStudio.TestTools.UnitTesting;

​

public static class SentimentAnalyzer

{

    public static string ClassifyText(string text, Dictionary<string, Dictionary<string, int>> trainingData)

    {

        string[] words = text.Split(' ');

​

        double positiveProbability = CalculateSentimentProbability("positive", words, trainingData);

        double negativeProbability = CalculateSentimentProbability("negative", words, trainingData);

​

        return positiveProbability >= negativeProbability ? "positive" : "negative";

    }

​

    private static double CalculateSentimentProbability(string sentiment, string[] words, Dictionary<string, Dictionary<string, int>> trainingData)

    {

        double probability = 1.0;

​

        if (!trainingData.ContainsKey(sentiment))

        {

            return 0; // Or throw an exception, depending on how you want to handle unknown sentiments

        }

​

        Dictionary<string, int> wordCounts = trainingData[sentiment];

        int totalWordsInSentiment = wordCounts.Sum(kv => kv.Value);

​

        foreach (string word in words)

        {

            if (trainingData["positive"].ContainsKey(word) || trainingData["negative"].ContainsKey(word))

            {

                if (wordCounts.ContainsKey(word))

                {

                    probability *= (double)wordCounts[word] / totalWordsInSentiment;

                }

                else

                {

                    // If a word exist in other sentiment but not current, probability will be zero by nature of Naive Bayes.

                    probability *= 0.00000000000000000001; // Use a tiny value to avoid zero probability.

                }

            }

        }

        return probability;

    }

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

    }

}

​

[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_MixedText_ReturnsPositive()

    {

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

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

        Assert.AreEqual("positive", sentiment); // Expecting positive due to tie-breaking rule

    }

​

    [TestMethod]

    public void ClassifyText_UnknownWords_ReturnsPositive()

    {

        string text = "this is an unknown movie";  //unknown words are ignored.

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

        Assert.AreEqual("positive", sentiment); // Expecting positive, as it defaults when no words are matched

    }

​

    [TestMethod]

    public void ClassifyText_EmptyText_ReturnsPositive()

    {

        string text = "";

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

        Assert.AreEqual("positive", sentiment);

    }

​

    [TestMethod]

    public void ClassifyText_TextWithOnlyBad_ReturnsNegative()

    {

        string text = "bad bad bad";

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

        Assert.AreEqual("negative", sentiment);

    }

​

    [TestMethod]

    public void ClassifyText_TextWithWordFromOneSentiment_ReturnsOtherSentimentWhenOtherWordsAreUnknown()

    {

        // Arrange

        var trainingData = new Dictionary<string, Dictionary<string, int>>

        {

            { "positive", new Dictionary<string, int> { { "good", 10 } } },

            { "negative", new Dictionary<string, int> { { "bad", 7 } } }

        };

​

        string text = "unknown bad";

​

        // Act

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

​

        // Assert

        Assert.AreEqual("negative", sentiment);

    }

}