Fix issues with Mexican phone number formatting.

Fixes #9317

app/src/main/java/org/thoughtcrime/securesms/contacts/sync/DirectoryHelperV1.java

@@ -34,6 +34,7 @@ import org.thoughtcrime.securesms.logging.Log;
 import org.thoughtcrime.securesms.notifications.MessageNotifier;
 import org.thoughtcrime.securesms.notifications.NotificationChannels;
 import org.thoughtcrime.securesms.permissions.Permissions;
+import org.thoughtcrime.securesms.phonenumbers.PhoneNumberFormatter;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.recipients.RecipientId;
 import org.thoughtcrime.securesms.recipients.RecipientUtil;
@@ -41,7 +42,6 @@ import org.thoughtcrime.securesms.service.IncomingMessageObserver;
 import org.thoughtcrime.securesms.sms.IncomingJoinedMessage;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
 import org.thoughtcrime.securesms.util.Util;
-import org.thoughtcrime.securesms.util.concurrent.SignalExecutors;
 import org.whispersystems.libsignal.util.guava.Optional;
 import org.whispersystems.signalservice.api.SignalServiceAccountManager;
 import org.whispersystems.signalservice.api.SignalServiceMessagePipe;
@@ -53,13 +53,14 @@ import org.whispersystems.signalservice.api.push.exceptions.NotFoundException;
 
 import java.io.IOException;
 import java.util.Calendar;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
 
 class DirectoryHelperV1 {
 
@@ -90,25 +91,14 @@ class DirectoryHelperV1 {
     }
 
     RecipientDatabase recipientDatabase                       = DatabaseFactory.getRecipientDatabase(context);
-    Stream<String>    eligibleRecipientDatabaseContactNumbers = Stream.of(recipientDatabase.getAllPhoneNumbers());
+    Set<String>       allRecipientNumbers                     = recipientDatabase.getAllPhoneNumbers();
+    Stream<String>    eligibleRecipientDatabaseContactNumbers = Stream.of(allRecipientNumbers);
     Stream<String>    eligibleSystemDatabaseContactNumbers    = Stream.of(ContactAccessor.getInstance().getAllContactsWithNumbers(context));
     Set<String>       eligibleContactNumbers                  = Stream.concat(eligibleRecipientDatabaseContactNumbers, eligibleSystemDatabaseContactNumbers).collect(Collectors.toSet());
+    Set<String>       storedNumbers                           = Stream.of(allRecipientNumbers).collect(Collectors.toSet());
+    DirectoryResult   directoryResult                         = getDirectoryResult(context, accountManager, recipientDatabase, storedNumbers, eligibleContactNumbers);
 
-    try {
+    return directoryResult.getNewlyActiveRecipients();
-      Future<DirectoryResult> legacyRequest = getLegacyDirectoryResult(context, accountManager, recipientDatabase, eligibleContactNumbers);
-      DirectoryResult         legacyResult  = legacyRequest.get();
-
-      return legacyResult.getNewlyActiveRecipients();
-    } catch (InterruptedException e) {
-      throw new IOException("[Batch] Operation was interrupted.", e);
-    } catch (ExecutionException e) {
-      if (e.getCause() instanceof IOException) {
-        throw (IOException) e.getCause();
-      } else {
-        Log.e(TAG, "[Batch] Experienced an unexpected exception.", e);
-        throw new AssertionError(e);
-      }
-    }
   }
 
   @WorkerThread
@@ -126,24 +116,10 @@ class DirectoryHelperV1 {
       return isRegistered ? RegisteredState.REGISTERED : RegisteredState.NOT_REGISTERED;
     }
 
-    SignalServiceAccountManager accountManager    = ApplicationDependencies.getSignalServiceAccountManager();
+    return getRegisteredState(context, ApplicationDependencies.getSignalServiceAccountManager(), recipientDatabase, recipient);
-    Future<RegisteredState>     legacyRequest     = getLegacyRegisteredState(context, accountManager, recipientDatabase, recipient);
-
-    try {
-      return legacyRequest.get();
-    } catch (InterruptedException e) {
-      throw new IOException("[Singular] Operation was interrupted.", e);
-    } catch (ExecutionException e) {
-      if (e.getCause() instanceof IOException) {
-        throw (IOException) e.getCause();
-      } else {
-        Log.e(TAG, "[Singular] Experienced an unexpected exception.", e);
-        throw new AssertionError(e);
-      }
-    }
   }
 
-  private static void updateContactsDatabase(@NonNull Context context, @NonNull List<RecipientId> activeIds, boolean removeMissing) {
+  private static void updateContactsDatabase(@NonNull Context context, @NonNull List<RecipientId> activeIds, boolean removeMissing, Map<String, String> rewrites) {
     Optional<AccountHolder> account = getOrCreateAccount(context);
 
     if (account.isPresent()) {
@@ -161,7 +137,9 @@ class DirectoryHelperV1 {
             String number = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.NUMBER));
 
             if (isValidContactNumber(number)) {
-              RecipientId recipientId     = Recipient.externalContact(context, number).getId();
+              String      formattedNumber = PhoneNumberFormatter.get(context).format(number);
+              String      realNumber      = Util.getFirstNonEmpty(rewrites.get(formattedNumber), formattedNumber);
+              RecipientId recipientId     = Recipient.externalContact(context, realNumber).getId();
               String      displayName     = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
               String      contactPhotoUri = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.PHOTO_URI));
               String      contactLabel    = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.LABEL));
@@ -169,7 +147,6 @@ class DirectoryHelperV1 {
               Uri         contactUri      = ContactsContract.Contacts.getLookupUri(cursor.getLong(cursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone._ID)),
                                                                                    cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.LOOKUP_KEY)));
 
-
               handle.setSystemContactInfo(recipientId, displayName, contactPhotoUri, contactLabel, phoneType, contactUri.toString());
             }
           }
@@ -244,23 +221,37 @@ class DirectoryHelperV1 {
     }
   }
 
-  private static Future<DirectoryResult> getLegacyDirectoryResult(@NonNull Context context,
+  private static DirectoryResult getDirectoryResult(@NonNull Context context,
                                                     @NonNull SignalServiceAccountManager accountManager,
                                                     @NonNull RecipientDatabase recipientDatabase,
+                                                    @NonNull Set<String> locallyStoredNumbers,
                                                     @NonNull Set<String> eligibleContactNumbers)
+      throws IOException
   {
-    return SignalExecutors.UNBOUNDED.submit(() -> {
+    FuzzyPhoneNumberHelper.InputResult  inputResult   = FuzzyPhoneNumberHelper.generateInput(eligibleContactNumbers, locallyStoredNumbers);
-      List<ContactTokenDetails> activeTokens = accountManager.getContacts(eligibleContactNumbers);
+    List<ContactTokenDetails>           activeTokens  = accountManager.getContacts(inputResult.getNumbers());
+    Set<String>                         activeNumbers = Stream.of(activeTokens).map(ContactTokenDetails::getNumber).collect(Collectors.toSet());
+    FuzzyPhoneNumberHelper.OutputResult outputResult  = FuzzyPhoneNumberHelper.generateOutput(activeNumbers, inputResult);
+
+    if (inputResult.getFuzzies().size() > 0) {
+      Log.i(TAG, "[getDirectoryResult] Got a fuzzy number result.");
+    }
+
+    if (outputResult.getRewrites().size() > 0) {
+      Log.i(TAG, "[getDirectoryResult] Need to rewrite some numbers.");
+    }
+
+    recipientDatabase.updatePhoneNumbers(outputResult.getRewrites());
 
-      if (activeTokens != null) {
     List<RecipientId> activeIds   = new LinkedList<>();
     List<RecipientId> inactiveIds = new LinkedList<>();
 
-        Set<String> inactiveContactNumbers = new HashSet<>(eligibleContactNumbers);
+    Set<String> inactiveContactNumbers = new HashSet<>(inputResult.getNumbers());
+    inactiveContactNumbers.removeAll(outputResult.getRewrites().keySet());
 
-        for (ContactTokenDetails activeToken : activeTokens) {
+    for (String number : outputResult.getNumbers()) {
-          activeIds.add(recipientDatabase.getOrInsertFromE164(activeToken.getNumber()));
+      activeIds.add(recipientDatabase.getOrInsertFromE164(number));
-          inactiveContactNumbers.remove(activeToken.getNumber());
+      inactiveContactNumbers.remove(number);
     }
 
     for (String inactiveContactNumber : inactiveContactNumbers) {
@@ -275,7 +266,7 @@ class DirectoryHelperV1 {
                                                .toList();
 
     recipientDatabase.setRegistered(activeIds, inactiveIds);
-        updateContactsDatabase(context, activeIds, true);
+    updateContactsDatabase(context, activeIds, true, outputResult.getRewrites());
 
     Set<String> activeContactNumbers = Stream.of(activeIds).map(Recipient::resolved).filter(Recipient::hasSmsAddress).map(Recipient::requireSmsAddress).collect(Collectors.toSet());
 
@@ -286,25 +277,50 @@ class DirectoryHelperV1 {
       return new DirectoryResult(activeContactNumbers);
     }
   }
-      return new DirectoryResult(Collections.emptySet(), Collections.emptyList());
-   });
-  }
 
-  private static Future<RegisteredState> getLegacyRegisteredState(@NonNull Context                     context,
+  private static RegisteredState getRegisteredState(@NonNull Context                     context,
                                                     @NonNull SignalServiceAccountManager accountManager,
                                                     @NonNull RecipientDatabase           recipientDatabase,
                                                     @NonNull Recipient                   recipient)
+      throws IOException
   {
-    return SignalExecutors.UNBOUNDED.submit(() -> {
     boolean                       activeUser    = recipient.resolve().getRegistered() == RegisteredState.REGISTERED;
     boolean                       systemContact = recipient.isSystemContact();
-      Optional<ContactTokenDetails> details       = recipient.hasE164() ? accountManager.getContact(recipient.requireE164()) : Optional.absent();
+    Optional<ContactTokenDetails> details       = Optional.absent();
+    Map<String, String>           rewrites      = new HashMap<>();
+
+    if (recipient.hasE164()) {
+      FuzzyPhoneNumberHelper.InputResult inputResult = FuzzyPhoneNumberHelper.generateInput(Collections.singletonList(recipient.requireE164()), recipientDatabase.getAllPhoneNumbers());
+
+      if (inputResult.getNumbers().size() > 1) {
+        Log.i(TAG, "[getRegisteredState] Got a fuzzy number result.");
+
+        List<ContactTokenDetails>           detailList   = accountManager.getContacts(inputResult.getNumbers());
+        Collection<String>                  registered   = Stream.of(detailList).map(ContactTokenDetails::getNumber).collect(Collectors.toSet());
+        FuzzyPhoneNumberHelper.OutputResult outputResult = FuzzyPhoneNumberHelper.generateOutput(registered, inputResult);
+        String                              finalNumber  = recipient.requireE164();
+        ContactTokenDetails                 detail       = new ContactTokenDetails();
+
+        if (outputResult.getRewrites().size() > 0 && outputResult.getRewrites().containsKey(finalNumber)) {
+          Log.i(TAG, "[getRegisteredState] Need to rewrite a number.");
+          finalNumber = outputResult.getRewrites().get(finalNumber);
+          rewrites    = outputResult.getRewrites();
+        }
+
+        detail.setNumber(finalNumber);
+        details = Optional.of(detail);
+
+        recipientDatabase.updatePhoneNumbers(outputResult.getRewrites());
+      } else {
+        details = accountManager.getContact(recipient.requireE164());
+      }
+    }
 
     if (details.isPresent()) {
       recipientDatabase.setRegistered(recipient.getId(), RegisteredState.REGISTERED);
 
       if (Permissions.hasAll(context, Manifest.permission.WRITE_CONTACTS)) {
-          updateContactsDatabase(context, Util.asList(recipient.getId()), false);
+        updateContactsDatabase(context, Util.asList(recipient.getId()), false, rewrites);
       }
 
       if (!activeUser && TextSecurePreferences.isMultiDevice(context)) {
@@ -320,7 +336,6 @@ class DirectoryHelperV1 {
       recipientDatabase.setRegistered(recipient.getId(), RegisteredState.NOT_REGISTERED);
       return RegisteredState.NOT_REGISTERED;
     }
-    });
   }
 
   private static boolean isValidContactNumber(@Nullable String number) {
@@ -396,5 +411,4 @@ class DirectoryHelperV1 {
     }
 
   }
-
 }

app/src/main/java/org/thoughtcrime/securesms/contacts/sync/FuzzyPhoneNumberHelper.java

@@ -0,0 +1,130 @@
+package org.thoughtcrime.securesms.contacts.sync;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A helper class to match a single number with multiple possible registered numbers. An example is
+ * Mexican phone numbers, which recently removed a '1' after their country code. The idea is that
+ * when doing contact intersection, we can try both with and without the '1' and make a decision
+ * based on the results.
+ */
+class FuzzyPhoneNumberHelper {
+
+  /**
+   * This should be run on the list of eligible numbers for contact intersection so that we can
+   * create an updated list that has potentially more "fuzzy" number matches in it.
+   */
+  static @NonNull InputResult generateInput(@NonNull Collection<String> testNumbers, @NonNull Collection<String> storedNumbers) {
+    Set<String>         allNumbers = new HashSet<>(testNumbers);
+    Map<String, String> fuzzies    = new HashMap<>();
+
+    for (String number : testNumbers) {
+      if (mx(number)) {
+        String add1   = mxAdd1(number);
+        String strip1 = mxStrip1(number);
+
+        if (mxMissing1(number) && !storedNumbers.contains(add1) && allNumbers.add(add1)) {
+          fuzzies.put(number, add1);
+        } else if (mxHas1(number) && !storedNumbers.contains(strip1) && allNumbers.add(strip1)) {
+          fuzzies.put(number, strip1);
+        }
+      }
+    }
+
+    return new InputResult(allNumbers, fuzzies);
+  }
+
+  /**
+   * This should be run on the list of numbers we find out are registered with the server. Based on
+   * these results and our initial input set, we can decide if we need to rewrite which number we
+   * have stored locally.
+   */
+  static @NonNull OutputResult generateOutput(@NonNull Collection<String> registeredNumbers, @NonNull InputResult inputResult) {
+    Set<String>         allNumbers = new HashSet<>(registeredNumbers);
+    Map<String, String> rewrites   = new HashMap<>();
+
+    for (Map.Entry<String, String> entry : inputResult.getFuzzies().entrySet()) {
+      if (registeredNumbers.contains(entry.getKey()) && registeredNumbers.contains(entry.getValue())) {
+        if (mxHas1(entry.getKey())) {
+          rewrites.put(entry.getKey(), entry.getValue());
+          allNumbers.remove(entry.getKey());
+        } else {
+          allNumbers.remove(entry.getValue());
+        }
+      } else if (registeredNumbers.contains(entry.getValue())) {
+        rewrites.put(entry.getKey(), entry.getValue());
+        allNumbers.remove(entry.getKey());
+      }
+    }
+
+    return new OutputResult(allNumbers, rewrites);
+  }
+
+
+  private static boolean mx(@NonNull String number) {
+    return number.startsWith("+52") && (number.length() == 13 || number.length() == 14);
+  }
+
+  private static boolean mxHas1(@NonNull String number) {
+    return number.startsWith("+521") && number.length() == 14;
+  }
+
+  private static boolean mxMissing1(@NonNull String number) {
+    return number.startsWith("+52") && !number.startsWith("+521") && number.length() == 13;
+  }
+
+  private static @NonNull String mxStrip1(@NonNull String number) {
+    return mxHas1(number) ? "+52" + number.substring("+521".length())
+                          : number;
+  }
+
+  private static @NonNull String mxAdd1(@NonNull String number) {
+    return mxMissing1(number) ? "+521" + number.substring("+52".length())
+                              : number;
+  }
+
+
+  public static class InputResult {
+    private final Set<String>         numbers;
+    private final Map<String, String> fuzzies;
+
+    @VisibleForTesting
+    InputResult(@NonNull Set<String> numbers, @NonNull Map<String, String> fuzzies) {
+      this.numbers = numbers;
+      this.fuzzies = fuzzies;
+    }
+
+    public @NonNull Set<String> getNumbers() {
+      return numbers;
+    }
+
+    public @NonNull Map<String, String> getFuzzies() {
+      return fuzzies;
+    }
+  }
+
+  public static class OutputResult {
+    private final Set<String>         numbers;
+    private final Map<String, String> rewrites;
+
+    private OutputResult(@NonNull Set<String> numbers, @NonNull Map<String, String> rewrites) {
+      this.numbers  = numbers;
+      this.rewrites = rewrites;
+    }
+
+    public @NonNull Set<String> getNumbers() {
+      return numbers;
+    }
+
+    public @NonNull Map<String, String> getRewrites() {
+      return rewrites;
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/database/RecipientDatabase.java

@@ -456,6 +456,28 @@ public class RecipientDatabase extends Database {
     }
   }
 
+  public void updatePhoneNumbers(@NonNull Map<String, String> mapping) {
+    if (mapping.isEmpty()) return;
+
+    SQLiteDatabase db = databaseHelper.getWritableDatabase();
+
+    db.beginTransaction();
+    try {
+      String query = PHONE + " = ?";
+
+      for (Map.Entry<String, String> entry : mapping.entrySet()) {
+        ContentValues values = new ContentValues();
+        values.put(PHONE, entry.getValue());
+
+        db.updateWithOnConflict(TABLE_NAME, values, query, new String[] { entry.getKey() }, SQLiteDatabase.CONFLICT_IGNORE);
+      }
+
+      db.setTransactionSuccessful();
+    } finally {
+      db.endTransaction();
+    }
+  }
+
   private @NonNull RecipientId getByStorageKeyOrThrow(byte[] storageKey) {
     SQLiteDatabase db    = databaseHelper.getReadableDatabase();
     String         query = STORAGE_SERVICE_KEY + " = ?";

app/src/main/java/org/thoughtcrime/securesms/recipients/Recipient.java

@@ -214,11 +214,18 @@ public class Recipient {
    */
   @WorkerThread
   public static @NonNull Recipient externalContact(@NonNull Context context, @NonNull String identifier) {
+    RecipientDatabase db = DatabaseFactory.getRecipientDatabase(context);
+    RecipientId       id = null;
+
     if (UuidUtil.isUuid(identifier)) {
       throw new UuidRecipientError();
+    } else if (NumberUtil.isValidEmail(identifier)) {
+      id = db.getOrInsertFromEmail(identifier);
     } else {
-      return external(context, identifier);
+      id = db.getOrInsertFromE164(identifier);
     }
+
+    return Recipient.resolved(id);
   }
 
   /**

app/src/test/java/org/thoughtcrime/securesms/contacts/sync/FuzzyPhoneNumberHelperTest.java

@@ -0,0 +1,164 @@
+package org.thoughtcrime.securesms.contacts.sync;
+
+import org.junit.Test;
+import org.thoughtcrime.securesms.contacts.sync.FuzzyPhoneNumberHelper.InputResult;
+import org.thoughtcrime.securesms.contacts.sync.FuzzyPhoneNumberHelper.OutputResult;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import edu.emory.mathcs.backport.java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class FuzzyPhoneNumberHelperTest {
+
+  private static final String US_A = "+16108675309";
+  private static final String US_B = "+16101234567";
+
+  private static final String MX_A   = "+525512345678";
+  private static final String MX_A_1 = "+5215512345678";
+
+  @Test
+  public void generateInput_noMxNumbers() {
+    InputResult result = FuzzyPhoneNumberHelper.generateInput(setOf(US_A, US_B), setOf(US_A, US_B));
+
+    assertEquals(2, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(US_A, US_B)));
+    assertTrue(result.getFuzzies().isEmpty());
+  }
+
+  @Test
+  public void generateInput_mxWith1_without1NotStored() {
+    InputResult result = FuzzyPhoneNumberHelper.generateInput(setOf(US_A, MX_A_1), setOf(US_A, MX_A_1));
+
+    assertEquals(3, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(US_A, MX_A_1, MX_A)));
+    assertEquals(MX_A, result.getFuzzies().get(MX_A_1));
+  }
+
+  @Test
+  public void generateInput_mxWith1_without1AlreadyStored() {
+    InputResult result = FuzzyPhoneNumberHelper.generateInput(setOf(US_A, MX_A_1), setOf(US_A, MX_A_1, MX_A));
+
+    assertEquals(2, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(US_A, MX_A_1)));
+    assertTrue(result.getFuzzies().isEmpty());
+  }
+
+  @Test
+  public void generateInput_mxWithout1_with1NotStored() {
+    InputResult result = FuzzyPhoneNumberHelper.generateInput(setOf(US_A, MX_A), setOf(US_A, MX_A));
+
+    assertEquals(3, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(US_A, MX_A_1, MX_A)));
+    assertEquals(MX_A_1, result.getFuzzies().get(MX_A));
+  }
+
+  @Test
+  public void generateInput_mxWithout1_with1AlreadyStored() {
+    InputResult result = FuzzyPhoneNumberHelper.generateInput(setOf(US_A, MX_A), setOf(US_A, MX_A_1, MX_A));
+
+    assertEquals(2, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(US_A, MX_A)));
+    assertTrue(result.getFuzzies().isEmpty());
+  }
+
+  @Test
+  public void generateInput_mxWithAndWithout1_neitherStored() {
+    InputResult result = FuzzyPhoneNumberHelper.generateInput(setOf(US_A, MX_A_1, MX_A), setOf(US_A));
+
+    assertEquals(3, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(US_A, MX_A_1, MX_A)));
+    assertTrue(result.getFuzzies().isEmpty());
+  }
+
+  @Test
+  public void generateInput_mxWithAndWithout1_with1AlreadyStored() {
+    InputResult result = FuzzyPhoneNumberHelper.generateInput(setOf(US_A, MX_A_1, MX_A), setOf(US_A, MX_A_1));
+
+    assertEquals(3, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(US_A, MX_A_1, MX_A)));
+    assertTrue(result.getFuzzies().isEmpty());
+  }
+
+  @Test
+  public void generateInput_mxWithAndWithout1_without1AlreadyStored() {
+    InputResult result = FuzzyPhoneNumberHelper.generateInput(setOf(US_A, MX_A_1, MX_A), setOf(US_A, MX_A));
+
+    assertEquals(3, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(US_A, MX_A_1, MX_A)));
+    assertTrue(result.getFuzzies().isEmpty());
+  }
+
+  @Test
+  public void generateOutput_noMxNumbers() {
+    OutputResult result = FuzzyPhoneNumberHelper.generateOutput(setOf(US_A, US_B), new InputResult(setOf(US_A, US_B), Collections.emptyMap()));
+
+    assertEquals(2, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(US_A, US_B)));
+    assertTrue(result.getRewrites().isEmpty());
+  }
+
+  @Test
+  public void generateOutput_bothMatch_no1To1() {
+    OutputResult result = FuzzyPhoneNumberHelper.generateOutput(setOf(MX_A, MX_A_1), new InputResult(setOf(MX_A, MX_A_1), Collections.singletonMap(MX_A, MX_A_1)));
+
+    assertEquals(1, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(MX_A)));
+    assertTrue(result.getRewrites().isEmpty());
+  }
+
+  @Test
+  public void generateOutput_bothMatch_1toNo1() {
+    OutputResult result = FuzzyPhoneNumberHelper.generateOutput(setOf(MX_A, MX_A_1), new InputResult(setOf(MX_A, MX_A_1), Collections.singletonMap(MX_A_1, MX_A)));
+
+    assertEquals(1, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(MX_A)));
+    assertEquals(MX_A, result.getRewrites().get(MX_A_1));
+  }
+
+  @Test
+  public void generateOutput_no1Match_no1To1() {
+    OutputResult result = FuzzyPhoneNumberHelper.generateOutput(setOf(MX_A), new InputResult(setOf(MX_A, MX_A_1), Collections.singletonMap(MX_A, MX_A_1)));
+
+    assertEquals(1, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(MX_A)));
+    assertTrue(result.getRewrites().isEmpty());
+  }
+
+  @Test
+  public void generateOutput_no1Match_1ToNo1() {
+    OutputResult result = FuzzyPhoneNumberHelper.generateOutput(setOf(MX_A), new InputResult(setOf(MX_A, MX_A_1), Collections.singletonMap(MX_A_1, MX_A)));
+
+    assertEquals(1, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(MX_A)));
+    assertEquals(MX_A, result.getRewrites().get(MX_A_1));
+  }
+
+  @Test
+  public void generateOutput_1Match_1ToNo1() {
+    OutputResult result = FuzzyPhoneNumberHelper.generateOutput(setOf(MX_A_1), new InputResult(setOf(MX_A, MX_A_1), Collections.singletonMap(MX_A_1, MX_A)));
+
+    assertEquals(1, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(MX_A_1)));
+    assertTrue(result.getRewrites().isEmpty());
+  }
+
+  @Test
+  public void generateOutput_1Match_no1To1() {
+    OutputResult result = FuzzyPhoneNumberHelper.generateOutput(setOf(MX_A_1), new InputResult(setOf(MX_A, MX_A_1), Collections.singletonMap(MX_A, MX_A_1)));
+
+    assertEquals(1, result.getNumbers().size());
+    assertTrue(result.getNumbers().containsAll(setOf(MX_A_1)));
+    assertEquals(MX_A_1, result.getRewrites().get(MX_A));
+  }
+
+
+  private static <E> Set<E> setOf(E... values) {
+    //noinspection unchecked
+    return new HashSet<>(Arrays.asList(values));
+  }
+}