Freestyle Sparring

import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.runners.JUnit4;

// TODO: Replace examples and use TDD development by writing your own tests

public class SolutionTest {

    @Test
    public void should_return_a_when_a_gt_b() {
    
        int a = 10;
        int b = 5;
        
        assertEquals(a, BiggerNum.compare(a, b));
    }
    
    @Test
    public void should_return_b_when_a_lt_b() {
    
        int a = 4;
        int b = 5;
        
        assertEquals(b, BiggerNum.compare(a, b));
    }
    
    @Test
    public void should_return_either_when_a_eq_b() {
    
        int a = 5;
        int b = 5;
        
        assertEquals(5, BiggerNum.compare(a, b));
    }
}

#include <string>

using namespace std;

Describe(the_generic_vector_map_function) {
  It(should_correctly_map_an_int_vector_to_an_int_vector) {
    Assert::That(vectorMap(vector<int> {2, -7, 5, -4, 3}, [] (int n) -> int {return n * -2;}), EqualsContainer(vector<int> {-4, 14, -10, 8, -6}));
  }
  It(should_correctly_map_an_int_vector_to_a_string_vector) {
    Assert::That(vectorMap(vector<int> {13, 27, -2, 33, 666, 11723}, [] (int n) -> string {return to_string(n);}), EqualsContainer(vector<string> {"13", "27", "-2", "33", "666", "11723"}));
  }
};

Describe(the_generic_vector_filter_function) {
  It(should_correctly_filter_an_int_vector) {
    Assert::That(vectorFilter(vector<int> {4, 6, 9, 16, -5, -28}, [] (int n) -> bool {return n % 2 != 0;}), EqualsContainer(vector<int> {9, -5}));
    Assert::That(vectorFilter(vector<int> {4, 6, 9, 16, -5, -28}, [] (int n) -> bool {return n % 2 == 0;}), EqualsContainer(vector<int> {4, 6, 16, -28}));
  }
  It(should_correctly_filter_a_string_vector) {
    Assert::That(vectorFilter(vector<string> {"Hello World", "Goodbye World", "hello", "meow", "goodbye"}, [] (string s) -> bool {return s.find("Hello") != string::npos || s.find("hello") != string::npos;}), EqualsContainer(vector<string> {"Hello World", "hello"}));
    Assert::That(vectorFilter(vector<string> {"Hello World", "Goodbye World", "hello", "meow", "goodbye"}, [] (string s) -> bool {return s.find("Hello") == string::npos && s.find("hello") == string::npos;}), EqualsContainer(vector<string> {"Goodbye World", "meow", "goodbye"}));
  }
};

Describe(the_generic_vector_reduce_function) {
  It(should_correctly_reduce_an_int_vector_into_a_single_int) {
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, [] (int s, int n) -> int {return s + n * n;}, 0), Equals(17838));
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, [] (int t, int n) -> int {return t < n ? n : t;}, INT_MIN), Equals(99));
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, [] (int t, int n) -> int {return t > n ? n : t;}, INT_MAX), Equals(-23));
  }
  It(should_correctly_reduce_an_int_vector_into_a_string) {
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, [] (string s, int n) -> string {return s + to_string(n);}, (string)""), Equals("57486332-2399"));
  }
  It(should_correctly_reduce_a_string_vector_to_an_int) {
    Assert::That(vectorReduce(vector<string> {"Hello World", "Goodbye World", "hello", "meow", "goodbye"}, [] (int n, string s) -> int {return n + s.length();}, 0), Equals(40));
  }
};

Test.describe("Queue", function () {
  Test.it("is first-in-first-out", function () {
    var queue = new Queue();
    let items = [1,2,3];
    
    items.forEach(item => queue.enqueue(item));
    
    Test.assertEquals(queue.dequeue(), 1);
    Test.assertEquals(queue.dequeue(), 2);
    Test.assertEquals(queue.dequeue(), 3);
  });
  
  Test.describe("#enqueue", function() {
    Test.it("adds the item to the stack", function () {
      var queue = new Queue();
      var mockStack = [];
      
      queue._stack = mockStack;
      
      queue.enqueue(1);
      Test.assertSimilar(mockStack, [1]);   
      
      queue.enqueue(2);
      Test.assertSimilar(mockStack, [1,2]);
    });
  });
  
  Test.describe("#dequeue", function() {
    Test.it("removes items from the stack", function () {
      var queue = new Queue();
      var mockStack = [1,2];
      
      queue._stack = mockStack;
      
      queue.dequeue();
      Test.assertSimilar(mockStack, [2]);   
      
      queue.dequeue();
      Test.assertSimilar(mockStack, []);
    });
    
    Test.it("returns the first item from the stack", function () {
      var queue = new Queue();
      var mockStack = [1,2];
      var result = null;
      
      queue._stack = mockStack;
      
      result = queue.dequeue();
      Test.assertEquals(result, 1);   
      
      result = queue.dequeue();
      Test.assertEquals(result, 2);
    });
  });
});

Test.describe("Stack", function () {
  let stack = new Stack();
  
  Test.it("has #pop", function () {
    Test.expect(typeof stack.pop === "function");
  });
  
  Test.it("has #push", function () {
    Test.expect(typeof stack.push === "function");
  });
  
  Test.it("has .length", function () {
    Test.expect(typeof stack.length === "number");
  });
  
  Test.it("does not have #shift", function () {
    Test.expect(typeof stack.shift === "undefined");
  });
});

describe("Solution", function(){
  it("defaults to english", function(){
    Test.assertEquals(hello('gotham'), "hello gotham");
  });
  
  it("responds in pirate when passed 'pirate' as the language", function(){
    Test.assertEquals(hello('gotham', GREET_LANG.PIRATE), "yar gotham");
  });
  it("responds in real time binarry when passed 'binary' as the language", function(){
    Test.assertEquals(hello('gotham', GREET_LANG.BINARY), "0110100001100101011011000110110001101111 011001110110111101110100011010000110000101101101");
  });
});