import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
@Test (expected = ClientException.class)
public void shouldNotCreateACopyOfTheGivenStateSinceItsADifferentEntityState() throws Throwable {
    // This is in a try-block, to make sure we close the driver after the test
    try (Driver driver = GraphDatabase
            .driver(neo4j.boltURI(), Config.build().withEncryption().toConfig()); Session session = driver.session()) {
        // Given
        session.run("CREATE (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'})");
        session.run("MATCH (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'}) CREATE (e)-[:HAS_STATE {startDate:593910000000}]->(s)");
        session.run("MATCH (e:Entity) CREATE (e)-[:HAS_STATE {startDate:593900000000, endDate:59391000000}]->(s:State:Test {key:'initialValue'})");
        session.run("MATCH (sc:State)<-[:CURRENT]-(e:Entity)-[:HAS_STATE]->(s:Test) CREATE (sc)-[:PREVIOUS {date:593900000000}]->(s)");
        session.run("CREATE (e:EntityBis {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'})");
        session.run("MATCH (e:EntityBis)-[:CURRENT]->(s:State) CREATE (e)-[:HAS_STATE {startDate:593910000000}]->(s)");

        StatementResult result = session.run("MATCH (e:Entity), (:EntityBis)-[:HAS_STATE]->(s:State) WITH e, s CALL graph.versioner.patch.from(e, s) YIELD node RETURN node");
        Node currentState = result.single().get("node").asNode();
    }
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
@Test (expected = ClientException.class)
public void shouldNotRollbackToTheGivenStateSinceItsADifferentEntityState() throws Throwable {
    // This is in a try-block, to make sure we close the driver after the test
    try (Driver driver = GraphDatabase
            .driver(neo4j.boltURI(), Config.build().withEncryption().toConfig()); Session session = driver.session()) {
        // Given
        session.run("CREATE (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'})");
        session.run("MATCH (e:Entity {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'}) CREATE (e)-[:HAS_STATE {startDate:593910000000}]->(s)");
        session.run("MATCH (e:Entity) CREATE (e)-[:HAS_STATE {startDate:593900000000, endDate:59391000000}]->(s:State:Test {key:'initialValue'})");
        session.run("MATCH (sc:State)<-[:CURRENT]-(e:Entity)-[:HAS_STATE]->(s:Test) CREATE (sc)-[:PREVIOUS {date:593900000000}]->(s)");
        session.run("CREATE (e:EntityBis {key:'immutableValue'})-[:CURRENT {date:593910000000}]->(s:State {key:'initialValue'})");
        session.run("MATCH (e:EntityBis)-[:CURRENT]->(s:State) CREATE (e)-[:HAS_STATE {startDate:593910000000}]->(s)");

        StatementResult result = session.run("MATCH (e:Entity), (:EntityBis)-[:HAS_STATE]->(s:State) WITH e, s CALL graph.versioner.rollback.to(e, s) YIELD node RETURN node");
    }
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
private void flush() {
    try {
        // delete edges
        deleteEdges();
        // delete vertices
        deleteVertices();
        // create vertices
        createVertices();
        // create edges
        createEdges();
        // update edges
        updateEdges();
        // update vertices (after edges to be able to locate the vertex if referenced by an edge)
        updateVertices();
    }
    catch (ClientException ex) {
        // log error
        if (logger.isErrorEnabled())
            logger.error("Error committing transaction [{}]", transaction.hashCode(), ex);
        // throw original exception
        throw ex;
    }
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
private ExerciseValidation tryValidate(TraineeSession session, String statement, Exercise currentExercise) {
    try {
        List<Map<String, Object>> actualResult = computeActualResult(statement, currentExercise);
        return session.validate(actualResult);
    } catch (ClientException e) {
        return new ExerciseValidation(false, format("An execution error occurred:%n%s", e.getMessage()));
    }
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
/**
 * warm up the Neo4j caches if the server has just been turned on.
 * https://neo4j.com/developer/kb/warm-the-cache-to-improve-performance-from-cold-start/
 * also, if there is an SSL issue when changing databases, attempt to fix it by running
 * some fix up code.
 *
 * @param props C2SProperties object.
 */
static void warmUpResetSSL(C2SProperties props) {
    try {
        Neo4jDriver.warmUp(props);
    } catch (ClientException ce) {
        if (ce.getMessage().contains("SSLEngine problem")) {
            System.err.println("SSL Engine issue");
        }
    } catch (ServiceUnavailableException unavail) {
        System.err.println("*** Make sure the Neo4j database is up and running correctly. ***");
        unavail.printStackTrace();
        System.exit(1);
    }
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
/**
 * Interpret the cause of a Bolt exception and translate it into a sensible error message.
 */
@Nonnull
String getFormattedMessage(@Nonnull final Throwable e) {
    AnsiFormattedText msg = AnsiFormattedText.s().colorRed();

    if (isDebugEnabled()) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(baos);
        e.printStackTrace(ps);
        msg.append(new String(baos.toByteArray(), StandardCharsets.UTF_8));
    } else {
        //noinspection ThrowableResultOfMethodCallIgnored
        final Throwable cause = getRootCause(e);

        if (cause instanceof AnsiFormattedException) {
            msg = msg.append(((AnsiFormattedException) cause).getFormattedMessage());
        } else if (cause instanceof ClientException &&
                cause.getMessage() != null && cause.getMessage().contains("Missing username")) {
            // Username and password was not specified
            msg = msg.append(cause.getMessage())
                     .append("\nPlease specify --username, and optionally --password, as argument(s)")
                     .append("\nor as environment variable(s), NEO4J_USERNAME, and NEO4J_PASSWORD respectively.")
                     .append("\nSee --help for more info.");
        } else {
            if (cause.getMessage() != null) {
                msg = msg.append(cause.getMessage());
            } else {
                msg = msg.append(cause.getClass().getSimpleName());
            }
        }
    }

    return msg.formattedString();
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
@Test
public void testNestedDeep() {
    assertEquals("@|RED nested deep|@", logger.getFormattedMessage(
            new ClientException("outer",
                    new ClientException("nested",
                            new ClientException("nested deep")))));
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
@Before
public void setup() throws CommandException {
    statementParser = new ShellStatementParser();
    badLineError = new ClientException("Found a bad line");
    doThrow(badLineError).when(cmdExecuter).execute(contains("bad"));
    doReturn(System.out).when(logger).getOutputStream();
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
@Test
public void errorsShouldThrow() throws IOException, CommandException {
    ClientException kaboom = new ClientException("Error kaboom");
    doThrow(kaboom).when(statementExecuter).execute(anyString());

    StringShellRunner runner = new StringShellRunner(parse("nan anana"), statementExecuter, logger);

    int code = runner.runUntilEnd();

    assertEquals("Wrong exit code", 1, code);
    verify(logger).printError(kaboom);
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
@Before
public void setup() throws Exception {
    statementParser = new ShellStatementParser();
    logger = mock(Logger.class);
    cmdExecuter = mock(StatementExecuter.class);
    txHandler = mock(TransactionHandler.class);
    historyFile = temp.newFile();
    badLineError = new ClientException("Found a bad line");
    userMessagesHandler = mock(UserMessagesHandler.class);
    when(userMessagesHandler.getWelcomeMessage()).thenReturn("Welcome to cypher-shell!");
    when(userMessagesHandler.getExitMessage()).thenReturn("Exit message");

    doThrow(badLineError).when(cmdExecuter).execute(contains("bad"));
    doReturn(System.out).when(logger).getOutputStream();
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
public Neo4JBoltTransport(Configuration config) throws MessageOutputConfigurationException {


        configuration = config;
        fields = new LinkedList<String>();;
        Session session = null;

        try {
            driver = GraphDatabase.driver( config.getString(Neo4jOutput.CK_NEO4J_URL),
                    AuthTokens.basic(config.getString(Neo4jOutput.CK_NEO4J_USER), config.getString(Neo4jOutput.CK_NEO4J_PASSWORD)) );
            session = driver.session();

            //run initialization query only once
            String createQueryOnce = config.getString(Neo4jOutput.CK_NEO4J_STARTUP_QUERY);

            if (createQueryOnce.length() > 0)
                session.run(createQueryOnce);
        }
        catch (ClientException e){
            throw new MessageOutputConfigurationException("Malformed neo4j configuration: " + e );
        }
        finally {
            session.close();
        }
        //get message fields needed by cypher query
        String createQuery = config.getString(Neo4jOutput.CK_NEO4J_QUERY);
        LOG.debug("Bolt protocol, create query: " + createQuery);

        Matcher m = Pattern.compile("\\{([^{}]*)\\}").matcher(createQuery);
        while (m.find()) {
            fields.add(m.group(1));
            LOG.debug("Found field in cypher statement: " + m.group(1));
        }
        LOG.info("Identified " + fields.size() + " fields in graph create query.");

        parsedCreateQery = parseQuery(createQuery);


    }
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
private void postQuery(String query, Map<String, Object> mapping) {
    Session session = null;
    try {
        session = driver.session();
        session.run(query, mapping).consume();
    }
    catch (ClientException e) {
        LOG.debug("Could not push message to Graph Database: " + e.getMessage());
    }
    finally{
        if (session != null && session.isOpen())
            session.close();
    }
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
@Test
public void testNested() {
    assertEquals("@|RED nested|@", logger.getFormattedMessage(new ClientException("outer",
            new CommandException("nested"))));
}
 

import org.neo4j.driver.v1.exceptions.ClientException; //导入依赖的package包/类
@Test
public void testNullMessage() {
    assertEquals("@|RED ClientException|@", logger.getFormattedMessage(new ClientException(null)));
    assertEquals("@|RED NullPointerException|@",
            logger.getFormattedMessage(new ClientException("outer", new NullPointerException(null))));
}