SnippetsTests.java

package snippets;

import java.util.AbstractMap.SimpleEntry;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.OptionalInt;
import java.util.stream.IntStream;

import org.junit.Test;

import static org.assertj.core.api.Assertions.assertThat;

public class SnippetsTests {

    @Test
    public void gcd_of_array_containing_1_to_5_is_1() throws Exception {
        OptionalInt gcd = Snippets.gcd(new int[]{1, 2, 3, 4, 5});
        assertThat(gcd).isNotEmpty();
        assertThat(gcd).hasValue(1);
    }

    @Test
    public void gcd_of_array_containing_4_8_and_12_is_4() throws Exception {
        OptionalInt gcd = Snippets.gcd(new int[]{4, 8, 12});
        assertThat(gcd).isNotEmpty();
        assertThat(gcd).hasValue(4);
    }

    @Test
    public void lcm_of_array_containing_1_to_5_is_60() throws Exception {
        OptionalInt lcm = Snippets.lcm(new int[]{1, 2, 3, 4, 5});
        assertThat(lcm).isNotEmpty();
        assertThat(lcm).hasValue(60);
    }

    @Test
    public void lcm_of_array_containing_4_8_and_12_is_24() throws Exception {
        OptionalInt lcm = Snippets.lcm(new int[]{4, 8, 12});
        assertThat(lcm).isNotEmpty();
        assertThat(lcm).hasValue(24);
    }

    @Test
    public void max_of_array_containing_10_1_and_5_is_10() throws Exception {
        OptionalInt max = Snippets.arrayMax(new int[]{10, 1, 5});
        assertThat(max).hasValue(10);
    }

    @Test
    public void min_of_array_containing_10_1_and_5_is_10() throws Exception {
        OptionalInt min = Snippets.arrayMin(new int[]{10, 1, 5});
        assertThat(min).hasValue(1);
    }

    @Test
    public void chunk_breaks_input_array__with_odd_length() throws Exception {
        int[][] chunks = Snippets.chunk(new int[]{1, 2, 3, 4, 5}, 2);
        assertThat(chunks)
                .containsExactly(
                        new int[]{1, 2},
                        new int[]{3, 4},
                        new int[]{5}
                );
    }

    @Test
    public void chunk_breaks_input_array__with_event_length() throws Exception {
        int[][] chunks = Snippets.chunk(new int[]{1, 2, 3, 4, 5, 6}, 2);
        assertThat(chunks)
                .containsExactly(
                        new int[]{1, 2},
                        new int[]{3, 4},
                        new int[]{5, 6}
                );
    }

    @Test
    public void countOccurrences_counts_occurrences_of_a_value() throws Exception {
        long count = Snippets.countOccurrences(new int[]{1, 1, 2, 1, 2, 3}, 1);
        assertThat(count).isEqualTo(3);
    }

    @Test
    public void deepFlatten_flatten_a_deeply_nested_array() throws Exception {
        int[] flatten = Snippets.deepFlatten(
                new Object[]{1, new Object[]{2}, new Object[]{3, 4, 5}}
        );

        assertThat(flatten).isEqualTo(new int[]{1, 2, 3, 4, 5});
    }

    @Test
    public void difference_between_array_with_1_2_3_and_array_with_1_2_4_is_3() throws Exception {
        int[] difference = Snippets.difference(new int[]{1, 2, 3}, new int[]{1, 2, 4});
        assertThat(difference).isEqualTo(new int[]{3});
    }

    @Test
    public void difference_between_array_with_1_2_3_and_array_with_1_2_3_is_empty_array() throws Exception {
        int[] difference = Snippets.difference(new int[]{1, 2, 3}, new int[]{1, 2, 3});
        assertThat(difference).isEmpty();
    }

    @Test
    public void differenceWith_return_all_squares_that_do_not_exist_in_second() throws Exception {
        int[] difference = Snippets.differenceWith(
                new int[]{1, 4, 9, 16, 25},
                new int[]{1, 2, 3, 6, 7},
                (o1, o2) -> o1 - (o2 * o2)
        );

        assertThat(difference).isEqualTo(new int[]{16, 25});
    }

    @Test
    public void differenceWith_returns_empty_array_when_two_arrays_are_equal_as_per_comparison_operation() throws Exception {
        int[] difference = Snippets.differenceWith(
                new int[]{1, 2, 3},
                new int[]{1, 2, 3},
                (o1, o2) -> o1 - o2
        );

        assertThat(difference).isEmpty();
    }

    @Test
    public void differenceWith_returns_first_array_when_elements_in_second_array_are_not_comparable_as_per_comparison_operation() throws Exception {
        int[] difference = Snippets.differenceWith(
                new int[]{1, 2, 3},
                new int[]{10, 11, 12},
                (o1, o2) -> o1 - o2
        );

        assertThat(difference).isEqualTo(new int[]{1, 2, 3});
    }

    @Test
    public void distinct_remove_all_duplicate_values_from_an_array() throws Exception {
        int[] distinct = Snippets.distinctValuesOfArray(new int[]{1, 2, 2, 3, 4, 4, 5});
        assertThat(distinct).isEqualTo(new int[]{1, 2, 3, 4, 5});
    }

    @Test
    public void drop_elements_less_than_3() throws Exception {
        int[] elements = Snippets.dropElements(new int[]{1, 2, 3, 4}, i -> i >= 3);
        assertThat(elements).isEqualTo(new int[]{3, 4});
    }

    @Test
    public void drop_elements_returns_empty_array_when_no_element_match_the_condition() throws Exception {
        int[] elements = Snippets.dropElements(new int[]{1, 2, 3, 4}, i -> i < 1);
        assertThat(elements).isEmpty();
    }

    @Test
    public void drop_elements__return_all_elements_when_all_elements_match_the_condition() throws Exception {
        int[] elements = Snippets.dropElements(new int[]{1, 2, 3, 4}, i -> i <= 4);
        assertThat(elements).isEqualTo(new int[]{1, 2, 3, 4});
    }

    @Test
    public void dropRight_remove_n_elements_from_right() throws Exception {
        int[] elements = Snippets.dropRight(new int[]{1, 2, 3}, 1);
        assertThat(elements).isEqualTo(new int[]{1, 2});

        elements = Snippets.dropRight(new int[]{1, 2, 3}, 2);
        assertThat(elements).isEqualTo(new int[]{1});

        elements = Snippets.dropRight(new int[]{1, 2, 3}, 3);
        assertThat(elements).isEmpty();

        elements = Snippets.dropRight(new int[]{1, 2, 3}, 42);
        assertThat(elements).isEmpty();
    }

    @Test
    public void everyNth_return_every_2nd_element() throws Exception {
        int[] elements = Snippets.everyNth(new int[]{1, 2, 3, 4, 5, 6}, 2);
        assertThat(elements).isEqualTo(new int[]{2, 4, 6});
    }

    @Test
    public void filterNonUnique_return_unique_elements() throws Exception {
        int[] elements = Snippets.filterNonUnique(new int[]{1, 2, 2, 3, 4, 4, 5});
        assertThat(elements).isEqualTo(new int[]{1, 3, 5});
    }

    @Test
    public void filterNonUnique_return_same_array_when_all_unique() throws Exception {
        int[] elements = Snippets.filterNonUnique(new int[]{1, 2, 3, 4, 5});
        assertThat(elements).isEqualTo(new int[]{1, 2, 3, 4, 5});
    }

    @Test
    public void filterNonUnique_return_empty_array_when_all_duplicated() throws Exception {
        int[] elements = Snippets.filterNonUnique(new int[]{1, 1, 2, 2, 3, 3, 4, 4, 5, 5});
        assertThat(elements).isEmpty();
    }

    @Test
    public void flatten_flat_one_level_array() throws Exception {
        int[] flatten = Snippets.flatten(new Object[]{1, new int[]{2}, 3, 4});
        assertThat(flatten).isEqualTo(new int[]{1, 2, 3, 4});
    }

    @Test
    public void flattenDepth_flatten_to_specified_depth() throws Exception {
        Object[] input = {
                1,
                new Object[]{2},
                new Object[]{
                        new Object[]{
                                new Object[]{
                                        3
                                },
                                4
                        }, 5
                }
        };

        Object[] flatten = Snippets.flattenDepth(input, 2);
        assertThat(flatten).isEqualTo(new Object[]{1, 2, new Object[]{3}, 4, 5});
    }

    @Test
    public void group_elements_by_length() throws Exception {
        Map<Integer, List<String>> groups = Snippets.groupBy(new String[]{"one", "two", "three"}, String::length);
        assertThat(groups)
                .containsOnly(
                        new SimpleEntry<>(3, Arrays.asList("one", "two")),
                        new SimpleEntry<>(5, Collections.singletonList("three"))
                );
    }

    @Test
    public void initial_return_array_except_last_element() throws Exception {
        Integer[] initial = Snippets.initial(new Integer[]{1, 2, 3});
        assertThat(initial).isEqualTo(new Integer[]{1, 2});
    }

    @Test
    public void initializeArrayWithRange_from_1_to_5() throws Exception {
        int[] numbers = Snippets.initializeArrayWithRange(5, 1);
        assertThat(numbers).isEqualTo(new int[]{1, 2, 3, 4, 5});
    }

    @Test
    public void initializeArrayWithValues() throws Exception {
        int[] elements = Snippets.initializeArrayWithValues(5, 2);
        assertThat(elements).isEqualTo(new int[]{2, 2, 2, 2, 2});
    }

    @Test
    public void intersection_between_two_arrays() throws Exception {
        int[] elements = Snippets.intersection(new int[]{1, 2, 3}, new int[]{4, 3, 2});
        assertThat(elements).isEqualTo(new int[]{2, 3});
    }

    @Test
    public void isSorted_return_1_when_array_sorted_is_ascending_order() throws Exception {
        int sorted = Snippets.isSorted(new Integer[]{0, 1, 2, 3});
        assertThat(sorted).isEqualTo(1);

        sorted = Snippets.isSorted(new Integer[]{0, 1, 2, 2});
        assertThat(sorted).isEqualTo(1);
    }

    @Test
    public void isSorted_return_minus_1_when_array_sorted_in_descending_order() throws Exception {
        int sorted = Snippets.isSorted(new Integer[]{3, 2, 1, 0});
        assertThat(sorted).isEqualTo(-1);

        sorted = Snippets.isSorted(new Integer[]{3, 3, 2, 1, 0});
        assertThat(sorted).isEqualTo(-1);
    }

    @Test
    public void isSorted_returns_0_when_array_is_not_sorted() throws Exception {
        int sorted = Snippets.isSorted(new Integer[]{3, 4, 1, 0});
        assertThat(sorted).isEqualTo(0);
    }

    @Test
    public void join_should_create_string_from_an_array_with_different_sep_and_end() throws Exception {
        String joined = Snippets.join(new String[]{"pen", "pineapple", "apple", "pen"}, ",", "&");
        assertThat(joined).isEqualTo("pen,pineapple,apple&pen");
    }

    @Test
    public void join_should_create_string_from_an_array_with_sep_only() throws Exception {
        String joined = Snippets.join(new String[]{"pen", "pineapple", "apple", "pen"}, ",");
        assertThat(joined).isEqualTo("pen,pineapple,apple,pen");
    }

    @Test
    public void join_should_create_string_from_an_array_with_default_sep() throws Exception {
        String joined = Snippets.join(new String[]{"pen", "pineapple", "apple", "pen"});
        assertThat(joined).isEqualTo("pen,pineapple,apple,pen");
    }

    @Test
    public void join_should_create_empty_string_with_empty_array() throws Exception {
        String joined = Snippets.join(new String[]{});
        assertThat(joined).isEqualTo("");
    }

    @Test
    public void nthElement_return_nth_element_from_start_when_n_is_greater_than_0() throws Exception {
        String nthElement = Snippets.nthElement(new String[]{"a", "b", "c"}, 1);
        assertThat(nthElement).isEqualTo("b");
    }


    @Test
    public void nthElement_return_nth_element_from_end_when_n_is_less_than_0() throws Exception {
        String nthElement = Snippets.nthElement(new String[]{"a", "b", "c"}, -3);
        assertThat(nthElement).isEqualTo("a");
    }

    @Test
    public void pick_should_pick_key_pairs_corresponding_to_keys() throws Exception {
        Map<String, Integer> obj = new HashMap<>();
        obj.put("a", 1);
        obj.put("b", 2);
        obj.put("c", 3);

        Map<String, Integer> picked = Snippets.pick(obj, new String[]{"a", "c"});
        assertThat(picked).containsOnly(new SimpleEntry<>("a", 1), new SimpleEntry<>("c", 3));
    }

    @Test
    public void reducedFilter_Test() throws Exception {
        Map<String, Object> item1 = new HashMap<>();
        item1.put("id", 1);
        item1.put("name", "john");
        item1.put("age", 24);

        Map<String, Object> item2 = new HashMap<>();
        item2.put("id", 2);
        item2.put("name", "mike");
        item2.put("age", 50);

        Map<String, Object>[] filtered = Snippets.reducedFilter((Map<String, Object>[]) new Map[]{item1, item2}, new String[]{"id", "name"}, item -> (Integer) item.get("age") > 24);
        assertThat(filtered).hasSize(1);
        assertThat(filtered[0])
                .containsOnly(
                        new SimpleEntry<String, Object>("id", 2),
                        new SimpleEntry<String, Object>("name", "mike"));
    }

    @Test
    public void sample_should_return_random_element() throws Exception {
        Integer sample = Snippets.sample(new Integer[]{3, 7, 9, 11});
        assertThat(sample).isIn(Arrays.asList(3, 7, 9, 11));
    }

    @Test
    public void sampleSize_should_return_sample_of_size_array_length_when_sample_size_is_greater_than_array_size() throws Exception {
        Integer[] sample = Snippets.sampleSize(new Integer[]{1, 2, 3}, 4);
        assertThat(sample).hasSize(3);
    }

    @Test
    public void similarity_test() throws Exception {
        Integer[] arr = Snippets.similarity(new Integer[]{1, 2, 3}, new Integer[]{1, 2, 4});
        assertThat(arr).isEqualTo(new Integer[]{1, 2});
    }

    @Test
    public void empty_array() throws Exception {
        String[] empty = Snippets.emptyArray(String.class);
        assertThat(empty).isEmpty();
    }

    @Test
    public void sortedIndex_descending() throws Exception {
        int index = Snippets.sortedIndex(new Integer[]{5, 3, 2, 1}, 4);
        assertThat(index).isEqualTo(1);
    }

    @Test
    public void sortedIndex_ascending() throws Exception {
        int index = Snippets.sortedIndex(new Integer[]{30, 50}, 40);
        assertThat(index).isEqualTo(1);
    }

    @Test
    public void sortedIndex_ascending_at_end() throws Exception {
        int index = Snippets.sortedIndex(new Integer[]{30, 50}, 60);
        assertThat(index).isEqualTo(2);
    }

    @Test
    public void symmetricDifference_test() throws Exception {
        Integer[] diff = Snippets.symmetricDifference(
                new Integer[]{1, 2, 3},
                new Integer[]{1, 2, 4}
        );
        assertThat(diff).isEqualTo(new Integer[]{3, 4});
    }

    @Test
    public void union_test() throws Exception {
        Integer[] union = Snippets.union(
                new Integer[]{1, 2, 3},
                new Integer[]{1, 2, 4}
        );

        assertThat(union).containsExactlyInAnyOrder(new Integer[]{1, 2, 3, 4});
    }

    @Test
    public void without_test() throws Exception {
        Integer[] without = Snippets.without(
                new Integer[]{2, 1, 2, 3},
                1, 2

        );

        assertThat(without).isEqualTo(new Integer[]{3});
    }

    @Test
    public void zip_test() throws Exception {
        List<Object[]> zipped = Snippets.zip(
                new String[]{"a", "b"},
                new Integer[]{1, 2},
                new Boolean[]{true, false}
        );

        assertThat(zipped).hasSize(2);
        assertThat(zipped.get(0)).isEqualTo(new Object[]{"a", 1, true});
        assertThat(zipped.get(1)).isEqualTo(new Object[]{"b", 2, false});
    }

    @Test
    public void zip_test_2() throws Exception {
        List<Object[]> zipped = Snippets.zip(
                new String[]{"a"},
                new Integer[]{1, 2},
                new Boolean[]{true, false}
        );

        assertThat(zipped).hasSize(2);
        assertThat(zipped.get(0)).isEqualTo(new Object[]{"a", 1, true});
        assertThat(zipped.get(1)).isEqualTo(new Object[]{null, 2, false});
    }

    @Test
    public void zipObject_test_1() throws Exception {
        Map<String, Object> map = Snippets.zipObject(
                new String[]{"a", "b", "c"},
                new Integer[]{1, 2}
        );

        assertThat(map).containsOnly(
                new SimpleEntry<>("a", 1),
                new SimpleEntry<>("b", 2),
                new SimpleEntry<>("c", null)
        );
    }

    @Test
    public void zipObject_test_2() throws Exception {
        Map<String, Object> map = Snippets.zipObject(
                new String[]{"a", "b"},
                new Integer[]{1, 2, 3}
        );

        assertThat(map).containsOnly(
                new SimpleEntry<>("a", 1),
                new SimpleEntry<>("b", 2)
        );
    }

    @Test
    public void average_of_1_to_10_is_5_dot_5() throws Exception {
        double average = Snippets.average(IntStream.rangeClosed(1, 10).toArray());
        assertThat(average).isEqualTo(5.5);
    }

    @Test
    public void capitalize_test() throws Exception {
        assertThat(Snippets.capitalize("fooBar", false)).isEqualTo("FooBar");
        assertThat(Snippets.capitalize("fooBar", true)).isEqualTo("Foobar");
    }

    @Test
    public void capitalizeEveryWord_test() throws Exception {
        assertThat(Snippets.capitalizeEveryWord("hello world!")).isEqualTo("Hello World!");
    }

    @Test
    public void anagrams_test() throws Exception {
        List<String> anagrams = Snippets.anagrams("abc");
        assertThat(anagrams)
                .containsOnly("abc", "acb", "bac", "bca", "cab", "cba");
    }

    @Test
    public void byteSize_of_smiley_is_4() throws Exception {
        int length = Snippets.byteSize("\uD83D\uDE00");
        assertThat(length).isEqualTo(4);
    }

    @Test
    public void byteSize_of_hello_world_is_11() throws Exception {
        assertThat(Snippets.byteSize("Hello World")).isEqualTo(11);
    }

    @Test
    public void countVowels_test() throws Exception {
        assertThat(Snippets.countVowels("foobar")).isEqualTo(3);
    }

    @Test
    public void escapeRegex_test() throws Exception {
        assertThat(Snippets.escapeRegExp("(test)")).isEqualTo("\\Q(test)\\E");
    }

    @Test
    public void fromCamelCase_test() throws Exception {
        assertThat(Snippets.fromCamelCase("someJavaProperty", "_"))
                .isEqualTo("some_java_property");
        assertThat(Snippets.fromCamelCase("someDatabaseFieldName", " "))
                .isEqualTo("some database field name");
        assertThat(Snippets.fromCamelCase("someLabelThatNeedsToBeCamelized", "-"))
                .isEqualTo("some-label-that-needs-to-be-camelized");
    }

    @Test
    public void isAbsoluteUrl_test() throws Exception {
        assertThat(Snippets.isAbsoluteUrl("https://google.com")).isTrue();
        assertThat(Snippets.isAbsoluteUrl("ftp://www.myserver.net")).isTrue();
        assertThat(Snippets.isAbsoluteUrl("/foo/bar")).isFalse();
    }

    @Test
    public void isLowerCase_test() throws Exception {
        assertThat(Snippets.isLowerCase("abc")).isTrue();
        assertThat(Snippets.isLowerCase("a3@$")).isTrue();
        assertThat(Snippets.isLowerCase("Ab4")).isFalse();
    }

    @Test
    public void mask_test() throws Exception {
        assertThat(Snippets.mask("1234567890", 4, "*")).isEqualTo("******7890");
        assertThat(Snippets.mask("1234567890", 3, "*")).isEqualTo("*******890");
        assertThat(Snippets.mask("1234567890", -4, "*")).isEqualTo("1234******");
    }

    @Test
    public void palindrome_test() throws Exception {
        assertThat(Snippets.isPalindrome("taco cat")).isTrue();
        assertThat(Snippets.isPalindrome("abc")).isFalse();
    }

    @Test
    public void reverseString_test() throws Exception {
        assertThat(Snippets.reverseString("foobar")).isEqualTo("raboof");
    }

    @Test
    public void sortCharactersInString_test() throws Exception {
        assertThat(Snippets.sortCharactersInString("cabbage")).isEqualTo("aabbceg");
    }

    @Test
    public void splitLines_test() throws Exception {
        assertThat(Snippets.splitLines("This\nis a\nmultiline\nstring.\n"))
                .isEqualTo(new String[]{
                        "This",
                        "is a",
                        "multiline",
                        "string."
                });
    }

    @Test
    public void toCamelCase_test() throws Exception {
        assertThat(Snippets.toCamelCase("some_database_field_name")).isEqualTo("someDatabaseFieldName");
        assertThat(Snippets.toCamelCase("Some label that needs to be camelized")).isEqualTo("someLabelThatNeedsToBeCamelized");
        assertThat(Snippets.toCamelCase("some-java-property")).isEqualTo("someJavaProperty");
        assertThat(Snippets.toCamelCase("some-mixed_string with spaces_underscores-and-hyphens")).isEqualTo("someMixedStringWithSpacesUnderscoresAndHyphens");
    }

    @Test
    public void toKebabCase_test() throws Exception {
        assertThat(Snippets.toKebabCase("camelCase")).isEqualTo("camel-case");
        assertThat(Snippets.toKebabCase("some text")).isEqualTo("some-text");
        assertThat(Snippets.toKebabCase("some-mixed_string With spaces_underscores-and-hyphens")).isEqualTo("some-mixed-string-with-spaces-underscores-and-hyphens");
        assertThat(Snippets.toKebabCase("AllThe-small Things")).isEqualTo("all-the-small-things");
        assertThat(Snippets.toKebabCase("IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingXMLAndHTML")).isEqualTo("i-am-listening-to-fm-while-loading-different-url-on-my-browser-and-also-editing-xml-and-html");
    }

    @Test
    public void toSnakeCase_test() throws Exception {
        assertThat(Snippets.toSnakeCase("camelCase")).isEqualTo("camel_case");
        assertThat(Snippets.toSnakeCase("some text")).isEqualTo("some_text");
        assertThat(Snippets.toSnakeCase("some-mixed_string With spaces_underscores-and-hyphens")).isEqualTo("some_mixed_string_with_spaces_underscores_and_hyphens");
        assertThat(Snippets.toSnakeCase("AllThe-small Things")).isEqualTo("all_the_small_things");
        assertThat(Snippets.toSnakeCase("IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingXMLAndHTML")).isEqualTo("i_am_listening_to_fm_while_loading_different_url_on_my_browser_and_also_editing_xml_and_html");
    }

    @Test
    public void truncateString_test() throws Exception {
        assertThat(Snippets.truncateString("boomerang", 7)).isEqualTo("boom...");
    }

    @Test
    public void words_test() throws Exception {
        assertThat(Snippets.words("I love java!!")).isEqualTo(new String[]{"I", "love", "java"});
        assertThat(Snippets.words("Kotlin, Java & LemonTea")).isEqualTo(new String[]{"Kotlin", "Java", "LemonTea"});
    }

    @Test
    public void randomInts_test() throws Exception {
        assertThat(Snippets.randomInts(5, 100, 200)).hasSize(5);
    }

    @Test
    public void concat_test() throws Exception {
        String[] first = {"a", "b"};
        String[] second = {"c", "d"};
        assertThat(Snippets.concat(first, second))
                .isEqualTo(new String[]{"a", "b", "c", "d"});
    }

    @Test
    public void getCurrentWorkingDirectoryPath_test() throws Exception {
        assertThat(Snippets.getCurrentWorkingDirectoryPath()).isNotBlank();
    }

    @Test
    public void isNumeric_test() throws Exception {
        assertThat(Snippets.isNumeric("123")).isTrue();
        assertThat(Snippets.isNumeric("abc")).isFalse();
        assertThat(Snippets.isNumeric("")).isFalse();
    }

    @Test
    public void findNextPositivePowerOfTwo_test() throws Exception {
        assertThat(Snippets.findNextPositivePowerOfTwo(-1)).isEqualTo(1);
        assertThat(Snippets.findNextPositivePowerOfTwo(3)).isEqualTo(4);
        assertThat(Snippets.findNextPositivePowerOfTwo(31)).isEqualTo(32);
        assertThat(Snippets.findNextPositivePowerOfTwo(32)).isEqualTo(32);
    }

    @Test
    public void isEven_test() throws Exception {
        assertThat(Snippets.isEven(1)).isFalse();
        assertThat(Snippets.isEven(2)).isTrue();
        assertThat(Snippets.isEven(3)).isFalse();
        assertThat(Snippets.isEven(4)).isTrue();
        assertThat(Snippets.isEven(-1)).isFalse();
    }

    @Test
    public void stringToIntegers_test() throws Exception {
        int[] intArray = Snippets.stringToIntegers("1 2 3 4 5");
        assertThat(intArray).isEqualTo(new int[]{1, 2, 3, 4, 5});
    }

    private static class Class1 implements I2, I1, I5 {
        // empty
    }

    private static class Class2 extends Class1 implements I2, I3 {
        // empty
    }

    private interface I1 {
        // empty
    }

    private interface I2 {
        // empty
    }

    private interface I3 extends I4, I5 {
        // empty
    }

    private interface I4 {
        // empty
    }

    private interface I5 extends I6 {
        // empty
    }

    private interface I6 {
        // empty
    }

    @Test
    public void getAllInterfaces_shouldFindAllInterfacesImplementedByAClass() {
        final List<Class<?>> list = Snippets.getAllInterfaces(Class2.class);
        assertThat(list).hasSize(6);
        assertThat(list).containsExactly(I2.class, I3.class, I4.class, I5.class, I6.class, I1.class);
    }

    enum Priority {
        High, Medium, Low
    }

    @Test
    public void getEnumMap_convert_enum_to_map() throws Exception {
        Map<String, Priority> map = Snippets.getEnumMap(Priority.class);
        assertThat(map).hasSize(3);
        assertThat(map)
                .containsOnly(
                        new SimpleEntry<>("High", Priority.High),
                        new SimpleEntry<>("Medium", Priority.Medium),
                        new SimpleEntry<>("Low", Priority.Low)
                );
    }
}