All perguntas(coding)

Estou tentando usar std::filesystem::current_path()para alterar o diretório de trabalho para algo que pode ser um symlink. Se o alvo for um symlink, o link está sendo resolvido e o diretório de trabalho se torna o alvo do link em vez do caminho que especifiquei. Meu principal problema com isso é que ele torna os caminhos relativos incorretos.

Como exemplo:

#include <filesystem>
#include <iostream>

using namespace std;
using namespace std::filesystem;

auto main(int, char **) -> int {
  // create absolute directory then symlink to it
  create_directory("/tmp/tgt");
  create_directory_symlink("/tmp/tgt", "/tmp/dir");

  cout << "cwd0: " << current_path() << '\n';
  current_path("/tmp/dir");
  cout << "cwd1: " << current_path() << '\n';

  remove("/tmp/tgt");
  remove("/tmp/dir");
  return 0;
}

Executando isso de dentro do /tmpdiretório, a saída é.

cwd0: "/tmp"
cwd1: "/tmp/tgt"

mas o que eu quero é cwd1mostrar/tmp/dir

Existe um mecanismo portátil para alterar o diretório de trabalho para um link simbólico?

Quero ter testes parametrizados no NUnit para testes em execução em dois cenários diferentes. A maioria/alguns testes são os mesmos, mas alguns não são. Então pensei, quero ter uma classe base para executar testes comuns em dois cenários.

Aqui está o MVE completo:

using FluentAssertions;
using NUnit.Framework;

public class SystemUnderTest
{
    public bool? CrucialSettingsForSut { get; }

    public SystemUnderTest(bool crucialSettingsForSut)
    {
        // does something with crucialSettingsForSut that inheritly changes the logic, this is just an example
        this.CrucialSettingsForSut = crucialSettingsForSut;
    }
}

public class ConstructorTest
{
    public class BaseTestClass
    {
        protected readonly SystemUnderTest sut;

        public BaseTestClass(bool crucialSettingsForSut)
        {
            this.sut = new SystemUnderTest(crucialSettingsForSut);
        }

        [Test]
        public void TestApplicableToBothCases()
        {
            this.sut.CrucialSettingsForSut.Should().NotBeNull();
        }
    }
    
    [TestFixture]
    public class ActualTestFixtureFalse : BaseTestClass
    {
        public ActualTestFixtureFalse() : base(false) { }

        [Test]
        public void TestOnlyApplyingToFalse()
        {
            this.sut.CrucialSettingsForSut.Should().BeFalse();
        }
    }

    [TestFixture]
    public class ActualTestFixtureTrue : BaseTestClass
    {
        public ActualTestFixtureTrue() : base(true) { }

        [Test]
        public void TestOnlyApplyingToTrue()
        {
            this.sut.CrucialSettingsForSut.Should().BeTrue();
        }
    }
}

Este é um exemplo simplificado, é claro que o código real é mais complexo.

O importante é que TestOnlyApplyingToTruee TestOnlyApplyingToFalsesão contraditórios , ou seja, não posso colocá-los na mesma classe e fazer com que ambos os testes sejam executados em a TestFixturecom o parâmetro para o construtor.

Problema

Infelizmente, o NUnit tenta instanciar BaseTestClassmesmo que eu não queira isso de fato. Afinal, isso contém apenas o conjunto de "testes base":

Isso resulta neste erro para TestApplicableToBothCases:

OneTimeSetUp: No suitable constructor was found
  Exception doesn't have a stacktrace



-----

No suitable constructor was found
  Exception doesn't have a stacktrace

Tentativas

Eu vi No suitable constructor was found em NUnit Parameterised tests , mas no meu caso BaseTestClassdeveria estar lá e tem um propósito, como explicado. Não consigo resolver isso com TestFixture.

Assert.IgnoreUma alternativa pode ser ter um costume TestOnlyApplyingToTruee TestOnlyApplyingToFalsesomente ser acionado se o respectivo outro caso de teste for executado, mas isso é IMHO design de código feio e causa uma entrada de "teste ignorado". A maneira com herança que usei aqui faz muito mais sentido. Além disso, obviamente isso dificilmente escala, pois não tenho apenas um teste para cada cenário como neste exemplo simplificado.

Padrões de design

Você pode se perguntar sobre esse design, mas, na minha humilde opinião, ele é bom para casos simples. Na verdade, ele é apresentado como um padrão de classe de infraestrutura de teste abstrato em The Art of Unit Testing Second Edition (com exemplos em C#) por Roy Osherove . (ISBN: 9781617290893)

O que importa: pelo menos na versão que tenho, eles realmente têm o mesmo erro lá! BaseTestsClass(na Listagem 7.4, página 139) não é abstrato . (Escrevi isso depois de saber a solução.) Simplesmente não importa, porque nenhum teste real está incluído na classe base (não abstrata) ali.

A Listagem 7.6 etc. usa uma classe base abstrata real como solução para esta e, até onde li, também inclui um teste na classe base.

Pergunta

Então, como posso resolver isso da maneira mais elegante?

Tenho o seguinte código:

void check_portvalue(std::string_view value)
{
    [[maybe_unused]] port_t test {value};
}

O objeto testpermanece sem uso, mas a criação serve como uma verificação, porque o construtor pode lançar. O [[maybe_unused]]atributo suprime o aviso do compilador.

Mas já que o compilador detecta que isso não é utilizado, ele poderia otimizar a instrução inteira e assim evitar que a exceção fosse lançada?

Estou tentando definir operator<=>uma classe, porém quando especifico uma implementação não padrão, std::three_way_comparableretorna false:

#include <cstdio>
#include <compare>

using namespace std;

struct UDTC
{
    int i_;
    UDTC(int i) : i_(i) {}

#if 1
    friend std::strong_ordering operator<=>(const UDTC &lhs, const UDTC &rhs) {
        return lhs.i_ <=> rhs.i_;
    }
#else
    friend std::strong_ordering operator<=>(const UDTC &lhs, const UDTC &rhs) = default;
#endif
};


int main(void)
{
    if constexpr (std::three_way_comparable<UDTC>) {
        fprintf(stderr, "UDTC is three_way_comparable\n");
    } else {
        fprintf(stderr, "UDTC is NOT three_way_comparable\n");
    }
}

Quando executo isso com o Visual Studio 2022 ou GCC 12, se a <=>função for padrão, three_way_comparableretorna true. Se eu fornecer minha própria implementação, ele retorna false. Só posso supor que minha implementação esteja de alguma forma incompleta, mas não estou vendo o que estou perdendo.

Estou usando o coord_radialdo ggplot2, mas não consigo fazer os limites do eixo corretos. A estética x (neste caso theta) é um fator e y (r) é um número. Quero que o primeiro nível do fator esteja exatamente em 12 (norte) e os outros níveis sejam distribuídos uniformemente. No exemplo abaixo, a lacuna entre o primeiro e o último nível (A e D) é maior do que as outras lacunas. Entre outras coisas, tentei usar scale_x_discretee expand. Abaixo está um exemplo mínimo, mas meu caso real tem 15 níveis.

library(dplyr)
library(ggplot2)

tibble(lab = c("A", "B", "C", "D"),
       val = rexp(4)) %>%
  ggplot(aes(lab, val, group = 1)) +
  geom_line() +
  coord_radial(r.axis.inside = TRUE)

Tenho dois conjuntos de dados:

O primeiro data frame ( small) é relativamente menor que o segundo data frame ( large). Cada data frame tem uma idcoluna com identificadores exclusivos. O data frame menor tem uma coluna de lista chamada links, que contém uma lista de links para o segundo data frame maior. O data frame maior tem uma coluna de atributos, que chamaremos de att:

library(tidyverse)

a <- c(3, 3, NA, 5)
b <- c(NA, 3, 4, 5)

small <- tibble(id = c(1, 2),
                links = list(a, b))

large <- tibble(id = c(3, 4, 5),
                att = c("yes", "no", "maybe"))

Meu objetivo é contar o número de vezes que cada observação no smallquadro de dados tem links para observações com o "yes"atributo no largequadro de dados.

Sinto que algo assim está no caminho certo, mas não está contando corretamente:

counted <- small %>%
  mutate(count_yes = map_int(links, ~ sum(large$att[large$id %in% .x] == "yes")))

print(counted)
#> # A tibble: 2 × 3
#>      id links     count_yes
#>   <dbl> <list>        <int>
#> 1     1 <dbl [4]>         1
#> 2     2 <dbl [4]>         1

Aqui, count_yesaparece apenas como 1, quando deveria ser lido como 2 e 1.

Provavelmente já respondido, mas estou com dificuldade para encontrar a resposta para esta pergunta: Em uma nova coluna 'new_text', como preencher um texto fornecido com outro texto fornecido, e assim por diante...

No exemplo abaixo, como preencher 'Potter' com 'Wisley' e depois 'Wisley' com 'Granger', etc...?

A ideia é aplicar a solução proposta a dataframes de milhares de linhas (obtidos com pdftools::pdf_data) selecionando uma sequência de palavras específicas para preencher dessa maneira.

Obrigado pela ajuda.

> dat0
      text new_text
1   Potter   Potter
2     hj7d   Potter
3    kl8ep   Potter
4      f3d   Potter
5   rtyzs2   Potter
6   Wisley   Wisley
7     lq6s   Wisley
8      2fg   Wisley
9  Granger  Granger
10    r8ka  Granger
11      h9  Granger
12   qm9ne  Granger  

Dados:

dat0 <-
structure(list(text = c("Potter", "hj7d", "kl8ep", "f3d", "rtyzs2", 
"Wisley", "lq6s", "2fg", "Granger", "r8ka", "h9", "qm9ne"), new_text = c("Potter", 
"Potter", "Potter", "Potter", "Potter", "Wisley", "Wisley", "Wisley", 
"Granger", "Granger", "Granger", "Granger")), class = "data.frame", row.names = c(NA, 
-12L))

Tenho os seguintes dados para os quais estou tentando dividir de 1 para a última seção de números por a -. Meus dados são os seguintes;

dat
"4-3" "60-0 2-5" "10-1 3-2" "20-2 3-0" "3-0" "20-5 3-0"

O que estou tentando arquivar é que estamos adicionando separadamente 1 ao último número e 1 ao penúltimo número;

dat1
"5-3" "60-0 3-5" "10-1 4-2" "20-2 4-0" "4-0" "20-5 4-0"

dat2
"4-4" "60-0 2-6" "10-1 3-3" "20-2 3-1" "3-1" "20-5 3-1"

Acho que pode ser possível dividir os dados usando um gsub(), embora isso possa ser complicado, pois meus dados variam em comprimento entre 1 conjunto de números e 2, meu outro problema é que se eu usar um gsub, não consigo somar (até onde eu saiba). Minha teoria seria algo como identificar o último número e adicionar 1, então identificar o segundo último número e adicionar 1

Estou tentando aprender o skopt, mas estou com dificuldade para executar até mesmo uma minimização multivariada simples.

import skopt

def black_box_function(some_x, some_y):
    return -some_x + 2 - (some_y - 1) ** 2 + 1

BOUNDS = [(0, 100.0), (0, 100.0)]

result = skopt.dummy_minimize(func=black_box_function, dimensions=BOUNDS)

Quando executo isso, ele parece descobrir que quero que o espaço de busca para some_x fique entre 0 e 100, mas retorna este erro:

TypeError: black_box_function() faltando 1 argumento posicional obrigatório: 'some_y'.

Como posso definir o espaço de busca para some_xe some_y?

Estou tentando inverter meus dados cada vez que vemos um -, isso provavelmente é melhor explicado em um exemplo;

myDat
"11-11 10-30" "1-1 30-29" "9-8" "1-1 1-1 1-3" "0-1 7-12" "5-8 20-45"

Quando ligo isso, -estou tentando obter;

myDat
"11-11 30-10" "1-1 29-30" "8-9" "1-1 1-1 3-1" "1-0 12-7" "8-5 45-20"

Minha ideia inicial era fazer isso usando um gsub ou sub e apenas inverter o número cada vez que víssemos um, -mas isso foi complicado, pois tenho comprimentos diferentes. Talvez uma maneira melhor de fazer isso seja usar strsplit(), dividindo em -e colando novamente, embora eu não esteja muito familiarizado com essa função.