/* eslint-disable no-undef */

const {

getBiggest,

greeting,

isTenOrFive,

isInRange,

isInteger,

fizzBuzz,

isPrime,

returnFirst,

returnLast,

getArrayLength,

incrementByOne,

addItemToArray,

addItemToFront,

wordsToSentence,

contains,

addNumbers,

averageTestScore,

largestNumber

} = require('../src/project-2');

describe('Project 2', () => {

describe('getBiggest(x, y)', () => {

it('should return x if it is larger than y', () => {

expect(getBiggest(10, 5)).toBe(10);

});

it('should return y if it is larger than x', () => {

expect(getBiggest(50, 100)).toBe(100);

});

it('should return either one if they are the same', () => {

expect(getBiggest(1000, 1000)).toBe(1000);

});

});

describe('greeting(language)', () => {

it('should return \'Guten Tag!\' for German', () => {

expect(greeting('German')).toBe('Guten Tag!');

});

it('should return \'Hola!\' for Spanish', () => {

expect(greeting('Spanish')).toBe('Hola!');

});

it('should return \'Ni Hao!\' for Chinese', () => {

expect(greeting('Chinese')).toBe('Ni Hao!');

});

it('should return \'Hello!\' if no argument is passed in or if a language beyond Spanish, English, and German is passed in.', () => {

expect(greeting('French')).toBe('Hello!');

expect(greeting()).toBe('Hello!');

});

});

describe('isTenOrFive(num)', () => {

it('should return true if num is 10 or 5', () => {

expect(isTenOrFive(10)).toBe(true);

expect(isTenOrFive(5)).toBe(true);

});

it('should return false if num is not 10 or 5', () => {

expect(isTenOrFive(11)).toBe(false);

expect(isTenOrFive(6)).toBe(false);

expect(isTenOrFive(0)).toBe(false);

expect(isTenOrFive(5.01)).toBe(false);

});

});

describe('isInRange(num)', () => {

it('should return true if num is inside range', () => {

expect(isInRange(35.5)).toBe(true);

expect(isInRange(40)).toBe(true);

expect(isInRange(49)).toBe(true);

expect(isInRange(21)).toBe(true);

});

it('should return false if outside of range', () => {

expect(isInRange(10)).toBe(false);

expect(isInRange(20)).toBe(false);

expect(isInRange(50)).toBe(false);

expect(isInRange(100)).toBe(false);

});

});

describe('isInteger(num)', () => {

it('should return true if num is 5', () => {

expect(isInteger(5)).toBe(true);

});

it('should return false if num is 0.5', () => {

expect(isInteger(0.5)).toBe(false);

});

it('should return true if num is -20', () => {

expect(isInteger(-20)).toBe(true);

});

it('should return true for 0', () => {

expect(isInteger(0)).toBe(true);

});

});

describe('fizzBuzz(num)', () => {

it('should return fizz if divisible by 3', () => {

expect(fizzBuzz(9)).toBe('fizz');

});

it('should return buzz if divisible by 5', () => {

expect(fizzBuzz(10)).toBe('buzz');

});

it('should return fizzbuzz if divisible by 3 and 5', () => {

expect(fizzBuzz(15)).toBe('fizzbuzz');

});

it('should return num if not divisible by 3 or 5', () => {

expect(fizzBuzz(4)).toBe(4);

});

});

describe('isPrime(num)', () => {

it('should return true if num is prime', () => {

expect(isPrime(7)).toBe(true);

expect(isPrime(97)).toBe(true);

});

it('should return false if num is not prime', () => {

expect(isPrime(10)).toBe(false);

expect(isPrime(100)).toBe(false);

expect(isPrime(0)).toBe(false);

expect(isPrime(1)).toBe(false);

});

});

describe('returnFirst(arr)', () => {

it('should return the first item in the array', () => {

expect(returnFirst([10, 10, 16, 12])).toBe(10);

expect(returnFirst([97, 100, 80, 55, 72, 94])).toBe(97);

});

});

describe('returnLast(arr)', () => {

it('should return the last item in the array', () => {

expect(returnLast([10, 10, 16, 12])).toBe(12);

expect(returnLast([97, 100, 80, 55, 72, 94])).toBe(94);

expect(returnLast(['hi', 'there', 'how', 'are', 'you', 'doing?'])).toBe('doing?');

});

});

describe('getArrayLength(arr)', () => {

it('should return the length of the array', () => {

expect(getArrayLength([10, 10, 16, 12])).toBe(4);

expect(getArrayLength([97, 100, 80, 55, 72, 94])).toBe(6);

expect(getArrayLength(['hi', 'there', 'how', 'are', 'you', 'doing?'])).toBe(6);

});

});

describe('incrementByOne(arr)', () => {

it('should return the array with each value incremented by one', () => {

expect(incrementByOne([10, 10, 16, 12])).toEqual([11, 11, 17, 13]);

expect(incrementByOne([97, 100, 80, 55, 72, 94])).toEqual([98, 101, 81, 56, 73, 95]);

expect(incrementByOne([])).toEqual([]);

});

});

describe('addItemToArray(arr, item)', () => {

it('should return the array with the item added to the end', () => {

expect(addItemToArray([10, 10, 16, 12], 10)).toEqual([10, 10, 16, 12, 10]);

expect(addItemToArray([97, 100, 80, 55, 72, 94], 'Hello')).toEqual([97, 100, 80, 55, 72, 94, 'Hello']);

expect(addItemToArray([], true)).toEqual([true]);

});

});

describe('addItemToFront(arr, item)', () => {

it('should return the array with the item added to the front', () => {

expect(addItemToFront([10, 10, 16, 12], 10)).toEqual([10, 10, 10, 16, 12]);

expect(addItemToFront([97, 100, 80, 55, 72, 94], 'Hello')).toEqual(['Hello', 97, 100, 80, 55, 72, 94]);

expect(addItemToFront([], true)).toEqual([true]);

});

});

describe('wordsToSentence(words)', () => {

it('should return a string that has all of the words from the array separated by spaces', () => {

expect(wordsToSentence(['LambdaSchool', 'JavaScript', 'Class'])).toBe('LambdaSchool JavaScript Class');

expect(wordsToSentence(['LambdaSchool'])).toBe('LambdaSchool');

});

});

describe('contains(arr, item)', () => {

it('should return true if the array contains the item', () => {

expect(contains([10, 10, 16, 12], 10)).toBe(true);

expect(contains([97, 100, 80, 55, 72, 94], 'Hello')).toBe(false);

expect(contains([], true)).toBe(false);

});

});

describe('addNumbers(numbers)', () => {

it('should add all of the numbers in the array together and return the sum', () => {

expect(addNumbers([10, 10, 16])).toBe(36);

expect(addNumbers([97, 100])).toBe(197);

expect(addNumbers([0])).toBe(0);

});

});

describe('averageTestScore(testScores)', () => {

it('should return the average test score', () => {

expect(averageTestScore([10, 10, 16, 12])).toBe(12);

expect(averageTestScore([97, 100, 80, 55, 72, 94])).toBe(83);

});

});

describe('largestNumber(numbers)', () => {

it('should return the largest number', () => {

expect(largestNumber([10, 10, 16, 12])).toBe(16);

expect(largestNumber([97, 100, 80, 55, 72, 94])).toBe(100);

expect(largestNumber([97, 10000, 80, 55, 7.2, -94])).toBe(10000);

});

});

});