Roy Osheroves Strings Kata

// My attempt at  http://osherove.com/tdd-kata-1/ using c# with nunit
// @martin_evans - last updated 21 December 2012 [End of the world edition!]

using System;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;

namespace Kata
{
    [TestFixture]
    public class StringCalculatorTests
    {
        private StringCalculator subject;

        [SetUp]
        public void Setup()
        {
            subject = new StringCalculator();
        }

        [Test]
        public void Add_EmptyString_ReturnsZero()
        {
            Assert.AreEqual(0, subject.Add(string.Empty));
        }

        [Test]
        public void Add_OneNumber_ReturnNumericValue()
        {
            Assert.AreEqual(0, subject.Add("0"));
        }

        [Test]
        public void Add_TwoNumbers_ReturnSum()
        {
            Assert.AreEqual(3, subject.Add("1,2"));
        }

        [Test]
        public void Add_UnknownNumberCount_ReturnSum()
        {
            var rnd = new Random();
            var numbers = "";
            var count = rnd.Next(1, 1000);
            var lst = new List<int>();

            for (var i = 0; i < count; i++)
                lst.Add(i);

            numbers = String.Join(",", lst.ToArray());

            Console.WriteLine("Testing with {0} numbers", count);

            Assert.AreEqual(lst.Sum(), subject.Add(numbers));

        }

        [Test]
        public void Add_AllowNewLinesBetweenNumbersInsteadOfCommas_ReturnsSum()
        {
            Assert.AreEqual(6, subject.Add("1\n2,3"));
        }

        [Test]
        public void Add_SupportsChangingDelimiterAtBeginningOfString_ReturnsSum()
        {
            Assert.AreEqual(3, subject.Add("//;\n1;2"));
        }

        [Test]
        public void Add_NegativeNumber_ThrowsException()
        {
            Assert.Throws<Exception>(() => subject.Add("1,2,3,-4,-5"));
        }

        [Test]
        public void Add_NegativeNumber_ExceptionContainsNumbersInMessage()
        {
            const string exMsg = "negatives not allowed : -4,-5";

            try
            {
                subject.Add("1,2,3,-4,-5");
                Assert.Fail();
            }
            catch (Exception ex)
            {
                Assert.AreEqual(exMsg, ex.Message);
            }
        }

        [Test]
        public void Add_NumbersBiggerThan1000Included_ShouldBeIgnoredInCalcultion()
        {
            Assert.AreEqual(3, subject.Add("1,2,1001"));
        }

        [Test]
        public void Add_DelimitersOfAnyLength_Permitted()
        {
            Assert.AreEqual(6, subject.Add("//[***]\n1***2***3"));
        }

        [Test]
        public void Add_MultipleDelimiters_Permitted()
        {
            Assert.AreEqual(6, subject.Add("//[*][%]\n1*2%3"));
        }

        [Test]
        public void Add_MultipleDelimitersWithLengthLongerThanOneCharacter_Permitted()
        {
            Assert.AreEqual(6, subject.Add("//[fred][wilma]\n1fred2wilma3"));
        }

    }

    public class StringCalculator
    {
        public int Add(string numbers)
        {
            if (string.IsNullOrEmpty(numbers))
                return 0;

            var numericVals = GetNumbersFromString(numbers);

            Validate(numericVals);

            return numericVals.Where(x=>x<=1000).Sum();
        }

        private void Validate(IEnumerable<int> numericVals)
        {
            var negativenumbers = numericVals.Where(x => x < 0);

            if (negativenumbers.Any())
            {
                var msg = string.Format("negatives not allowed : {0}", string.Join(",", negativenumbers));
                throw new Exception( msg);
            }


        }

        private static IEnumerable<int> GetNumbersFromString(string numbers)
        {
            var delimiters = new[]{","};

            if (numbers.StartsWith("//"))
            {
                var n = numbers.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
                delimiters = n[0].Substring(2).Split(new[] {"[", "]"}, StringSplitOptions.RemoveEmptyEntries);                ;
                numbers = string.Join(delimiters[0], n.Skip(1));
            }

            return  numbers
                           .Replace("\n", delimiters[0])
                           .Split(delimiters, StringSplitOptions.RemoveEmptyEntries)
                           .Select(Int32.Parse).ToArray();
        }
    }
}