[Fact] 
public void Add_SingleNumber_ReturnsSameNumber() 
{ 
  var stringCalculator = new StringCalculator();
  var actual = stringCalculator.Add("42"); 
  Assert.Equal(42, actual); 
}

[Fact] 
public void Add_SingleNumber_ReturnsSameNumber() 
{
  var stringCalculator = new StringCalculator();
  var actual = stringCalculator.Add("0");
  Assert.Equal(0, actual);
}

[Fact] 
public void Add_BigNumber_ThrowsException() 
{
  var stringCalculator = new StringCalculator();
  Action actual = () => stringCalculator.Add("1001");
  Assert.Throws<OverflowException>(actual);
}

[Fact]
void Add_MaximumSumResult_ThrowsOverflowException()
{
  var stringCalculator = new StringCalculator();
  const string MAXIMUM_RESULT = "1001";
  Action actual = () => stringCalculator.Add(MAXIMUM_RESULT);
  Assert.Throws<OverflowException>(actual);
}

[Fact] 
public void Add_MultipleNumbers_ReturnsCorrectResults() 
{ 
  var stringCalculator = new StringCalculator();
  var expected = 0;
  var testCases = new[] { "0,0,0", "0,1,2", "1,2,3" };
  foreach (var test in testCases)
  {
     Assert.Equal(expected, stringCalculator.Add(test));
      expected += 3;
  }
}

[Theory]
[InlineData("0,0,0", 0)]
[InlineData("0,1,2", 3)]
[InlineData("1,2,3", 6)]
public void Add_MultipleNumbers_ReturnsSumOfNumbers(string input, int expected)
{
   var stringCalculator = new StringCalculator();
   var actual = stringCalculator.Add(input);
   Assert.Equal(expected, actual);
}

[Fact]
public void Add_EdgeCases_ThrowsArgumentExceptions()
{
   Assert.Throws<ArgumentException>(() => stringCalculator.Add(null));
   Assert.Throws<ArgumentException>(() => stringCalculator.Add("a"));
}

[Theory]
[InlineData(null)]
[InlineData("a")] 
public void Add_InputNullOrAlphabetic_ThrowsArgumentException(string input)
{
  var stringCalculator = new StringCalculator();
  Action actual = () => stringCalculator.Add(input);
  Assert.Throws<ArgumentException>(actual);
}

public string ParseLogLine(string input) 
{
  var sanitizedInput = TrimInput(input);
  return sanitizedInput;
} 
private string TrimInput(string input) 
{ 
  return input.Trim(); 
}

public void ParseLogLine_StartsAndEndsWithSpace_ReturnsTrimmedResult() 
{
   var parser = new Parser();
   var result = parser.ParseLogLine(" a ");
   Assert.Equals("a", result);
 }

public int GetDiscountedPrice(int price)
{
  if (DateTime.Now.DayOfWeek == DayOfWeek.Tuesday)
   { 
     return price / 2;
   } 
  else
   {
     return price;
   }
}

public void GetDiscountedPrice_NotTuesday_ReturnsFullPrice()
{
   var priceCalculator = new PriceCalculator();
   var actual = priceCalculator.GetDiscountedPrice(2);
   Assert.Equals(2, actual)
}
public void GetDiscountedPrice_OnTuesday_ReturnsHalfPrice()
{
   var priceCalculator = new PriceCalculator();
   var actual = priceCalculator.GetDiscountedPrice(2);
   Assert.Equals(1, actual);
}

public interface IDateTimeProvider
{ 
  DayOfWeek DayOfWeek(); 
} 
public int GetDiscountedPrice(int price, IDateTimeProvider dateTimeProvider)
{ 
   if (dateTimeProvider.DayOfWeek() == DayOfWeek.Tuesday)
   {
     return price / 2;
   }
   else
   { 
     return price;
   }
 }

public void GetDiscountedPrice_NotTuesday_ReturnsFullPrice()
{
  var priceCalculator = new PriceCalculator();
  var dateTimeProviderStub = new Mock<IDateTimeProvider>();
  dateTimeProviderStub.Setup(dtp => dtp.DayOfWeek()).Returns(DayOfWeek.Monday);
  var actual = priceCalculator.GetDiscountedPrice(2, dateTimeProviderStub);
  Assert.Equals(2, actual);
} 

public void GetDiscountedPrice_OnTuesday_ReturnsHalfPrice() 
{ 
  var priceCalculator = new PriceCalculator();
  var dateTimeProviderStub = new Mock<IDateTimeProvider>();
  dateTimeProviderStub.Setup(dtp => dtp.DayOfWeek()).Returns(DayOfWeek.Tuesday);
  var actual = priceCalculator.GetDiscountedPrice(2, dateTimeProviderStub);
  Assert.Equals(1, actual);
}