/*
 * Copyright 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package androidx.emoji.text;

import static androidx.emoji.util.Emoji.CHAR_DEFAULT_EMOJI_STYLE;
import static androidx.emoji.util.Emoji.CHAR_DEFAULT_TEXT_STYLE;
import static androidx.emoji.util.Emoji.CHAR_DIGIT;
import static androidx.emoji.util.Emoji.CHAR_FITZPATRICK;
import static androidx.emoji.util.Emoji.CHAR_VS_EMOJI;
import static androidx.emoji.util.Emoji.CHAR_VS_TEXT;
import static androidx.emoji.util.Emoji.DEFAULT_TEXT_STYLE;
import static androidx.emoji.util.Emoji.EMOJI_ASTERISK_KEYCAP;
import static androidx.emoji.util.Emoji.EMOJI_DIGIT_ES;
import static androidx.emoji.util.Emoji.EMOJI_DIGIT_ES_KEYCAP;
import static androidx.emoji.util.Emoji.EMOJI_DIGIT_KEYCAP;
import static androidx.emoji.util.Emoji.EMOJI_FLAG;
import static androidx.emoji.util.Emoji.EMOJI_GENDER;
import static androidx.emoji.util.Emoji.EMOJI_GENDER_WITHOUT_VS;
import static androidx.emoji.util.Emoji.EMOJI_REGIONAL_SYMBOL;
import static androidx.emoji.util.Emoji.EMOJI_SINGLE_CODEPOINT;
import static androidx.emoji.util.Emoji.EMOJI_SKIN_MODIFIER;
import static androidx.emoji.util.Emoji.EMOJI_SKIN_MODIFIER_TYPE_ONE;
import static androidx.emoji.util.Emoji.EMOJI_SKIN_MODIFIER_WITH_VS;
import static androidx.emoji.util.Emoji.EMOJI_UNKNOWN_FLAG;
import static androidx.emoji.util.Emoji.EMOJI_WITH_ZWJ;
import static androidx.emoji.util.EmojiMatcher.hasEmoji;
import static androidx.emoji.util.EmojiMatcher.hasEmojiAt;
import static androidx.emoji.util.EmojiMatcher.hasEmojiCount;
import static androidx.emoji.util.KeyboardUtil.del;

import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.SdkSuppress;
import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
import android.text.Editable;
import android.text.Selection;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.SpannableStringBuilder;
import android.text.SpannedString;
import android.view.KeyEvent;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;

import androidx.emoji.util.Emoji.EmojiMapping;
import androidx.emoji.util.TestString;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@SmallTest
@RunWith(AndroidJUnit4.class)
public class EmojiCompatTest {

    @Before
    public void setup() {
        EmojiCompat.reset(TestConfigBuilder.config());
    }

    @Test(expected = IllegalStateException.class)
    public void testGet_throwsException() {
        EmojiCompat.reset((EmojiCompat) null);
        EmojiCompat.get();
    }

    @Test
    public void testProcess_doesNothing_withNullCharSequence() {
        assertNull(EmojiCompat.get().process(null));
    }

    @Test
    public void testProcess_returnsEmptySpanned_withEmptyString() {
        final CharSequence charSequence = EmojiCompat.get().process("");
        assertNotNull(charSequence);
        assertEquals(0, charSequence.length());
        assertThat(charSequence, not(hasEmoji()));
    }

    @SuppressLint("Range")
    @Test(expected = IllegalArgumentException.class)
    public void testProcess_withNegativeStartValue() {
        EmojiCompat.get().process("a", -1, 1);
    }

    @SuppressLint("Range")
    @Test(expected = IllegalArgumentException.class)
    public void testProcess_withNegativeEndValue() {
        EmojiCompat.get().process("a", 1, -1);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testProcess_withStartSmallerThanEndValue() {
        EmojiCompat.get().process("aa", 1, 0);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testProcess_withStartGreaterThanLength() {
        EmojiCompat.get().process("a", 2, 2);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testProcess_withEndGreaterThanLength() {
        EmojiCompat.get().process("a", 0, 2);
    }

    @Test
    public void testProcessWithStartEnd_withNoOpValues() {
        final Spannable spannable = new SpannableString(new TestString('a')
                .withPrefix().withSuffix().toString());
        // early return check
        assertSame(spannable, EmojiCompat.get().process(spannable, 0, 0));
        assertSame(spannable, EmojiCompat.get().process(spannable, 1, 1));
        assertSame(spannable, EmojiCompat.get().process(spannable, spannable.length(),
                spannable.length()));
    }

    @Test
    public void testProcess_doesNotAddEmojiSpan() {
        final String string = "abc";
        final CharSequence charSequence = EmojiCompat.get().process(string);
        assertNotNull(charSequence);
        assertEquals(string, charSequence.toString());
        assertThat(charSequence, not(hasEmoji()));
    }

    @Test
    @SdkSuppress(maxSdkVersion = 18)
    public void testProcess_returnsSameCharSequence_pre19() {
        assertNull(EmojiCompat.get().process(null));

        CharSequence testString = "abc";
        assertSame(testString, EmojiCompat.get().process(testString));

        testString = new SpannableString("abc");
        assertSame(testString, EmojiCompat.get().process(testString));

        testString = new TestString(new int[]{CHAR_DEFAULT_EMOJI_STYLE}).toString();
        assertSame(testString, EmojiCompat.get().process(testString));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsSingleCodePointEmoji() {
        assertCodePointMatch(EMOJI_SINGLE_CODEPOINT);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsFlagEmoji() {
        assertCodePointMatch(EMOJI_FLAG);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsUnknownFlagEmoji() {
        assertCodePointMatch(EMOJI_UNKNOWN_FLAG);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsRegionalIndicatorSymbol() {
        assertCodePointMatch(EMOJI_REGIONAL_SYMBOL);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsKeyCapEmoji() {
        assertCodePointMatch(EMOJI_DIGIT_KEYCAP);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_doesNotAddEmojiForNumbers() {
        assertCodePointDoesNotMatch(new int[] {CHAR_DIGIT});
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_doesNotAddEmojiForNumbers_1() {
        final TestString string = new TestString(EMOJI_SINGLE_CODEPOINT).append('1', 'f');
        CharSequence charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, hasEmojiCount(1));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsVariantSelectorEmoji() {
        assertCodePointMatch(EMOJI_DIGIT_ES);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_doesNotAddVariantSelectorTextStyle() {
        assertCodePointDoesNotMatch(new int[]{CHAR_DIGIT, CHAR_VS_TEXT});
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsVariantSelectorAndKeyCapEmoji() {
        assertCodePointMatch(EMOJI_DIGIT_ES_KEYCAP);
    }

    @Test
    public void testProcess_doesNotAddEmoji_forVariantBaseWithoutSelector() {
        assertCodePointDoesNotMatch(new int[]{CHAR_DIGIT});
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsAsteriskKeyCapEmoji() {
        assertCodePointMatch(EMOJI_ASTERISK_KEYCAP);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsSkinModifierEmoji() {
        assertCodePointMatch(EMOJI_SKIN_MODIFIER);
        assertCodePointMatch(EMOJI_SKIN_MODIFIER_TYPE_ONE);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsSkinModifierEmoji_withVariantSelector() {
        assertCodePointMatch(EMOJI_SKIN_MODIFIER_WITH_VS);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsSkinModifierEmoji_270c_withVariantSelector() {
        // 0x270c is a Standardized Variant Base, Emoji Modifier Base and also Emoji
        // therefore it is different than i.e. 0x1f3c3. The code actually failed for this test
        // at first.
        assertCodePointMatch(0xF0734, new int[]{0x270C, CHAR_VS_EMOJI, CHAR_FITZPATRICK});
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_defaultStyleDoesNotAddSpan() {
        assertCodePointDoesNotMatch(new int[]{CHAR_DEFAULT_TEXT_STYLE});
        assertCodePointMatch(DEFAULT_TEXT_STYLE);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_defaultEmojiStyle_withTextStyleVs() {
        assertCodePointMatch(EMOJI_SINGLE_CODEPOINT.id(),
                new int[]{CHAR_DEFAULT_EMOJI_STYLE, CHAR_VS_EMOJI});
        assertCodePointDoesNotMatch(new int[]{CHAR_DEFAULT_EMOJI_STYLE, CHAR_VS_TEXT});
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_genderEmoji() {
        assertCodePointMatch(EMOJI_GENDER);
        assertCodePointMatch(EMOJI_GENDER_WITHOUT_VS);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_standardizedVariantEmojiExceptions() {
        final int[][] exceptions = new int[][]{
                {0x2600, 0xF034D},
                {0x2601, 0xF0167},
                {0x260E, 0xF034E},
                {0x261D, 0xF0227},
                {0x263A, 0xF02A6},
                {0x2660, 0xF0350},
                {0x2663, 0xF033F},
                {0x2665, 0xF033B},
                {0x2666, 0xF033E},
                {0x270C, 0xF0079},
                {0x2744, 0xF0342},
                {0x2764, 0xF0362}
        };

        for (int i = 0; i < exceptions.length; i++) {
            final int[] codepoints = new int[]{exceptions[i][0]};
            assertCodePointMatch(exceptions[i][1], codepoints);
        }
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsZwjEmoji() {
        assertCodePointMatch(EMOJI_WITH_ZWJ);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_doesNotAddEmojiForNumbersAfterZwjEmo() {
        TestString string = new TestString(EMOJI_WITH_ZWJ).append(0x20, 0x2B, 0x31)
                .withSuffix().withPrefix();
        CharSequence charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, hasEmojiAt(EMOJI_WITH_ZWJ, string.emojiStartIndex(),
                string.emojiEndIndex() - 3));
        assertThat(charSequence, hasEmojiCount(1));

        string = new TestString(EMOJI_WITH_ZWJ).withSuffix().withPrefix();
        charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, hasEmojiCount(1));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_addsEmojiThatFollowsDigit() {
        TestString string = new TestString(EMOJI_SINGLE_CODEPOINT).prepend('N', '5');
        CharSequence charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, hasEmojiAt(EMOJI_SINGLE_CODEPOINT, string.emojiStartIndex() + 2,
                string.emojiEndIndex()));
        assertThat(charSequence, hasEmojiCount(1));

        string = new TestString(EMOJI_WITH_ZWJ).prepend('N', '5');
        charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, hasEmojiAt(EMOJI_WITH_ZWJ, string.emojiStartIndex() + 2,
                string.emojiEndIndex()));
        assertThat(charSequence, hasEmojiCount(1));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_withAppend() {
        final Editable editable = new SpannableStringBuilder(new TestString('a').withPrefix()
                .withSuffix().toString());
        final int start = 1;
        final int end = start + EMOJI_SINGLE_CODEPOINT.charCount();
        editable.insert(start, new TestString(EMOJI_SINGLE_CODEPOINT).toString());
        EmojiCompat.get().process(editable, start, end);
        assertThat(editable, hasEmojiCount(1));
        assertThat(editable, hasEmojiAt(EMOJI_SINGLE_CODEPOINT, start, end));
    }

    @Test
    public void testProcess_doesNotCreateSpannable_ifNoEmoji() {
        CharSequence processed = EmojiCompat.get().process("abc");
        assertNotNull(processed);
        assertThat(processed, instanceOf(String.class));

        processed = EmojiCompat.get().process(new SpannedString("abc"));
        assertNotNull(processed);
        assertThat(processed, instanceOf(SpannedString.class));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_reprocess() {
        final String string = new TestString(EMOJI_SINGLE_CODEPOINT)
                .append(EMOJI_SINGLE_CODEPOINT)
                .append(EMOJI_SINGLE_CODEPOINT)
                .withPrefix().withSuffix().toString();

        Spannable processed = (Spannable) EmojiCompat.get().process(string);
        assertThat(processed, hasEmojiCount(3));

        final EmojiSpan[] spans = processed.getSpans(0, processed.length(), EmojiSpan.class);
        final Set<EmojiSpan> spanSet = new HashSet<>();
        Collections.addAll(spanSet, spans);

        processed = (Spannable) EmojiCompat.get().process(processed);
        assertThat(processed, hasEmojiCount(3));
        // new spans should be new instances
        final EmojiSpan[] newSpans = processed.getSpans(0, processed.length(), EmojiSpan.class);
        for (int i = 0; i < newSpans.length; i++) {
            assertFalse(spanSet.contains(newSpans[i]));
        }
    }

    @SuppressLint("Range")
    @Test(expected = IllegalArgumentException.class)
    public void testProcess_throwsException_withMaxEmojiSetToNegative() {
        final String original = new TestString(EMOJI_SINGLE_CODEPOINT).toString();

        final CharSequence processed = EmojiCompat.get().process(original, 0, original.length(),
                -1 /*maxEmojiCount*/);

        assertThat(processed, not(hasEmoji()));
    }

    @Test
    public void testProcess_withMaxEmojiSetToZero() {
        final String original = new TestString(EMOJI_SINGLE_CODEPOINT).toString();

        final CharSequence processed = EmojiCompat.get().process(original, 0, original.length(),
                0 /*maxEmojiCount*/);

        assertThat(processed, not(hasEmoji()));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_withMaxEmojiSetToOne() {
        final String original = new TestString(EMOJI_SINGLE_CODEPOINT).toString();

        final CharSequence processed = EmojiCompat.get().process(original, 0, original.length(),
                1 /*maxEmojiCount*/);

        assertThat(processed, hasEmojiCount(1));
        assertThat(processed, hasEmoji(EMOJI_SINGLE_CODEPOINT));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_withMaxEmojiSetToLessThenExistingSpanCount() {
        final String original = new TestString(EMOJI_SINGLE_CODEPOINT)
                .append(EMOJI_SINGLE_CODEPOINT)
                .append(EMOJI_SINGLE_CODEPOINT)
                .toString();

        // add 2 spans
        final CharSequence processed = EmojiCompat.get().process(original, 0, original.length(), 2);

        assertThat(processed, hasEmojiCount(2));

        // use the Spannable with 2 spans, but use maxEmojiCount=1, start from the beginning of
        // last (3rd) emoji
        EmojiCompat.get().process(processed, original.length() - EMOJI_SINGLE_CODEPOINT.charCount(),
                original.length(), 1 /*maxEmojiCount*/);

        // expectation: there are still 2 emojis
        assertThat(processed, hasEmojiCount(2));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_withMaxEmojiSet_withExistingEmojis() {
        // test string with two emoji characters
        final String original = new TestString(EMOJI_SINGLE_CODEPOINT)
                .append(EMOJI_FLAG).toString();

        // process and add 1 EmojiSpan, maxEmojiCount=1
        CharSequence processed = EmojiCompat.get().process(original, 0, original.length(),
                1 /*maxEmojiCount*/);

        // assert that there is a single emoji
        assertThat(processed, hasEmojiCount(1));
        assertThat(processed,
                hasEmojiAt(EMOJI_SINGLE_CODEPOINT, 0, EMOJI_SINGLE_CODEPOINT.charCount()));

        // call process again with the charSequence that already has 1 span
        processed = EmojiCompat.get().process(processed, EMOJI_SINGLE_CODEPOINT.charCount(),
                processed.length(), 1 /*maxEmojiCount*/);

        // assert that there is still a single emoji
        assertThat(processed, hasEmojiCount(1));
        assertThat(processed,
                hasEmojiAt(EMOJI_SINGLE_CODEPOINT, 0, EMOJI_SINGLE_CODEPOINT.charCount()));

        // make the same call, this time with maxEmojiCount=2
        processed = EmojiCompat.get().process(processed, EMOJI_SINGLE_CODEPOINT.charCount(),
                processed.length(), 2 /*maxEmojiCount*/);

        // assert that it contains 2 emojis
        assertThat(processed, hasEmojiCount(2));
        assertThat(processed,
                hasEmojiAt(EMOJI_SINGLE_CODEPOINT, 0, EMOJI_SINGLE_CODEPOINT.charCount()));
        assertThat(processed,
                hasEmojiAt(EMOJI_FLAG, EMOJI_SINGLE_CODEPOINT.charCount(),
                        original.length()));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_withReplaceNonExistent_callsGlyphChecker() {
        final EmojiCompat.Config config = TestConfigBuilder.config().setReplaceAll(true);
        EmojiCompat.reset(config);

        final EmojiProcessor.GlyphChecker glyphChecker = mock(EmojiProcessor.GlyphChecker.class);
        when(glyphChecker.hasGlyph(any(CharSequence.class), anyInt(), anyInt())).thenReturn(true);
        EmojiCompat.get().setGlyphChecker(glyphChecker);

        final String original = new TestString(EMOJI_SINGLE_CODEPOINT).toString();

        CharSequence processed = EmojiCompat.get().process(original, 0, original.length(),
                Integer.MAX_VALUE /*maxEmojiCount*/, EmojiCompat.REPLACE_STRATEGY_NON_EXISTENT);

        // when function overrides config level replaceAll, a call to GlyphChecker is expected.
        verify(glyphChecker, times(1)).hasGlyph(any(CharSequence.class), anyInt(), anyInt());

        // since replaceAll is false, there should be no EmojiSpans
        assertThat(processed, not(hasEmoji()));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_withReplaceDefault_doesNotCallGlyphChecker() {
        final EmojiCompat.Config config = TestConfigBuilder.config().setReplaceAll(true);
        EmojiCompat.reset(config);

        final EmojiProcessor.GlyphChecker glyphChecker = mock(EmojiProcessor.GlyphChecker.class);
        when(glyphChecker.hasGlyph(any(CharSequence.class), anyInt(), anyInt())).thenReturn(true);
        EmojiCompat.get().setGlyphChecker(glyphChecker);

        final String original = new TestString(EMOJI_SINGLE_CODEPOINT).toString();
        // call without replaceAll, config value (true) should be used
        final CharSequence processed = EmojiCompat.get().process(original, 0, original.length(),
                Integer.MAX_VALUE /*maxEmojiCount*/, EmojiCompat.REPLACE_STRATEGY_DEFAULT);

        // replaceAll=true should not call hasGlyph
        verify(glyphChecker, times(0)).hasGlyph(any(CharSequence.class), anyInt(), anyInt());

        assertThat(processed, hasEmojiCount(1));
        assertThat(processed, hasEmoji(EMOJI_SINGLE_CODEPOINT));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testProcess_withSpanned_replaceNonExistent() {
        final EmojiCompat.Config config = TestConfigBuilder.config().setReplaceAll(false);
        EmojiCompat.reset(config);

        final String string = new TestString(EMOJI_SINGLE_CODEPOINT).append(
                EMOJI_SINGLE_CODEPOINT).toString();
        CharSequence processed = EmojiCompat.get().process(string, 0, string.length(),
                Integer.MAX_VALUE, EmojiCompat.REPLACE_STRATEGY_ALL);

        final SpannedString spanned = new SpannedString(processed);
        assertThat(spanned, hasEmojiCount(2));

        // mock GlyphChecker so that we can return true for hasGlyph
        final EmojiProcessor.GlyphChecker glyphChecker = mock(EmojiProcessor.GlyphChecker.class);
        when(glyphChecker.hasGlyph(any(CharSequence.class), anyInt(), anyInt())).thenReturn(true);
        EmojiCompat.get().setGlyphChecker(glyphChecker);

        processed = EmojiCompat.get().process(spanned, 0, spanned.length(),
                Integer.MAX_VALUE, EmojiCompat.REPLACE_STRATEGY_NON_EXISTENT);

        assertThat(processed, not(hasEmoji()));

        // start: 1 char after the first emoji (in the second emoji)
        processed = EmojiCompat.get().process(spanned, EMOJI_SINGLE_CODEPOINT.charCount() + 1,
                spanned.length(), Integer.MAX_VALUE, EmojiCompat.REPLACE_STRATEGY_NON_EXISTENT);

        assertThat(processed, hasEmojiCount(1));
        assertThat(processed, hasEmoji(EMOJI_SINGLE_CODEPOINT));
    }

    @Test(expected = NullPointerException.class)
    public void testHasEmojiGlyph_withNullCharSequence() {
        EmojiCompat.get().hasEmojiGlyph(null);
    }

    @Test(expected = NullPointerException.class)
    public void testHasEmojiGlyph_withMetadataVersion_withNullCharSequence() {
        EmojiCompat.get().hasEmojiGlyph(null, Integer.MAX_VALUE);
    }

    @Test
    @SdkSuppress(maxSdkVersion = 18)
    public void testHasEmojiGlyph_pre19() {
        String sequence = new TestString(new int[]{CHAR_DEFAULT_EMOJI_STYLE}).toString();
        assertFalse(EmojiCompat.get().hasEmojiGlyph(sequence));
    }

    @Test
    @SdkSuppress(maxSdkVersion = 18)
    public void testHasEmojiGlyph_withMetaVersion_pre19() {
        String sequence = new TestString(new int[]{CHAR_DEFAULT_EMOJI_STYLE}).toString();
        assertFalse(EmojiCompat.get().hasEmojiGlyph(sequence, Integer.MAX_VALUE));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testHasEmojiGlyph_returnsTrueForExistingEmoji() {
        final String sequence = new TestString(EMOJI_FLAG).toString();
        assertTrue(EmojiCompat.get().hasEmojiGlyph(sequence));
    }

    @Test
    public void testHasGlyph_returnsFalseForNonExistentEmoji() {
        final String sequence = new TestString(EMOJI_FLAG).append(0x1111).toString();
        assertFalse(EmojiCompat.get().hasEmojiGlyph(sequence));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testHashEmojiGlyph_withDefaultEmojiStyles() {
        String sequence = new TestString(new int[]{CHAR_DEFAULT_EMOJI_STYLE}).toString();
        assertTrue(EmojiCompat.get().hasEmojiGlyph(sequence));

        sequence = new TestString(new int[]{CHAR_DEFAULT_EMOJI_STYLE, CHAR_VS_EMOJI}).toString();
        assertTrue(EmojiCompat.get().hasEmojiGlyph(sequence));

        sequence = new TestString(new int[]{CHAR_DEFAULT_EMOJI_STYLE, CHAR_VS_TEXT}).toString();
        assertFalse(EmojiCompat.get().hasEmojiGlyph(sequence));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testHashEmojiGlyph_withMetadataVersion() {
        final String sequence = new TestString(EMOJI_SINGLE_CODEPOINT).toString();
        assertFalse(EmojiCompat.get().hasEmojiGlyph(sequence, 0));
        assertTrue(EmojiCompat.get().hasEmojiGlyph(sequence, Integer.MAX_VALUE));
    }

    @Test
    @SdkSuppress(maxSdkVersion = 18)
    public void testGetLoadState_returnsSuccess_pre19() {
        assertEquals(EmojiCompat.get().getLoadState(), EmojiCompat.LOAD_STATE_SUCCEEDED);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testGetLoadState_returnsSuccessIfLoadSuccess() throws InterruptedException {
        final TestConfigBuilder.WaitingDataLoader
                metadataLoader = new TestConfigBuilder.WaitingDataLoader(true /*success*/);
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig(metadataLoader);
        EmojiCompat.reset(config);

        assertEquals(EmojiCompat.get().getLoadState(), EmojiCompat.LOAD_STATE_LOADING);

        metadataLoader.getLoaderLatch().countDown();
        metadataLoader.getTestLatch().await();
        InstrumentationRegistry.getInstrumentation().waitForIdleSync();

        assertEquals(EmojiCompat.get().getLoadState(), EmojiCompat.LOAD_STATE_SUCCEEDED);
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testGetLoadState_returnsFailIfLoadFail() throws InterruptedException {
        final TestConfigBuilder.WaitingDataLoader
                metadataLoader = new TestConfigBuilder.WaitingDataLoader(false/*fail*/);
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig(metadataLoader);
        EmojiCompat.reset(config);

        assertEquals(EmojiCompat.get().getLoadState(), EmojiCompat.LOAD_STATE_LOADING);

        metadataLoader.getLoaderLatch().countDown();
        metadataLoader.getTestLatch().await();
        InstrumentationRegistry.getInstrumentation().waitForIdleSync();

        assertEquals(EmojiCompat.get().getLoadState(), EmojiCompat.LOAD_STATE_FAILED);
    }

    @Test
    public void testUpdateEditorInfoAttrs_doesNotSetKeyIfNotInitialized() {
        final EditorInfo editorInfo = new EditorInfo();
        editorInfo.extras = new Bundle();

        final TestConfigBuilder.WaitingDataLoader
                metadataLoader = new TestConfigBuilder.WaitingDataLoader();
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig(metadataLoader);
        EmojiCompat.reset(config);

        EmojiCompat.get().updateEditorInfoAttrs(editorInfo);

        final Bundle extras = editorInfo.extras;
        assertFalse(extras.containsKey(EmojiCompat.EDITOR_INFO_METAVERSION_KEY));
        assertFalse(extras.containsKey(EmojiCompat.EDITOR_INFO_REPLACE_ALL_KEY));

        metadataLoader.getLoaderLatch().countDown();
    }

    @Test(expected = IllegalStateException.class)
    public void testLoad_throwsException_whenLoadStrategyDefault() {
        final EmojiCompat.MetadataRepoLoader loader = mock(EmojiCompat.MetadataRepoLoader.class);
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig(loader);
        EmojiCompat.reset(config);

        EmojiCompat.get().load();
    }

    @Test
    @SdkSuppress(maxSdkVersion = 18)
    public void testLoad_pre19() {
        final EmojiCompat.MetadataRepoLoader loader = spy(new TestConfigBuilder
                .TestEmojiDataLoader());
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig(loader)
                .setMetadataLoadStrategy(EmojiCompat.LOAD_STRATEGY_MANUAL);

        EmojiCompat.reset(config);

        verify(loader, never()).load(any(EmojiCompat.MetadataRepoLoaderCallback.class));
        assertEquals(EmojiCompat.LOAD_STATE_DEFAULT, EmojiCompat.get().getLoadState());

        EmojiCompat.get().load();
        assertEquals(EmojiCompat.LOAD_STATE_SUCCEEDED, EmojiCompat.get().getLoadState());
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testLoad_startsLoading() {
        final EmojiCompat.MetadataRepoLoader loader = spy(new TestConfigBuilder
                .TestEmojiDataLoader());
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig(loader)
                .setMetadataLoadStrategy(EmojiCompat.LOAD_STRATEGY_MANUAL);

        EmojiCompat.reset(config);

        verify(loader, never()).load(any(EmojiCompat.MetadataRepoLoaderCallback.class));
        assertEquals(EmojiCompat.LOAD_STATE_DEFAULT, EmojiCompat.get().getLoadState());

        EmojiCompat.get().load();
        verify(loader, times(1)).load(any(EmojiCompat.MetadataRepoLoaderCallback.class));
        assertEquals(EmojiCompat.LOAD_STATE_SUCCEEDED, EmojiCompat.get().getLoadState());
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testLoad_onceSuccessDoesNotStartLoading() {
        final EmojiCompat.MetadataRepoLoader loader = spy(new TestConfigBuilder
                .TestEmojiDataLoader());
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig(loader)
                .setMetadataLoadStrategy(EmojiCompat.LOAD_STRATEGY_MANUAL);

        EmojiCompat.reset(config);

        EmojiCompat.get().load();
        verify(loader, times(1)).load(any(EmojiCompat.MetadataRepoLoaderCallback.class));
        assertEquals(EmojiCompat.LOAD_STATE_SUCCEEDED, EmojiCompat.get().getLoadState());

        reset(loader);
        EmojiCompat.get().load();
        verify(loader, never()).load(any(EmojiCompat.MetadataRepoLoaderCallback.class));
        assertEquals(EmojiCompat.LOAD_STATE_SUCCEEDED, EmojiCompat.get().getLoadState());
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testLoad_onceLoadingDoesNotStartLoading() throws InterruptedException {
        final TestConfigBuilder.WaitingDataLoader loader = spy(
                new TestConfigBuilder.WaitingDataLoader(true /*success*/));
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig(loader)
                .setMetadataLoadStrategy(EmojiCompat.LOAD_STRATEGY_MANUAL);

        EmojiCompat.reset(config);

        verify(loader, never()).load(any(EmojiCompat.MetadataRepoLoaderCallback.class));

        EmojiCompat.get().load();
        verify(loader, times(1)).load(any(EmojiCompat.MetadataRepoLoaderCallback.class));
        assertEquals(EmojiCompat.get().getLoadState(), EmojiCompat.LOAD_STATE_LOADING);

        reset(loader);

        EmojiCompat.get().load();
        verify(loader, never()).load(any(EmojiCompat.MetadataRepoLoaderCallback.class));

        loader.getLoaderLatch().countDown();
        loader.getTestLatch().await();

        assertEquals(EmojiCompat.get().getLoadState(), EmojiCompat.LOAD_STATE_SUCCEEDED);
    }

    @Test
    @SdkSuppress(maxSdkVersion = 18)
    public void testGetAssetSignature() {
        final String signature = EmojiCompat.get().getAssetSignature();
        assertTrue(signature.isEmpty());
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testGetAssetSignature_api19() {
        final String signature = EmojiCompat.get().getAssetSignature();
        assertNotNull(signature);
        assertFalse(signature.isEmpty());
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testUpdateEditorInfoAttrs_setsKeysIfInitialized() {
        final EditorInfo editorInfo = new EditorInfo();
        editorInfo.extras = new Bundle();
        EmojiCompat.Config config = new TestConfigBuilder.TestConfig().setReplaceAll(false);
        EmojiCompat.reset(config);
        EmojiCompat.get().updateEditorInfoAttrs(editorInfo);

        final Bundle extras = editorInfo.extras;
        assertTrue(extras.containsKey(EmojiCompat.EDITOR_INFO_METAVERSION_KEY));
        assertTrue(extras.getInt(EmojiCompat.EDITOR_INFO_METAVERSION_KEY) > 0);
        assertTrue(extras.containsKey(EmojiCompat.EDITOR_INFO_REPLACE_ALL_KEY));
        assertFalse(extras.getBoolean(EmojiCompat.EDITOR_INFO_REPLACE_ALL_KEY));

        config = new TestConfigBuilder.TestConfig().setReplaceAll(true);
        EmojiCompat.reset(config);
        EmojiCompat.get().updateEditorInfoAttrs(editorInfo);

        assertTrue(extras.containsKey(EmojiCompat.EDITOR_INFO_REPLACE_ALL_KEY));
        assertTrue(extras.getBoolean(EmojiCompat.EDITOR_INFO_REPLACE_ALL_KEY));
    }

    @Test
    @SdkSuppress(maxSdkVersion = 18)
    public void testHandleDeleteSurroundingText_pre19() {
        final TestString testString = new TestString(EMOJI_SINGLE_CODEPOINT);
        final InputConnection inputConnection = mock(InputConnection.class);
        final Editable editable = spy(new SpannableStringBuilder(testString.toString()));

        Selection.setSelection(editable, testString.emojiEndIndex());

        reset(editable);
        reset(inputConnection);
        verifyNoMoreInteractions(editable);
        verifyNoMoreInteractions(inputConnection);

        // try backwards delete 1 character
        assertFalse(EmojiCompat.handleDeleteSurroundingText(inputConnection, editable,
                1 /*beforeLength*/, 0 /*afterLength*/, false /*inCodePoints*/));
    }

    @Test
    @SdkSuppress(maxSdkVersion = 18)
    public void testOnKeyDown_pre19() {
        final TestString testString = new TestString(EMOJI_SINGLE_CODEPOINT);
        final Editable editable = spy(new SpannableStringBuilder(testString.toString()));
        Selection.setSelection(editable, testString.emojiEndIndex());
        final KeyEvent event = del();

        reset(editable);
        verifyNoMoreInteractions(editable);

        assertFalse(EmojiCompat.handleOnKeyDown(editable, event.getKeyCode(), event));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testUseEmojiAsDefaultStyle_whenEmojiInTheMiddle() {
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig().setReplaceAll(true);
        EmojiCompat.reset(config);
        String s = new TestString(0x0061, CHAR_DEFAULT_TEXT_STYLE, 0x0062).toString();
        // no span should be added as the emoji is text style presented by default
        assertThat(EmojiCompat.get().process(s), not(hasEmoji()));
        // a span should be added when we use the emoji style presentation as default
        EmojiCompat.reset(config.setUseEmojiAsDefaultStyle(true));
        assertThat(EmojiCompat.get().process(s), hasEmojiAt(DEFAULT_TEXT_STYLE, 1, 2));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testUseEmojiAsDefaultStyle_whenEmojiAtTheEnd() {
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig().setReplaceAll(true);
        EmojiCompat.reset(config);
        String s = new TestString(0x0061, CHAR_DEFAULT_TEXT_STYLE).toString();
        // no span should be added as the emoji is text style presented by default
        assertThat(EmojiCompat.get().process(s), not(hasEmoji()));
        // a span should be added when we use the emoji style presentation as default
        EmojiCompat.reset(config.setUseEmojiAsDefaultStyle(true));
        assertThat(EmojiCompat.get().process(s), hasEmojiAt(DEFAULT_TEXT_STYLE, 1, 2));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testUseEmojiAsDefaultStyle_noEmojisAdded_whenMarkedAsException() {
        final String s = new TestString(CHAR_DEFAULT_TEXT_STYLE).toString();
        final List<Integer> exceptions =
                Arrays.asList(CHAR_DEFAULT_TEXT_STYLE + 1, CHAR_DEFAULT_TEXT_STYLE);
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig().setReplaceAll(true)
                .setUseEmojiAsDefaultStyle(true, exceptions);
        EmojiCompat.reset(config);
        // no span should be added as the text style codepoint is marked as exception
        assertThat(EmojiCompat.get().process(s), not(hasEmoji()));
    }

    @Test
    @SdkSuppress(minSdkVersion = 19)
    public void testUseEmojiAsDefaultStyle_emojisAdded_whenNotMarkedAsException() {
        final String s = new TestString(CHAR_DEFAULT_TEXT_STYLE).toString();
        final List<Integer> exceptions =
                Arrays.asList(CHAR_DEFAULT_TEXT_STYLE - 1, CHAR_DEFAULT_TEXT_STYLE + 1);
        final EmojiCompat.Config config = new TestConfigBuilder.TestConfig().setReplaceAll(true)
                .setUseEmojiAsDefaultStyle(true, exceptions);
        EmojiCompat.reset(config);
        // a span should be added as the codepoint is not included in the set of exceptions
        assertThat(EmojiCompat.get().process(s), hasEmojiAt(DEFAULT_TEXT_STYLE, 0, 1));
    }

    private void assertCodePointMatch(EmojiMapping emoji) {
        assertCodePointMatch(emoji.id(), emoji.codepoints());
    }

    private void assertCodePointMatch(int id, int[] codepoints) {
        TestString string = new TestString(codepoints);
        CharSequence charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, hasEmojiAt(id, string.emojiStartIndex(), string.emojiEndIndex()));

        // case where Emoji is in the middle of string
        string = new TestString(codepoints).withPrefix().withSuffix();
        charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, hasEmojiAt(id, string.emojiStartIndex(), string.emojiEndIndex()));

        // case where Emoji is at the end of string
        string = new TestString(codepoints).withSuffix();
        charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, hasEmojiAt(id, string.emojiStartIndex(), string.emojiEndIndex()));
    }

    private void assertCodePointDoesNotMatch(int[] codepoints) {
        TestString string = new TestString(codepoints);
        CharSequence charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, not(hasEmoji()));

        string = new TestString(codepoints).withSuffix().withPrefix();
        charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, not(hasEmoji()));

        string = new TestString(codepoints).withPrefix();
        charSequence = EmojiCompat.get().process(string.toString());
        assertThat(charSequence, not(hasEmoji()));
    }
}