É uma boa ideia fazer TDD em componentes de baixo nível?

Estou pensando em escrever um driver de baixo nível ou componentes / kernels do SO.

O pessoal do osdev.org parece pensar que os bits importantes não são significativamente testáveis ​​dessa maneira, mas eu li algumas discussões em que as pessoas pensavam de maneira diferente. Eu olhei em volta, mas não consegui encontrar exemplos reais de TDD em componentes de baixo nível.

Isso é algo que as pessoas realmente fazem, ou apenas algo sobre o que as pessoas falam em teoria porque não existe uma boa maneira de fazer isso na prática?

Se você está interagindo ou controlando o hardware, é difícil testar sem ele. Você pode tentar emular o hardware, mas isso geralmente é mais difícil do que escrever o driver, para que você não saiba se o bug está no driver ou no emulador.

Pessoalmente, acredito que se pode obter muitos dos benefícios do TDD (sem realmente aderir ao TDD):

• Escreva o código do chamador e o chamado na mesma hora (definitivamente não mais de 24 horas).
  • E use isso para influenciar o design da interface (objetos, chamadas de métodos e parâmetros).
• Para um componente que exige um algoritmo / código complicado, considere fortemente implementar primeiro um algoritmo mais simples, mas correto, mesmo que seja menos eficiente (ou estúpido, ou apenas funcione em uma situação mais restrita).
  • Um método de teste muito simples seria executar os dois algoritmos e comparar seus resultados.
• Depois que um bug foi descoberto (por qualquer meio) em uma parte do código, essa parte do código merece ser testada com muito mais agressividade. Isso significa fazer testes mais sofisticados do que o TDD exigiria. (com base no raciocínio de que ocorrem erros nos clusters )

O TDD parece exigir que você tenha uma compreensão clara de qual função você planeja implementar ou quais requisitos você planeja satisfazer implementando o código. Em algumas situações, há simplesmente muito pouca compreensão do problema. Isso exigiria uma solução Spike . Dentro do escopo desta solução Spike, o TDD pode ser aplicado porque o problema foi reduzido a um nível gerenciável. Após a conclusão de alguns Spikes, cada um cobrindo alguns aspectos do problema original, é possível começar a trabalhar na solução completa, e a aplicação do TDD nesse ponto pode ser possível por causa do entendimento aprimorado.

Editado:

Depois de ler a página com mais cuidado,

Embora seja possível testar a maioria das funções do kernel em um driver de teste "testbed", coisas realmente "suculentas", como manipulação de interrupções, despacho de processos ou gerenciamento de memória, provavelmente não podem ser testadas por unidade. --- de http://wiki.osdev.org/Unit_Testing

Eles estão dizendo claramente que a maioria das peças é testável e que algumas peças exigem um tipo diferente de teste: teste de estresse .

Eu não. No código incorporado do meu mestre, apenas escrevo o código e passo meu tempo discutindo sobre o que ele faz (ou não). Não tenho certeza se isso poderia ser feito no meu caso, mas estou chegando perturbadoramente ao limite físico da memória sem injetar código de teste.

Eu acho que para sistemas que são grandes o suficiente (ou seja, têm MB de memória, não KB), isso pode ser feito para alguns componentes se você tiver tempo e esforço suficientes. Testar código de leitura de pinos zombando dos pinos é ... er ... não muito significativo. Se você separou sua lógica o suficiente, poderá testá-la em outro lugar.

FWIW, eu não compro TDD no caso geral - ele funciona bem para pilhas de sistema que são grandes o suficiente com recursos suficientes com comportamento determinístico suficiente, fora isso, não parece uma prática razoável.