| /* |
| * Copyright 2022 Google LLC |
| * |
| * 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 com.google.android.libraries.mobiledatadownload.internal.util; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static org.junit.Assert.assertThrows; |
| |
| import com.google.android.libraries.mobiledatadownload.internal.util.FuturesUtil.SequentialFutureChain; |
| import com.google.common.base.Function; |
| import com.google.common.util.concurrent.Futures; |
| import com.google.common.util.concurrent.ListenableFuture; |
| import com.google.common.util.concurrent.MoreExecutors; |
| import java.io.IOException; |
| import java.util.concurrent.ExecutionException; |
| import java.util.concurrent.Executor; |
| import java.util.concurrent.Executors; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| @RunWith(JUnit4.class) |
| public final class FuturesUtilTest { |
| |
| private static final Executor SEQUENTIAL_EXECUTOR = |
| MoreExecutors.newSequentialExecutor(Executors.newCachedThreadPool()); |
| |
| private FuturesUtil futuresUtil; |
| |
| @Before |
| public void setUp() { |
| futuresUtil = new FuturesUtil(SEQUENTIAL_EXECUTOR); |
| } |
| |
| @Test |
| public void chain_preservesOrder() throws ExecutionException, InterruptedException { |
| SequentialFutureChain<String> chain = futuresUtil.newSequentialChain(""); |
| for (int i = 0; i < 10; i++) { |
| // Variables captured in lambdas must be effectively final. |
| int index = i; |
| chain.chainAsync(str -> Futures.immediateFuture(str + index)); |
| } |
| String result = chain.start().get(); |
| assertThat(result).isEqualTo("0123456789"); |
| } |
| |
| @Test |
| public void chain_mixedOperationTypes_preservesOrder() |
| throws ExecutionException, InterruptedException { |
| String result = |
| futuresUtil |
| .newSequentialChain("") |
| .chainAsync(str -> Futures.immediateFuture(str + 0)) |
| .chain(str -> str + 1) |
| .chainAsync(str -> Futures.immediateFuture(str + 2)) |
| .chain(str -> str + 3) |
| .chain(str -> str + 4) |
| .chainAsync(str -> Futures.immediateFuture(str + 5)) |
| .start() |
| .get(); |
| assertThat(result).isEqualTo("012345"); |
| } |
| |
| @Test |
| public void chain_preservesOrder_sideEffects() throws ExecutionException, InterruptedException { |
| StringBuilder sb = new StringBuilder(""); |
| SequentialFutureChain<Void> chain = futuresUtil.newSequentialChain(); |
| for (int i = 0; i < 10; i++) { |
| chain.chainAsync(appendIntAsync(sb, i)); |
| } |
| chain.start().get(); |
| assertThat(sb.toString()).isEqualTo("0123456789"); |
| } |
| |
| @Test |
| public void chain_mixedOperationTypes_preservesOrder_sideEffects() |
| throws ExecutionException, InterruptedException { |
| StringBuilder sb = new StringBuilder(""); |
| futuresUtil |
| .newSequentialChain() |
| .chain(appendIntDirect(sb, 0)) |
| .chainAsync(appendIntAsync(sb, 1)) |
| .chain(appendIntDirect(sb, 2)) |
| .chainAsync(appendIntAsync(sb, 3)) |
| .chainAsync(appendIntAsync(sb, 4)) |
| .chain(appendIntDirect(sb, 5)) |
| .start() |
| .get(); |
| assertThat(sb.toString()).isEqualTo("012345"); |
| } |
| |
| @Test |
| public void chain_noOp_preservesInitialState() throws ExecutionException, InterruptedException { |
| StringBuilder sb = new StringBuilder("Initial state."); |
| SequentialFutureChain<Void> chain = futuresUtil.newSequentialChain(); |
| for (int i = 0; i < 0; i++) { |
| chain.chainAsync(appendIntAsync(sb, i)); |
| } |
| chain.start().get(); |
| assertThat(sb.toString()).isEqualTo("Initial state."); |
| } |
| |
| @Test |
| public void chain_propagatesFailure() { |
| StringBuilder sb = new StringBuilder(""); |
| SequentialFutureChain<Void> chain = futuresUtil.newSequentialChain(); |
| chain |
| .chainAsync(appendIntAsync(sb, 0)) |
| .chainAsync(appendIntAsync(sb, 1)) |
| .chainAsync(voidArg -> Futures.immediateFailedFuture(new IOException("The error message."))) |
| .chainAsync(appendIntAsync(sb, 2)) |
| .chainAsync(appendIntAsync(sb, 3)); |
| ExecutionException ex = assertThrows(ExecutionException.class, chain.start()::get); |
| assertThat(ex).hasCauseThat().isInstanceOf(IOException.class); |
| assertThat(ex).hasMessageThat().contains("The error message."); |
| } |
| |
| @Test |
| public void chain_mixedOperationTypes_propagatesFailure() { |
| StringBuilder sb = new StringBuilder(""); |
| SequentialFutureChain<Void> chain = futuresUtil.newSequentialChain(); |
| chain |
| .chainAsync(appendIntAsync(sb, 0)) |
| .chain(appendIntDirect(sb, 1)) |
| .chain( |
| voidArg -> { |
| throw new RuntimeException("The error message."); |
| }) |
| .chain(appendIntDirect(sb, 2)) |
| .chainAsync(appendIntAsync(sb, 3)); |
| ExecutionException ex = assertThrows(ExecutionException.class, chain.start()::get); |
| assertThat(ex).hasCauseThat().isInstanceOf(RuntimeException.class); |
| assertThat(ex).hasMessageThat().contains("The error message."); |
| } |
| |
| private static Function<Void, Void> appendIntDirect(StringBuilder sb, int i) { |
| return voidArg -> { |
| sb.append(i); |
| return null; |
| }; |
| } |
| |
| private static Function<Void, ListenableFuture<Void>> appendIntAsync(StringBuilder sb, int i) { |
| return voidArg -> { |
| sb.append(i); |
| return Futures.immediateFuture(null); |
| }; |
| } |
| } |