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 void GreenTea(int n)

    {

        for(var number=1; number < n; number++){

            var textToPrint = GetGreenTeaTextForNumber(number);

​

            //If its decided that the output should go to other place, this hardcoded console write must be abstracted and use a IOutputSource.Output(text) interface or something like that

            Console.WriteLine(textToPrint);

        }

    }

    //4. Extracted this from the original green tea in order to make it testable

    public static string GetGreenTeaTextForNumber(int number){

        var textToPrint = string.Empty;

        if(number < 1){

            return string.Empty;

        }

        if(IsDivisibleBy(number, 3)){

            textToPrint = "Green";

        }

        if(IsDivisibleBy(number, 5)){

            textToPrint += "Tea";

        }

​

        //Im assuming that overall in the future for this game, you either print some string or some number, not both cases

        if(string.IsNullOrEmpty(textToPrint)){

            textToPrint = number.ToString();

        }

        return textToPrint;

    }

    private static bool IsDivisibleBy(int n, int divisor){

        return n%divisor == 0;

    }

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

    {

        //In the rare case the input was huge, I would reconsider this approach, for smaller cases its fine

        return tt.Take(tt.Count()/2);

    }

​

}

public class Program

{

    public static void Main()

    {

        AssertGreenTeaHardcodingResults();

        AssertGreenTeaWithoutHardcodingResults();

        AssertFirstHalfIsCorrect();

​

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

    }

    //4.Not hardcoding expected results

    private static void AssertGreenTeaHardcodingResults(){

        //4. Hardcoding expected results

        AssertGreenTeaIsCorrect(1, "1");

        AssertGreenTeaIsCorrect(2, "2");

        AssertGreenTeaIsCorrect(3, "Green");

        AssertGreenTeaIsCorrect(4, "4");

        AssertGreenTeaIsCorrect(5, "Tea");

        AssertGreenTeaIsCorrect(6, "Green");

        AssertGreenTeaIsCorrect(7, "7");

        AssertGreenTeaIsCorrect(10, "Tea");

        AssertGreenTeaIsCorrect(12, "Green");

        AssertGreenTeaIsCorrect(13, "13");

        AssertGreenTeaIsCorrect(15, "GreenTea");

        AssertGreenTeaIsCorrect(30, "GreenTea");

        //Adding an invalid input, it´s not clear what to do here so empty string as expected

        AssertGreenTeaIsCorrect(0, string.Empty);

    }

    private static void AssertGreenTeaWithoutHardcodingResults(){

        //I would not do this because what I would need is a way to generate random numbers and THEN determine which output to expect according to the rules of the green tea algorythm,

        //which in essence reimplements the logic that I´m testing (I could use the same algorythm that determines the expected output, to generate that expected output)

    }

    private static void AssertFirstHalfIsCorrect(){

        //Added edge case as well: empty array

        AssertFirstHalfIsCorrect(new string [] { }, new string [] { });

        AssertFirstHalfIsCorrect(new string [] { "one element" }, new string [] { });

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

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

    }

    //This method is not actually asserting anything, ill leave it just for the sake of pointing out its wrong

    public static void AssertGreenTeaIsCorrect(int n)

    {

        Implementations.GreenTea(n);

    }

    //4. The new method is testable. Im not testing that the output goes to the console, that should be abstractable behaviour, what I care about here is the green tea logic

    public static void AssertGreenTeaIsCorrect(int n, string expectedResult){

        Assert.AreEqual(expectedResult, Implementations.GetGreenTeaTextForNumber(n));

    }

    public static void AssertFirstHalfIsCorrect(IEnumerable<string> input, IEnumerable<string> expectedResult)

    {

        var result = input.FirstHalf();

        Assert.IsTrue(result.SequenceEqual(expectedResult));

        //I think this is the way to go. Now not hardcoding the expeceted results is possible by first creating the expected array, copying it and appending it 

        //another array full of random values. This other array would have the same size of the expected result or same size+1 (with random factor). Then logging

        //logic must be added to the assert to print the eventual failed cases. I dont think is worth it that ammount of work for this simple method.

    }

}

​

​