react-native-notify-kit 10.5.0 → 10.6.0

package/android/src/test/java/app/notifee/core/ReceiverServicePendingIntentIdentityTest.java

@@ -0,0 +1,303 @@
+package app.notifee.core;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import android.app.PendingIntent;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowPendingIntent;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 34)
+public class ReceiverServicePendingIntentIdentityTest {
+
+  @Before
+  public void setUp() {
+    ContextHolder.setApplicationContext(RuntimeEnvironment.getApplication());
+    ShadowPendingIntent.reset();
+  }
+
+  @After
+  public void tearDown() {
+    ShadowPendingIntent.reset();
+  }
+
+  @Test
+  public void differentNotifications_doNotCollide() {
+    PendingIntent notificationA =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification-a", null, "done", "payload-a");
+    PendingIntent notificationB =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification-b", null, "done", "payload-b");
+
+    assertDistinctAndroidIdentity(notificationA, notificationB);
+    assertEquals("payload-a", payloadVersion(savedIntent(notificationA)));
+    assertEquals("payload-b", payloadVersion(savedIntent(notificationB)));
+  }
+
+  @Test
+  public void deleteIntents_forDifferentNotificationsAreDistinct() {
+    PendingIntent deleteA =
+        createReceiverIntent(ReceiverService.DELETE_INTENT, "notification-a", "tag", null, null);
+    PendingIntent deleteB =
+        createReceiverIntent(ReceiverService.DELETE_INTENT, "notification-b", "tag", null, null);
+
+    assertDistinctAndroidIdentity(deleteA, deleteB);
+  }
+
+  @Test
+  public void actionPressIntents_forDifferentNotificationsAreDistinct() {
+    PendingIntent actionA =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification-a", "tag", "done", null);
+    PendingIntent actionB =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification-b", "tag", "done", null);
+
+    assertDistinctAndroidIdentity(actionA, actionB);
+  }
+
+  @Test
+  public void actionPressIntents_forDifferentActionsOnSameNotificationAreDistinct() {
+    PendingIntent done =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification", "tag", "done", null);
+    PendingIntent snooze =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification", "tag", "snooze", null);
+
+    assertDistinctAndroidIdentity(done, snooze);
+  }
+
+  @Test
+  public void sameInteractionReposted_reusesTokenAndUpdatesExtras() {
+    PendingIntent original =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification", "tag", "done", "v1");
+    Intent originalIntent = new Intent(Shadows.shadowOf(original).getSavedIntent());
+    assertEquals("v1", payloadVersion(originalIntent));
+
+    PendingIntent reposted =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification", "tag", "done", "v2");
+
+    assertEquals(original, reposted);
+    Intent updatedIntent = Shadows.shadowOf(reposted).getSavedIntent();
+    assertTrue(originalIntent.filterEquals(updatedIntent));
+    assertEquals(originalIntent.getData(), updatedIntent.getData());
+    assertEquals("v2", payloadVersion(updatedIntent));
+  }
+
+  @Test
+  public void sameNotificationId_withDifferentTagsIsDistinct() {
+    PendingIntent tagA =
+        createReceiverIntent(ReceiverService.ACTION_PRESS_INTENT, "same-id", "tag-a", "done", null);
+    PendingIntent tagB =
+        createReceiverIntent(ReceiverService.ACTION_PRESS_INTENT, "same-id", "tag-b", "done", null);
+
+    assertDistinctAndroidIdentity(tagA, tagB);
+  }
+
+  @Test
+  public void deletePressAndActionPress_areDistinctInteractionTypes() {
+    PendingIntent delete =
+        createReceiverIntent(ReceiverService.DELETE_INTENT, "notification", "tag", null, null);
+    PendingIntent press =
+        createReceiverIntent(ReceiverService.PRESS_INTENT, "notification", "tag", "done", null);
+    PendingIntent actionPress =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification", "tag", "done", null);
+
+    assertDistinctAndroidIdentity(delete, press);
+    assertDistinctAndroidIdentity(delete, actionPress);
+    assertDistinctAndroidIdentity(press, actionPress);
+  }
+
+  @Test
+  public void delimiterHeavyValues_doNotCreateAmbiguousIdentity() {
+    String delimiterHeavyValue = "/?&=%# spazio 雪";
+    String tagA = "tag:" + delimiterHeavyValue + ":part";
+    String notificationIdA = "item";
+    String tagB = "tag:" + delimiterHeavyValue;
+    String notificationIdB = "part:item";
+
+    assertEquals(
+        naiveColonIdentity(tagA, notificationIdA, "done"),
+        naiveColonIdentity(tagB, notificationIdB, "done"));
+
+    PendingIntent interactionA =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, notificationIdA, tagA, "done", null);
+    PendingIntent interactionB =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, notificationIdB, tagB, "done", null);
+
+    assertDistinctAndroidIdentity(interactionA, interactionB);
+
+    Uri dataA = savedIntent(interactionA).getData();
+    Uri dataB = savedIntent(interactionB).getData();
+    assertNotNull(dataA);
+    assertNotNull(dataB);
+    assertEquals(tagA, dataA.getQueryParameter("notificationTag"));
+    assertEquals(notificationIdA, dataA.getQueryParameter("notificationId"));
+    assertEquals(tagB, dataB.getQueryParameter("notificationTag"));
+    assertEquals(notificationIdB, dataB.getQueryParameter("notificationId"));
+  }
+
+  @Test
+  public void nullEmptyAndLiteralNullTags_areDistinct() {
+    PendingIntent nullTag =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification", null, "done", null);
+    PendingIntent emptyTag =
+        createReceiverIntent(ReceiverService.ACTION_PRESS_INTENT, "notification", "", "done", null);
+    PendingIntent literalNullTag =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification", "null", "done", null);
+
+    assertDistinctAndroidIdentity(nullTag, emptyTag);
+    assertDistinctAndroidIdentity(nullTag, literalNullTag);
+    assertDistinctAndroidIdentity(emptyTag, literalNullTag);
+
+    Uri nullData = savedIntent(nullTag).getData();
+    Uri emptyData = savedIntent(emptyTag).getData();
+    Uri literalNullData = savedIntent(literalNullTag).getData();
+    assertNotNull(nullData);
+    assertNotNull(emptyData);
+    assertNotNull(literalNullData);
+    assertEquals("0", nullData.getQueryParameter("notificationTagPresent"));
+    assertNull(nullData.getQueryParameter("notificationTag"));
+    assertEquals("1", emptyData.getQueryParameter("notificationTagPresent"));
+    assertEquals("", emptyData.getQueryParameter("notificationTag"));
+    assertEquals("1", literalNullData.getQueryParameter("notificationTagPresent"));
+    assertEquals("null", literalNullData.getQueryParameter("notificationTag"));
+  }
+
+  @Test
+  public void requestCode_isStableAndDoesNotDependOnConstructionOrder() {
+    PendingIntent originalA =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification-a", "tag", "done", "v1");
+    PendingIntent notificationB =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification-b", "tag", "done", null);
+    PendingIntent repostedA =
+        createReceiverIntent(
+            ReceiverService.ACTION_PRESS_INTENT, "notification-a", "tag", "done", "v2");
+
+    ShadowPendingIntent shadowA = Shadows.shadowOf(originalA);
+    ShadowPendingIntent shadowB = Shadows.shadowOf(notificationB);
+    ShadowPendingIntent shadowRepostedA = Shadows.shadowOf(repostedA);
+
+    assertEquals(shadowA.getRequestCode(), shadowB.getRequestCode());
+    assertEquals(shadowA.getRequestCode(), shadowRepostedA.getRequestCode());
+    assertNotEquals(originalA, notificationB);
+    assertEquals(originalA, repostedA);
+    assertEquals("v2", payloadVersion(shadowA.getSavedIntent()));
+    assertTrue((shadowA.getFlags() & PendingIntent.FLAG_UPDATE_CURRENT) != 0);
+    assertTrue((shadowA.getFlags() & PendingIntent.FLAG_MUTABLE) != 0);
+  }
+
+  private static PendingIntent createReceiverIntent(
+      String action,
+      String notificationId,
+      String notificationTag,
+      String pressActionId,
+      String payloadVersion) {
+    Bundle notification = new Bundle();
+    notification.putString("id", notificationId);
+
+    Bundle android = new Bundle();
+    if (notificationTag != null) {
+      android.putString("tag", notificationTag);
+    }
+    notification.putBundle("android", android);
+
+    if (payloadVersion != null) {
+      Bundle data = new Bundle();
+      data.putString("version", payloadVersion);
+      notification.putBundle("data", data);
+    }
+
+    if (pressActionId == null) {
+      return ReceiverService.createIntent(action, new String[] {"notification"}, notification);
+    }
+
+    Bundle pressAction = new Bundle();
+    pressAction.putString("id", pressActionId);
+    return ReceiverService.createIntent(
+        action, new String[] {"notification", "pressAction"}, notification, pressAction);
+  }
+
+  private static void assertDistinctAndroidIdentity(PendingIntent first, PendingIntent second) {
+    ShadowPendingIntent firstShadow = Shadows.shadowOf(first);
+    ShadowPendingIntent secondShadow = Shadows.shadowOf(second);
+    Intent firstIntent = firstShadow.getSavedIntent();
+    Intent secondIntent = secondShadow.getSavedIntent();
+
+    assertNotEquals(first, second);
+    assertTrue(firstShadow.isService());
+    assertTrue(secondShadow.isService());
+    assertEquals(firstShadow.getRequestCode(), secondShadow.getRequestCode());
+    assertNotNull(firstIntent.getData());
+    assertNotNull(secondIntent.getData());
+    assertFalse(firstIntent.filterEquals(secondIntent));
+    assertNotEquals(firstIntent.getData(), secondIntent.getData());
+  }
+
+  private static Intent savedIntent(PendingIntent pendingIntent) {
+    Intent intent = Shadows.shadowOf(pendingIntent).getSavedIntent();
+    assertNotNull(intent);
+    return intent;
+  }
+
+  private static String payloadVersion(Intent intent) {
+    Bundle notification = intent.getBundleExtra("notification");
+    assertNotNull(notification);
+    Bundle data = notification.getBundle("data");
+    assertNotNull(data);
+    return data.getString("version");
+  }
+
+  private static String naiveColonIdentity(
+      String notificationTag, String notificationId, String pressActionId) {
+    return ReceiverService.ACTION_PRESS_INTENT
+        + ":"
+        + notificationTag
+        + ":"
+        + notificationId
+        + ":"
+        + pressActionId;
+  }
+}

package/android/src/test/java/app/notifee/core/model/NotificationAndroidStyleModelPersonFailureTest.java

@@ -0,0 +1,337 @@
+package app.notifee.core.model;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mockStatic;
+
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.Person;
+import androidx.core.graphics.drawable.IconCompat;
+import app.notifee.core.utility.ResourceUtils;
+import com.google.common.util.concurrent.ForwardingListeningExecutorService;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
+import org.robolectric.RobolectricTestRunner;
+
+/**
+ * Regression tests for the messaging style's person lookups.
+ *
+ * <p>The person task has a shorter icon timeout, but scheduling delays, process suspension, or
+ * other stalls can still exhaust the outer timed wait. {@link PersonFutureFailureExecutor} models
+ * outer-wait outcomes deterministically; it does not reproduce or identify their runtime cause.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class NotificationAndroidStyleModelPersonFailureTest {
+
+  private static final int STYLE_TYPE_MESSAGING = 3;
+  private static final int USER_PERSON_INDEX = 0;
+  private static final int MESSAGE_PERSON_INDEX = 1;
+  private static final String USER_ICON_URL = "https://example.invalid/user.png";
+
+  @Test
+  public void messagingStyle_userPersonTimesOut_keepsEverythingButTheIcon() throws Exception {
+    NotificationAndroidStyleModel model =
+        NotificationAndroidStyleModel.fromBundle(messagingStyleBundle(USER_ICON_URL, null));
+
+    NotificationCompat.Style resolvedStyle =
+        model.getStyleTask(timesOutAt(USER_PERSON_INDEX)).get();
+
+    assertTrue(resolvedStyle instanceof NotificationCompat.MessagingStyle);
+    NotificationCompat.MessagingStyle style = (NotificationCompat.MessagingStyle) resolvedStyle;
+    Person user = style.getUser();
+    assertPersonFields(user, "Me", "viewer-1", "mailto:me@example.com");
+    assertNull(user.getIcon());
+  }
+
+  @Test
+  public void messagingStyle_messagePersonTimesOut_keepsEveryFieldButTheIcon() throws Exception {
+    NotificationAndroidStyleModel model =
+        NotificationAndroidStyleModel.fromBundle(messagingStyleBundle(null, USER_ICON_URL));
+
+    NotificationCompat.Style resolvedStyle =
+        model.getStyleTask(timesOutAt(MESSAGE_PERSON_INDEX)).get();
+
+    assertTrue(resolvedStyle instanceof NotificationCompat.MessagingStyle);
+    NotificationCompat.MessagingStyle style = (NotificationCompat.MessagingStyle) resolvedStyle;
+    List<NotificationCompat.MessagingStyle.Message> messages = style.getMessages();
+    assertEquals(1, messages.size());
+    assertEquals("hello", messages.get(0).getText().toString());
+    Person messagePerson = messages.get(0).getPerson();
+    assertPersonFields(messagePerson, "Alice", "alice-1", "mailto:a@example.com");
+    assertNull(messagePerson.getIcon());
+  }
+
+  @Test
+  public void messagingStyle_iconFutureFails_keepsEverythingButTheIcon() throws Exception {
+    IllegalStateException iconFailure = new IllegalStateException("simulated icon load failure");
+    NotificationAndroidStyleModel model =
+        NotificationAndroidStyleModel.fromBundle(messagingStyleBundle(USER_ICON_URL, null));
+
+    try (MockedStatic<ResourceUtils> resourceUtils = mockStatic(ResourceUtils.class)) {
+      resourceUtils
+          .when(() -> ResourceUtils.getImageBitmapFromUrl(USER_ICON_URL))
+          .thenReturn(Futures.immediateFailedFuture(iconFailure));
+
+      NotificationCompat.MessagingStyle style =
+          (NotificationCompat.MessagingStyle)
+              model.getStyleTask(MoreExecutors.newDirectExecutorService()).get();
+
+      Person user = style.getUser();
+      assertPersonFields(user, "Me", "viewer-1", "mailto:me@example.com");
+      assertNull(user.getIcon());
+    }
+  }
+
+  @Test
+  public void messagingStyle_unexpectedPersonFailure_propagates() {
+    IllegalStateException unexpectedFailure =
+        new IllegalStateException("simulated unexpected person task failure");
+    NotificationAndroidStyleModel model =
+        NotificationAndroidStyleModel.fromBundle(messagingStyleBundle());
+
+    ExecutionException failure =
+        assertThrows(
+            ExecutionException.class,
+            () ->
+                model
+                    .getStyleTask(failsUnexpectedlyAt(USER_PERSON_INDEX, unexpectedFailure))
+                    .get());
+
+    assertTrue(failure.getCause() instanceof ExecutionException);
+    assertSame(unexpectedFailure, failure.getCause().getCause());
+  }
+
+  @Test
+  public void messagingStyle_outerPersonWaitIsInterrupted_propagates() {
+    InterruptedException interruption = new InterruptedException("simulated outer interruption");
+    NotificationAndroidStyleModel model =
+        NotificationAndroidStyleModel.fromBundle(messagingStyleBundle());
+
+    ExecutionException failure =
+        assertThrows(
+            ExecutionException.class,
+            () -> model.getStyleTask(interruptedAt(USER_PERSON_INDEX, interruption)).get());
+
+    assertSame(interruption, failure.getCause());
+  }
+
+  @Test
+  public void messagingStyle_personIconResolves_mapsEveryBundleField() throws Exception {
+    Bitmap iconBitmap = Bitmap.createBitmap(2, 2, Bitmap.Config.ARGB_8888);
+    NotificationAndroidStyleModel model =
+        NotificationAndroidStyleModel.fromBundle(messagingStyleBundle(USER_ICON_URL, null));
+
+    try (MockedStatic<ResourceUtils> resourceUtils = mockStatic(ResourceUtils.class)) {
+      resourceUtils
+          .when(() -> ResourceUtils.getImageBitmapFromUrl(USER_ICON_URL))
+          .thenReturn(Futures.immediateFuture(iconBitmap));
+
+      NotificationCompat.MessagingStyle style =
+          (NotificationCompat.MessagingStyle)
+              model.getStyleTask(MoreExecutors.newDirectExecutorService()).get();
+
+      Person user = style.getUser();
+      assertPersonFields(user, "Me", "viewer-1", "mailto:me@example.com");
+      assertNotNull(user.getIcon());
+      assertEquals(IconCompat.TYPE_ADAPTIVE_BITMAP, user.getIcon().getType());
+      assertEquals("Room", style.getConversationTitle().toString());
+      assertTrue(style.isGroupConversation());
+      assertEquals("Alice", style.getMessages().get(0).getPerson().getName());
+    } finally {
+      iconBitmap.recycle();
+    }
+  }
+
+  private static Bundle messagingStyleBundle() {
+    return messagingStyleBundle(null, null);
+  }
+
+  private static Bundle messagingStyleBundle(String userIcon, String messageIcon) {
+    Bundle messagePerson = personBundle("Alice", "alice-1");
+    if (messageIcon != null) {
+      messagePerson.putString("icon", messageIcon);
+    }
+
+    Bundle message = new Bundle();
+    message.putString("text", "hello");
+    message.putLong("timestamp", 1_700_000_000_000L);
+    message.putBundle("person", messagePerson);
+
+    ArrayList<Bundle> messages = new ArrayList<>();
+    messages.add(message);
+
+    Bundle user = personBundle("Me", "viewer-1");
+    if (userIcon != null) {
+      user.putString("icon", userIcon);
+    }
+
+    Bundle styleBundle = new Bundle();
+    styleBundle.putInt("type", STYLE_TYPE_MESSAGING);
+    styleBundle.putString("title", "Room");
+    styleBundle.putBoolean("group", true);
+    styleBundle.putBundle("person", user);
+    styleBundle.putParcelableArrayList("messages", messages);
+    return styleBundle;
+  }
+
+  private static Bundle personBundle(String name, String id) {
+    Bundle person = new Bundle();
+    person.putString("name", name);
+    person.putString("id", id);
+    person.putBoolean("important", true);
+    person.putBoolean("bot", true);
+    person.putString("uri", name.equals("Me") ? "mailto:me@example.com" : "mailto:a@example.com");
+    return person;
+  }
+
+  private static void assertPersonFields(Person person, String name, String key, String uri) {
+    assertEquals(name, person.getName());
+    assertEquals(key, person.getKey());
+    assertEquals(uri, person.getUri());
+    assertTrue(person.isImportant());
+    assertTrue(person.isBot());
+  }
+
+  private interface PersonFailure {
+    void raise() throws InterruptedException, ExecutionException, TimeoutException;
+  }
+
+  private static PersonFutureFailureExecutor timesOutAt(int personIndex) {
+    return new PersonFutureFailureExecutor(
+        personIndex,
+        () -> {
+          throw new TimeoutException("simulated person task stall");
+        });
+  }
+
+  private static PersonFutureFailureExecutor interruptedAt(
+      int personIndex, InterruptedException interruption) {
+    return new PersonFutureFailureExecutor(
+        personIndex,
+        () -> {
+          throw interruption;
+        });
+  }
+
+  private static PersonFutureFailureExecutor failsUnexpectedlyAt(
+      int personIndex, RuntimeException failure) {
+    return new PersonFutureFailureExecutor(
+        personIndex,
+        () -> {
+          throw new ExecutionException(failure);
+        });
+  }
+
+  /**
+   * Runs the style task and non-target person tasks inline, but makes one indexed person future
+   * fail when its outer timed wait is invoked.
+   */
+  private static final class PersonFutureFailureExecutor
+      extends ForwardingListeningExecutorService {
+    private final ListeningExecutorService delegate = MoreExecutors.newDirectExecutorService();
+    private final int failingPersonIndex;
+    private final PersonFailure failure;
+    private boolean styleTaskSubmitted = false;
+    private int personTaskCount = 0;
+
+    PersonFutureFailureExecutor(int failingPersonIndex, PersonFailure failure) {
+      this.failingPersonIndex = failingPersonIndex;
+      this.failure = failure;
+    }
+
+    @Override
+    protected ListeningExecutorService delegate() {
+      return delegate;
+    }
+
+    @Override
+    public <T> ListenableFuture<T> submit(Callable<T> task) {
+      if (!styleTaskSubmitted) {
+        styleTaskSubmitted = true;
+        return runImmediately(task);
+      }
+
+      if (personTaskCount++ == failingPersonIndex) {
+        return failingFuture();
+      }
+
+      return runImmediately(task);
+    }
+
+    private static <T> ListenableFuture<T> runImmediately(Callable<T> task) {
+      try {
+        return Futures.immediateFuture(task.call());
+      } catch (Exception e) {
+        return Futures.immediateFailedFuture(e);
+      }
+    }
+
+    private <T> ListenableFuture<T> failingFuture() {
+      return new ListenableFuture<T>() {
+        @Override
+        public void addListener(Runnable listener, Executor executor) {}
+
+        @Override
+        public boolean cancel(boolean mayInterruptIfRunning) {
+          return false;
+        }
+
+        @Override
+        public boolean isCancelled() {
+          return false;
+        }
+
+        @Override
+        public boolean isDone() {
+          return false;
+        }
+
+        @Override
+        public T get() {
+          throw new UnsupportedOperationException("the style awaits persons with a timeout");
+        }
+
+        @Override
+        public T get(long timeout, TimeUnit unit)
+            throws InterruptedException, ExecutionException, TimeoutException {
+          failure.raise();
+          throw new AssertionError("unreachable");
+        }
+      };
+    }
+  }
+}