using System;

using System.Linq;

using System.Collections.Generic;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System.Text;

​

//1.  Implement the Implementations.GreenTea() method, according to it's description.

//2.  Implement the Implementations.FirstHalf() method, according to it's description.

//3.  Can you refactor the Program.AssertFirstHalfIsCorrect() method to handle more cases without hardcoding expected results?

//4.  Can you refactor the Implementations.GreenTea() method so that it can be tested, with or without hardcoding expected results?

//5.  When you have finished the test, please hit "Share" or "Fork" and then share the link back to us.

​

//Please treat this as if it were production quality code and tests you have to write, so highlight any potential pitfalls of the 

//approaches you take, maybe add some comments on additional tests you might right if you don't have time to write them now.    

​

public static class Implementations

{

    /// Prints out the numbers from 1 to n, 

    /// but if the number is divisible by 3 prints "Green" instead of the number,

    /// if the number is divisible by 5 it prints "Tea" instead of the number,

    /// and if the number is divisible by both 3 and 5 it prints "GreenTea" instead of the number.

    public static IList<string> GreenTea(int n)

    {

        var printedStrings = new List<string>();

        for(var i=1; i<=n; i++)

        { 

            string textToPrint = null;

            if(i % 3 == 0)

            {

                textToPrint = "Green";

            }

            if(i % 5 == 0)

            {

                textToPrint = string.Format("{0}Tea", textToPrint);

            }

            var result = textToPrint ?? i.ToString();

            printedStrings.Add(result);

            Console.WriteLine(result);

        }

        return printedStrings;

    }

    /// Returns the first half of the given sequence.  For example:

    ///   new[] { "North", "South", "East", "West" }.FirstHalf()

    /// returns "North","South".  An example with an odd number of items:

    ///   new[] { "red", "green", "blue" }.FirstHalf()

    /// returns "red".

    public static IEnumerable<T> FirstHalf<T>(this IEnumerable<T> tt)

    {

        var seqLength = tt.Count();

        var halfLength = seqLength/2;

        return tt.Take(halfLength);

    }

​

}

public class Program

{

    public static void Main()

    {

        AssertGreenTeaIsCorrect(1020);

        AssertGreenTeaIsCorrect(102);

        AssertGreenTeaIsCorrect(10, new string [] { "1", "2", "Green", "4", "Tea", "Green", "7", "8", "Green", "Tea" });

        AssertGreenTeaIsCorrect(4, new string [] { "1", "2", "Green", "4" });

        AssertFirstHalfIsCorrect(new string [] { "North", "South", "East", "West" });

        AssertFirstHalfIsCorrect(new string [] { "red", "green", "blue" });

        AssertGreenTeaIsCorrect(15, new string [] { "1", "2", "Green", "4", "Tea", "Green", "7", "8", "Green", "Tea", "11", "Green", "13", "14", "GreenTea" });

​

        Console.WriteLine("All tests succeeded.");

    }

    public static void AssertGreenTeaIsCorrect(int n, IEnumerable<string> expectedSequence = null)

    {

        var printedStrings = Implementations.GreenTea(n);

        if(expectedSequence != null) {

            Assert.IsTrue(printedStrings.SequenceEqual(expectedSequence));

        }

    }

    public static void AssertFirstHalfIsCorrect(IEnumerable<string> tt)

    {

        var result = tt.FirstHalf().ToList();

        var originalList = tt.ToList();

        var length = tt.Count()/2;

        var arrayExpectedLength = 0;

        for(var i = 0; i < length; i++){

            Assert.AreEqual(originalList[i], result[i], string.Format("The i item should be {0} not {1}", originalList[i], result[i]));

            arrayExpectedLength++;

        }

        Assert.AreEqual(arrayExpectedLength, result.Count, string.Format("The half array length should be {0} not {1}", arrayExpectedLength, result.Count));

        /*if (tt.SequenceEqual(new string [] { "North", "South", "East", "West" }))

            Assert.IsTrue(result.SequenceEqual(new string [] { "North", "South" }));

        else if (tt.SequenceEqual(new string [] { "red", "green", "blue" }))

            Assert.IsTrue(result.SequenceEqual(new string [] { "red" }));

        else

            Assert.Fail("No benchmark for sequence {0}.", string.Join(", ", tt));*/

    }

}

​

​