Task 395 | Step 3 Code Execution | C# Online Compiler

Task 395 | Step 3 Code Execution by Jomo Lumina

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

public class SentimentAnalyzer
{
    public static string ClassifyText(string text, Dictionary<string, Dictionary<string, int>> trainingData)
    {
        // Input validation
        if (string.IsNullOrEmpty(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 sentiment probabilities
        double positiveProbability = CalculateSentimentProbability("positive", text, trainingData);
        double negativeProbability = CalculateSentimentProbability("negative", text, trainingData);

        // Return the sentiment with the highest probability
        return positiveProbability >= negativeProbability ? "positive" : "negative";
    }

    private static double CalculateSentimentProbability(string sentiment, string text, Dictionary<string, Dictionary<string, int>> trainingData)
    {
        double logProbability = Math.Log(0.5); // Assuming equal prior probability for each sentiment

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

        foreach (string word in words)
        {
            if (trainingData[sentiment].ContainsKey(word))
            {
                int wordCountInSentiment = trainingData[sentiment][word];
                int totalWordsInSentiment = trainingData[sentiment].Values.Sum();
                logProbability += Math.Log((double)wordCountInSentiment / totalWordsInSentiment);
            }
        }

        return logProbability;
    }

     public static void Main(string[] args)
    {
        // Example usage
        var 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 }
                }
            }
        };

        string text1 = "this is a good and great movie";
        string sentiment1 = ClassifyText(text1, trainingData);
        Console.WriteLine($"'{text1}' is classified as: {sentiment1}"); // Expected: positive

        string text2 = "this is a bad and terrible movie";
        string sentiment2 = ClassifyText(text2, trainingData);
        Console.WriteLine($"'{text2}' is classified as: {sentiment2}"); // Expected: negative
    }
}

[TestClass]
public class SentimentAnalyzerTests
{
    private readonly Dictionary<string, Dictionary<string, int>> _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_ReturnsCorrectSentiment()
    {
        string text = "this is a good bad and awesome movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment);
    }
    [TestMethod]
    public void ClassifyText_UnknownWords_ReturnsCorrectSentiment()
    {
        string text = "this movie is amazing";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment); // amazing gets ignored, so it defaults to the tiebreaker
    }

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

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

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

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_EmptyTrainingData_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("good movie", new Dictionary<string, Dictionary<string, int>>());
    }
     [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_MissingPositiveSentiment_ThrowsArgumentException()
    {
          var trainingData = new Dictionary<string, Dictionary<string, int>>
            {
               
                {
                    "negative", new Dictionary<string, int>
                    {
                        { "bad", 7 },
                        { "terrible", 5 },
                        { "awful", 3 },
                        { "good", 2 }
                    }
                }
            };
        SentimentAnalyzer.ClassifyText("good movie", trainingData);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_MissingNegativeSentiment_ThrowsArgumentException()
    {
      var trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            {
                "positive", new Dictionary<string, int>
                {
                    { "good", 10 },
                    { "great", 8 },
                    { "awesome", 5 },
                    { "bad", 2 }
                }
            }
        };
        SentimentAnalyzer.ClassifyText("good movie", trainingData);
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
​
public class SentimentAnalyzer
{
    public static string ClassifyText(string text, Dictionary<string, Dictionary<string, int>> trainingData)
    {
        // Input validation
        if (string.IsNullOrEmpty(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 sentiment probabilities
        double positiveProbability = CalculateSentimentProbability("positive", text, trainingData);
        double negativeProbability = CalculateSentimentProbability("negative", text, trainingData);
​
        // Return the sentiment with the highest probability
        return positiveProbability >= negativeProbability ? "positive" : "negative";
    }
​
    private static double CalculateSentimentProbability(string sentiment, string text, Dictionary<string, Dictionary<string, int>> trainingData)
    {
        double logProbability = Math.Log(0.5); // Assuming equal prior probability for each sentiment
​
        string[] words = text.Split(' ');
​
        foreach (string word in words)
        {
            if (trainingData[sentiment].ContainsKey(word))
            {
                int wordCountInSentiment = trainingData[sentiment][word];
                int totalWordsInSentiment = trainingData[sentiment].Values.Sum();
                logProbability += Math.Log((double)wordCountInSentiment / totalWordsInSentiment);
            }
        }
​
        return logProbability;
    }
​
     public static void Main(string[] args)
    {
        // Example usage
        var 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 }
                }
            }
        };
​
        string text1 = "this is a good and great movie";
        string sentiment1 = ClassifyText(text1, trainingData);
        Console.WriteLine($"'{text1}' is classified as: {sentiment1}"); // Expected: positive
​
        string text2 = "this is a bad and terrible movie";
        string sentiment2 = ClassifyText(text2, trainingData);
        Console.WriteLine($"'{text2}' is classified as: {sentiment2}"); // Expected: negative
    }
}
​
[TestClass]
public class SentimentAnalyzerTests
{
    private readonly Dictionary<string, Dictionary<string, int>> _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_ReturnsCorrectSentiment()
    {
        string text = "this is a good bad and awesome movie";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment);
    }
    [TestMethod]
    public void ClassifyText_UnknownWords_ReturnsCorrectSentiment()
    {
        string text = "this movie is amazing";
        string sentiment = SentimentAnalyzer.ClassifyText(text, _trainingData);
        Assert.AreEqual("positive", sentiment); // amazing gets ignored, so it defaults to the tiebreaker
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_EmptyText_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("", _trainingData);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_NullText_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText(null, _trainingData);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_NullTrainingData_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("good movie", null);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_EmptyTrainingData_ThrowsArgumentException()
    {
        SentimentAnalyzer.ClassifyText("good movie", new Dictionary<string, Dictionary<string, int>>());
    }
     [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_MissingPositiveSentiment_ThrowsArgumentException()
    {
          var trainingData = new Dictionary<string, Dictionary<string, int>>
            {
               
                {
                    "negative", new Dictionary<string, int>
                    {
                        { "bad", 7 },
                        { "terrible", 5 },
                        { "awful", 3 },
                        { "good", 2 }
                    }
                }
            };
        SentimentAnalyzer.ClassifyText("good movie", trainingData);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ClassifyText_MissingNegativeSentiment_ThrowsArgumentException()
    {
      var trainingData = new Dictionary<string, Dictionary<string, int>>
        {
            {
                "positive", new Dictionary<string, int>
                {
                    { "good", 10 },
                    { "great", 8 },
                    { "awesome", 5 },
                    { "bad", 2 }
                }
            }
        };
        SentimentAnalyzer.ClassifyText("good movie", trainingData);
    }
}

View IL Code