Início / user-1747834

Mikhail T.'s questions

Martin Hope
Mikhail T.
Asked: 2024-09-10 04:09:34 +0800 CST
  • 5

Estou testando nossa própria biblioteca, que usa JDBC. Para o nome do banco de dados especificado, o código precisa encontrar o valor javax.sql.DataSource, conectar usando o DataSource.getConnection(), e então executar algumas instruções SQL.

Gostaria que todos os testes fossem pulados, se houver mp $TESTDBno ambiente. Eu também gostaria de testar essas etapas iniciais separadamente -- pulando o resto se, por exemplo, encontrar o dataSourceque falhou.

O código de teste até agora é:

    public static final String DBNAME = System.getenv("TESTDB");

    private static DataSource DS = null;
    private static Connection CONN = null;

    @BeforeAll
    public static void checkEnvironment() {
        assumeTrue(DBNAME != null, "Environment variable DBNAME");
        logger.info("DBNAME is {}", DBNAME);
    }

    @Test
    @Order(20)
    public void getDataSource() {
        DS = DatasourceFactory.getDataSourceByKey(DBNAME);
        assertNotNull(DS, "Failed to find details for datasource " +
            DBNAME);

        logger.info("Datasource for {}: {}", DBNAME, DS);
    }

    @Test
    @Order(30)
    public void getConnection() {
        try {
            CONN = DS.getConnection();
        } catch (SQLException e) {
            fail("Connetion to " + DBNAME + " failed", e);
        }
    }

A @BeforeAllanotação parece funcionar bem -- o método é invocado primeiro e registra o DBNAME obtido da variável de ambiente. Se a variável de ambiente não estiver definida, todos os testes serão ignorados, como eu quero.

Meu problema é que, apesar das @Orderanotações explícitas, o getConnection()teste é tentado antes que o getDataSource()teste tenha a chance de definir o static DS. O getDataSource()próprio é bem-sucedido -- depois, registrando algo como:

Datasource for SQL_DEV4: org.apache.commons.dbcp.BasicDataSource@4a3668

mas getConnection()falha devido a uma exceção de ponteiro nulo, porque DSainda é null, quando é tentado.

Por que meu pedido não está funcionando?

java
Martin Hope
Mikhail T.
Asked: 2024-09-05 02:51:03 +0800 CST
  • 14

Estou lidando com uma API razoavelmente uniforme fornecida por um fornecedor e gostaria de verificar -- e lidar -- com quaisquer falhas de forma unificada também. Para esse fim, escrevi o seguinte wrapper:

template <typename Func, typename... Args>
auto awrap(Func &func, Args&&... args)
{
    auto code = func(args...);

    if (code >= 0)
        return code;

    ... handle the error ...
};
...
awrap(handlepath, handle, path, NULL, 0, coll, NULL);

O comando acima compila bem com clang, mas o g++13 e o Microsoft VC++ reclamam dos dois argumentos NULL:

... error: invalid conversion from 'int' to 'const char*' [-fpermissive]
   87 |                 auto code = func(args...

Substituir os dois NULLs por nullptrresolve o problema, mas por que isso importa?

Provavelmente, o NULLé transformado em 0x0ou mesmo 0em algum lugar pelo pré-processador, mas a chamada original nunca levantou uma "sobrancelha". Usar NULL era perfeitamente adequado em:

handlepath(handle, path, NULL, 0, coll, NULL);

Por que isso é um problema (para alguns compiladores) quando usado em um wrapper?

ATUALIZAÇÃO : /usr/include/sys/_null.hno meu sistema FreeBSD tem o seguinte código:

#ifndef NULL

#if !defined(__cplusplus)
#define NULL    ((void *)0)
#else
#if __cplusplus >= 201103L
#define NULL    nullptr
#elif defined(__GNUG__) && defined(__GNUC__) && __GNUC__ >= 4
#define NULL    __null
#else
#if defined(__LP64__)
#define NULL    (0L)
#else
#define NULL    0
#endif  /* __LP64__ */
#endif  /* __GNUG__ */
#endif  /* !__cplusplus */

#endif

Então:

  1. para C, NULLé (void *)0;

  2. para clang++ NULLe nullptrsão a mesma coisa, enquanto para GNU pode não ser...

c++
Martin Hope
Mikhail T.
Asked: 2024-08-30 05:48:15 +0800 CST
  • 7

Uma "calculadora" complexa é atualmente invocada assim:

result = calculator.calc(a, b, extra);

Infelizmente, às vezes pode falhar devido a mudanças não relacionadas acontecendo no servidor. Sincronizar com diferentes departamentos é difícil -- tentar novamente é mais fácil.

Para isso, implementei uma retryfunção lambda:

auto retry = [](const auto& func, auto... args) {
    int attempts = 5;
    for (;;) try {
        return func(args...);
    }
    catch (const std::system_error& e) {
        /* Don't retry in case of a system_error */
        throw;
    }
    catch (const exception& e) {
        if (attempts-- == 0)
            throw; /* Give up and rethrow */
        Logging::log(Logging::Level::Warning,
            "%s. Retrying %d more times.", e.what(), attempts);
        sleep(2);
    }
};

O acima compila, mas, conforme tento usá-lo:

result = retry(calculator.calc, a, b, extra);

Recebo um erro do clang:

referência à função membro não estática deve ser chamada

GNU c++ sinaliza a mesma linha com:

uso inválido de função de membro não estático

De fato, este calc()é um método não estático da Calculatorclasse.

Como eu usaria meu novo lambda?

c++
Martin Hope
Mikhail T.
Asked: 2023-08-25 23:47:05 +0800 CST
  • 5

Estou lidando com um aplicativo que precisa ler mais de 10 arquivos CSV (de tipos diferentes) como entrada. Os dados são lidos em um contêiner – std::mapou vector.

Anteriormente, cada tipo tinha sua própria função de análise, e estou trabalhando para unificá-la em uma única função padronizada: economizar na manutenção futura do código e fornecer relatórios de erros uniformes para arquivos corrompidos.

Esta função lê cada linha, discerne se o tipo de contêiner tem o conceito de a key(like map) e usa emplacepara essas e emplace_backpara as outras (like vector).

A única expectativa da classe de valor do contêiner é que seu construtor possa instanciar a partir de uma linha CSV. Qualquer exceção do construtor é um erro fatal - o nome do arquivo de entrada e o número da linha são relatados e o programa é encerrado:

try {
        if constexpr (is_associative_container<Container>(NULL)) {
                result->emplace(typename Container::key_type(
                    key, keylen), value);
        } else {
                result->emplace_back(value);
        }
} catch (const std::exception &e) {
        fprintf(stderr, "%s:%zd: %s\n", path, line, e.what());
        goto failure;
}

Tudo isso funciona e estou feliz - cerca de 75% da análise de CSV agora é feita por esta função.

Agora estou enfrentando o quarto restante dos arquivos CSV, que são menos simples: porque certas linhas neles requerem tratamento especial e seu conteúdo não deve ser armazenado no contêiner.

Como o value_typeconstrutor do sinaliza para a função que a exceção que ela está lançando não deve ser considerada fatal? Uma maneira é escolher uma das exceções padrão ( std::bad_function_call?) como sinal, mas isso significaria que a exceção escolhida não deve ocorrer inesperadamente - o que não é confiável...

Algo mais?

c++