* used so that OkHttp can learn from its mistakes: if there was a failure attempting to connect to
 * a specific IP address or proxy server, that failure is remembered and alternate routes are
 * preferred.
 */
class RouteDatabase {
  private val _failedRoutes = mutableSetOf<Route>()

  val failedRoutes: Set<Route>
    @Synchronized get() = _failedRoutes.toSet()

  /** Records a failure connecting to [failedRoute]. */

    /**
     * Execution must occur before any executions of the phase proper. Failure of any {@code #BEFORE} dynamic phase
     * execution will prevent the {@link #AT} phase but will not prevent any {@link #AFTER} dynamic phases.
     */
    BEFORE("before:"),
    /**
     * Execution is the execution of the phase proper. Failure of any {@code #AT} dynamic phase execution will fail

    check(rule.startsWith(WILDCARD_CHAR)) {
      """Wildcard Assertion Failure: '$rule'
A wildcard rule was added with a wildcard that is not in leftmost position! We'll need to change the ${PublicSuffixDatabase::class.java.name} to handle this."""
    }
    check(rule.indexOf(WILDCARD_CHAR, 1) == -1) {
      """Wildcard Assertion Failure: '$rule'

     *
     * @param from The previous state that is being transitioned from. Failure can occur in any
     *     state with the exception of {@linkplain State#NEW NEW} or {@linkplain State#TERMINATED
     *     TERMINATED}.
     * @param failure The exception that caused the failure.
     */
    public void failed(State from, Throwable failure) {}
  }

                        Throwable failure;
                        if (failures.size() == 1) {
                            failure = failures.get(
                                    0); // Single exception, no need to wrap it in a LifecycleExecutionException
                        } else {
                            failure = new LifecycleExecutionException("Error building project");

            .build()
        connection.start()
      } catch (e: IOException) {
        logger.log(Level.INFO, "Http2Server connection failure: $e")
        socket?.closeQuietly()
      } catch (e: Exception) {
        logger.log(Level.WARNING, "Http2Server unexpected failure", e)
        socket?.closeQuietly()
      }
    }
  }

  private fun doSsl(socket: Socket): SSLSocket {
    val sslSocket =

    @Test
    @DisplayName("getSessionKey throws CIFSException on failure")
    void getSessionKey_throws() throws CIFSException {
        doThrow(new CIFSException("session key failure")).when(session).getSessionKey();

        CIFSException ex = assertThrows(CIFSException.class, () -> session.getSessionKey());
        assertTrue(ex.getMessage().contains("failure"));
        verify(session).getSessionKey();
    }

   * test case failure. Only the first failure is recorded; subsequent calls to this method from
   * within the same test have no effect.
   */
  final void threadRecordFailure(Throwable t) {
    threadFailure.compareAndSet(null, t);
  }

  /**
   * Extra checks that get done for all test cases.
   *
   * <p>Triggers test case failure if any thread assertions have failed, by rethrowing, in the test

            }
            logger.warn("Failed to store failure url: url={}", urlQueue != null ? urlQueue.getUrl() : "unknown", e);
        }

        super.processCrawlingException(objs);
        if (urlQueue != null) {
            ComponentUtil.getCrawlerStatsHelper().record(urlQueue, StatsAction.ACCESS_EXCEPTION);
        }
    }

    /**
     * Stores a failure URL with error information for later analysis.
     *

package mountinfo

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

// Tests cross device mount verification function, for both failure
// and success cases.
func TestCrossDeviceMountPaths(t *testing.T) {
	successCase := `/dev/0 /path/to/0/1 type0 flags 0 0
		/dev/1    /path/to/1   type1	flags 1 1
		/dev/2 /path/to/1/2 type2 flags,1,2=3 2 2