break;
          }
        }

        try {
          ImmutableRangeSet<Integer> unused = builder.add(range).build();
          assertFalse(overlaps);
          mutable.add(range);
        } catch (IllegalArgumentException e) {
          assertTrue(overlaps);
          continue subsets;
        }
      }

      if (anyOverlaps) {

        indexUpdater.setSessionIdList(sessionIdList);

        final CountDownLatch latch = new CountDownLatch(1);
        final AtomicBoolean errorOccurred = new AtomicBoolean(false);

        indexUpdater.setUncaughtExceptionHandler((t, e) -> {
            errorOccurred.set(true);
            latch.countDown();
        });

        // Set up test data service to return empty results

 * </ul>
 *
 * Each derivation can capture the next value or any intermediate objects for later closing.
 *
 * <p>A step can be the input to at most one derived step. Once you transform its value, catch its
 * exception, or combine it with others, you cannot do anything else with it, including declare it
 * to be the last step of the pipeline.
 *
 * <h4>Transforming</h4>
 *

          default:
            assertThat(network.hasEdgeConnecting(node, otherNode)).isTrue();
            try {
              network.edgeConnectingOrNull(node, otherNode);
              fail();
            } catch (IllegalArgumentException expected) {
            }
        }

        boolean isSelfLoop = node.equals(otherNode);
        boolean connected = !edgesConnecting.isEmpty();

          } catch (RuntimeException e) {
            throw new RuntimeException(
                Strings.lenientFormat(
                    "byAscendingSize %s, startIndex %s, inputIsSet %s",
                    byAscendingSize, startIndex, inputIsSet),
                e);
          }
          /*
           * TODO(cpovirk): Check that the values match one of candidates that

            } else {
                queryContext.setQueryBuilder(QueryBuilders.matchAllQuery());
            }
            // TODO options query
            context.accept(queryContext);
        } catch (final QueryParseException e) {
            throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryParseError(UserMessages.GLOBAL_PROPERTY_KEY),

            parser.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, StringUtil.EMPTY);
            parser.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, StringUtil.EMPTY);
            parser.parse(is, this);
        } catch (final Exception e) {
            throw new GsaConfigException("Failed to parse XML file.", e);
        }
    }

    /**
     * SAX event handler called at the beginning of document parsing.

    try {
      Files.move(from, to);
      if (success) {
        assertFalse(from.exists());
        assertTrue(to.exists());
      } else {
        fail("expected exception");
      }
    } catch (IOException possiblyExpected) {
      if (success) {
        throw possiblyExpected;
      }
    }
  }

  private static class UnmovableFile extends File {

    private final boolean canRename;

     * @return The converted {@link Time}.
     */
    protected static Time toSqlTimeJdbcEscape(final String str) {
        try {
            return Time.valueOf(str);
        } catch (final IllegalArgumentException ex) {
            return null;
        }
    }

    /**
     * Converts a pattern string to a plain pattern string without delimiters.
     *
     * @param pattern

     * @return The converted {@link Timestamp}.
     */
    protected static Timestamp toSqlTimestampJdbcEscape(final String str) {
        try {
            return Timestamp.valueOf(str);
        } catch (final IllegalArgumentException ex) {
            return null;
        }
    }

    /**
     * Converts the pattern string to a plain pattern string without delimiters.
     *
     * @param pattern