Fix matching issue with placeholders

deeplinkdispatch-base/src/main/java/com/airbnb/deeplinkdispatch/base/MatchIndex.java

@@ -410,7 +410,12 @@ private CompareResult compareComponentParam(
                               + new String(placeholderValue), false);
             } else return null;
           }
-          if (byteArray[valueStartPos + j] != valueToMatch[k]) {
+          // We do the comparison from the back. If the value in the index (before the placeholder
+          // starts) is longer than valueToMatch we need to abort.
+          // e.g. template value: "{something}longer" and valueToMatch: "onger". As we compare
+          // from back all the chars match but the template value is longer so as soon as we reach
+          // the end of valueToMatch before we reach the placeholder end char we need to abort.
+          if (k < 0 || byteArray[valueStartPos + j] != valueToMatch[k]) {
             return null;
           }
         }

deeplinkdispatch-base/src/test/java/com/airbnb/deeplinkdispatch/MatchIndexTests.kt

@@ -9,6 +9,7 @@ class MatchIndexTests {
     private val entryWithAllowedValues = DeepLinkEntry.MethodDeeplinkEntry("http{scheme(|s)}://www.example.{tld(de|fr)}/somePath1/differentPath2", MatchIndexTests::class.java.name, "someMethod10")
     private val entryWithAllowedValueOnlyOneElement = DeepLinkEntry.MethodDeeplinkEntry("http{scheme(s)}://www.justtesting.com/somePath", MatchIndexTests::class.java.name, "someMethod10")
     private val entryWithEmptyAllowedValue = DeepLinkEntry.MethodDeeplinkEntry("http{scheme()}://www.anothertest.com/somePath", MatchIndexTests::class.java.name, "someMethod10")
+    private val entryWithAllowedValueAndLongerValueThan = DeepLinkEntry.MethodDeeplinkEntry("scheme://{some_value(allowed|values)}somethinglonger/one/{param}/three", MatchIndexTests::class.java.name, "someMethod10")
 
     private val allowedValuesPlaceholderNames = setOf("scheme", "tld")
 
@@ -23,9 +24,23 @@ class MatchIndexTests {
         DeepLinkEntry.MethodDeeplinkEntry("http://example.com/path1/someOtherPathElement2", MatchIndexTests::class.java.name, "someMethod6"),
         DeepLinkEntry.MethodDeeplinkEntry("http://example.com/", MatchIndexTests::class.java.name, "someMethod8"),
         entryWithAllowedValues,
-        entryWithAllowedValueOnlyOneElement
+        entryWithAllowedValueOnlyOneElement,
+        entryWithAllowedValueAndLongerValueThan
     ).sortedBy { it.uriTemplate }
 
+    @Test
+    fun testMatchWithPlaceholderThatEndsInSegmentWithLongerMatch() {
+        // This is testing a condition where an URL segment (in this case the host) has a placeholder with allowed values
+        // in the template and is matching (from the back) to what is in the to be matched URL, where the entry in the template
+        // is matching but longer (and thus not matching) before the placeholder starts (from the back).
+        // In this case the host is it like this:
+        // template host: {some_value(allowed|values)}somethinglonger
+        // to match host:                                      longer
+        val deepLinkUri = DeepLinkUri.parse("scheme://longer/one/param/three")
+        val matchEntry = testRegistry(testEntries).idxMatch(deepLinkUri, emptyMap())
+        assertThat(matchEntry).isNull()
+    }
+
     @Test
     fun testGetAllEntries() {
         val allEntries = testRegistry(testEntries).getAllEntries().sortedBy { it.uriTemplate }