guava
1/*
2* Copyright (C) 2009 The Guava Authors
3*
4* Licensed under the Apache License, Version 2.0 (the "License");
5* you may not use this file except in compliance with the License.
6* You may obtain a copy of the License at
7*
8* http://www.apache.org/licenses/LICENSE-2.0
9*
10* Unless required by applicable law or agreed to in writing, software
11* distributed under the License is distributed on an "AS IS" BASIS,
12* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13* See the License for the specific language governing permissions and
14* limitations under the License.
15*/
16
17package com.google.common.testing;18
19import com.google.common.annotations.GwtCompatible;20import java.util.ArrayList;21import java.util.Arrays;22import java.util.Collection;23import java.util.Collections;24
25/**
26* An {@link ClusterException} is a data structure that allows for some code to "throw multiple
27* exceptions", or something close to it. The prototypical code that calls for this class is
28* presented below:
29*
30* <pre>
31* void runManyThings({@literal List<ThingToRun>} thingsToRun) {
32* for (ThingToRun thingToRun : thingsToRun) {
33* thingToRun.run(); // say this may throw an exception, but you want to
34* // always run all thingsToRun
35* }
36* }
37* </pre>
38*
39* <p>This is what the code would become:
40*
41* <pre>
42* void runManyThings({@literal List<ThingToRun>} thingsToRun) {
43* {@literal List<Exception>} exceptions = Lists.newArrayList();
44* for (ThingToRun thingToRun : thingsToRun) {
45* try {
46* thingToRun.run();
47* } catch (Exception e) {
48* exceptions.add(e);
49* }
50* }
51* if (exceptions.size() > 0) {
52* throw ClusterException.create(exceptions);
53* }
54* }
55* </pre>
56*
57* <p>See semantic details at {@link #create(Collection)}.
58*
59* @author Luiz-Otavio Zorzella
60*/
61@GwtCompatible
62@ElementTypesAreNonnullByDefault
63final class ClusterException extends RuntimeException {64
65final Collection<? extends Throwable> exceptions;66
67private ClusterException(Collection<? extends Throwable> exceptions) {68super(69exceptions.size() + " exceptions were thrown. The first exception is listed as a cause.",70exceptions.iterator().next());71ArrayList<? extends Throwable> temp = new ArrayList<>(exceptions);72this.exceptions = Collections.unmodifiableCollection(temp);73}74
75/** See {@link #create(Collection)}. */76static RuntimeException create(Throwable... exceptions) {77ArrayList<Throwable> temp = new ArrayList<>(Arrays.asList(exceptions));78return create(temp);79}80
81/**82* Given a collection of exceptions, returns a {@link RuntimeException}, with the following rules:
83*
84* <ul>
85* <li>If {@code exceptions} has a single exception and that exception is a {@link
86* RuntimeException}, return it
87* <li>If {@code exceptions} has a single exceptions and that exceptions is <em>not</em> a
88* {@link RuntimeException}, return a simple {@code RuntimeException} that wraps it
89* <li>Otherwise, return an instance of {@link ClusterException} that wraps the first exception
90* in the {@code exceptions} collection.
91* </ul>
92*
93* <p>Though this method takes any {@link Collection}, it often makes most sense to pass a {@link
94* java.util.List} or some other collection that preserves the order in which the exceptions got
95* added.
96*
97* @throws NullPointerException if {@code exceptions} is null
98* @throws IllegalArgumentException if {@code exceptions} is empty
99*/
100static RuntimeException create(Collection<? extends Throwable> exceptions) {101if (exceptions.size() == 0) {102throw new IllegalArgumentException("Can't create an ExceptionCollection with no exceptions");103}104if (exceptions.size() == 1) {105Throwable temp = exceptions.iterator().next();106if (temp instanceof RuntimeException) {107return (RuntimeException) temp;108} else {109return new RuntimeException(temp);110}111}112return new ClusterException(exceptions);113}114}
115