[C++]tester automatico

[trallallero]

immagine piccola:
http://lh3.ggpht.com/_HH5byQu0gx4/SSLQ7L_YMKI/AAAAAAAAAJg/JCjsItR1M5c/s400/a.jpg

versione grande:
http://lh3.ggpht.com/_HH5byQu0gx4/SSLQ7L_YMKI/AAAAAAAAAJg/JCjsItR1M5c/s800/a.jpg


Oggi è stato accettato il mio software dall'esercito tedesco !!! :yeah: :cincin:
Il che significa che possiamo andare avanti, abbiamo il progetto! :D

In pratica è un programma per esercitare piloti di carri armati, soldati vari, etc
e la mia parte è la logica per farli comunicare e gestire i mille mila pulsanti nella foto.

Adesso la domanda: secondo un paio di miei colleghi si può fare un programma che testa automaticamente tutto
il sistema che si vede nella foto - dalla quale non si può vedere che i vari pannelli possono anche comunicare tra di loro
via radio (HF o VHF ma comunque half duplex) o in maniera diretta (full duplex) -.
Tutto il sistema significa che ad ogni switch modificato, oltre alla comunicazione, possono esserci da 0 ad infinite reazioni e relative modifiche di altrettanti switch.

Secondo me no o, meglio, si, ma è un lavoro mastodontico che non può essere fatto in breve tempo e da solo noi 3.


Chiedo pareri e consigli, grazie :)

[banryu79]

Accidenti, complimentoni!
Ovviamente non sono in grado di darti un parere utile per il tuo quesito, però ci tenevo a postarti i complimenti: è sempre bello sapere dei risultati positivi raggiunti da un collega.
:)

[trallallero]

Accidenti, complimentoni!
Ovviamente non sono in grado di darti un parere utile per il tuo quesito, però ci tenevo a postarti i complimenti: è sempre bello sapere dei risultati positivi raggiunti da un collega.
:)

Grazie mille :)

E sono anche contento perchè questo significa bonus (€) a fine anno :D

[trallallero]

È stato deciso senza possibilità di appello che il test và automatizzato ...

:help:

[PhysX]

se ad ogni switch modificato possono esserci da 0 ad infinite reazioni e relative modifiche di altrettanti switch la prima cosa che mi viene in mente è implementare un sistema basato su degli Observer pattern (http://en.wikipedia.org/wiki/Observer_pattern) con cui collegare gli switch tra loro (tipo i Signal/Slot delle QT) e un Mediator pattern (http://en.wikipedia.org/wiki/Mediator_pattern) che è utile quando ci sono molti oggetti che comunicano tra loro in quanto riduce il numero di connessioni e rende piu semplice il sistema, inoltre le dipendenze tra le comunicazioni vengono gestite in un unico posto per cui sono piu semplici da controllare.
dopo puoi inserire il codice di test nelle classi base in modo che venga eseguito automaticamente anche nelle implementazioni concrete.

[trallallero]

Beh, io ho già spalmato la logica in varie classi e il ciclo è il seguente:

Engine: riceve il messaggio (es: switch premuto) e chiama la Unit passandole il messaggio (non sà quale Unit quindi chiama il metodo virtuale della classe Unit base).

Unit: riceve il messaggio e, se serve, chiama il metodo virtual della classe Panel.

Panel: riceve il messaggio e, se serve, chiama il metodo virtual della classe Device (lo switch, appunto)

Device: riceve il messaggio e, se serve, imposta uno stato del suo Element.

Element: se cambia stato aggiunge un messaggio alla lista dinamica di messaggi da riinviare al chiamante.

Quindi ogni funzione termina e si torna a bomba e, se il messaggio uscente non è vuoto, Engine spedisce i messaggi al chiamante.

Dal Panel ho anche una struttura Signal che informa la Unit che qualcosa è stato fatto (cambiato frequenza comunicazione, disturbata frequenza per troppa distanza, etc etc) perchè ogni livello ha le sue responsabilità e certe azioni possono essere eseguite solo dalla Unit.

Quindi mi ritrovo ad avere tutti i messaggi in un unico posto, ovvero Engine.
Penso di aver fatto un buon lavoro (a parte qualche cagata per la fretta tipo il Panel che interroga la Unit - ovvero rottura del sistema :muro: ) perchè è ordinato e lineare.

Il mio vero problema quindi è: ad ogni messaggio entrante, come faccio a controllare se gli n messaggi uscenti sono corretti ?
o, meglio, come faccio a controllare che la somma, il risultato dei messaggi uscenti è corretto ?

A me puzza tanto di "memorizzare di ogni singolo scenario" e la cosa è da pazzi !!!

Grazie dell'aiuto :)


PS: per quanto riguarda la comunicazione, registro tutto in una matrice "clients * clients" dove le linee orizzontali sono gli input, quelle verticali gli output.
Qundi anche lì posso interrogare la matrice per sapere chi sta parlando con chi.
Ho tutte le info quindi, devo solo trovare il modo per analizzarle, per confrontarle con un valore giusto.

[trallallero]

Ho risolto cosí, se a qualcuno può servire/interessare:

uso un DB (sqlite3) dove memorizzo, tramite l'AutoTester in fase store, tutti i test da fare suddivisi in gruppi.
Per esempio ho fatto un gruppo (l'unico per adesso) dove testo tutti i pulsanti prima ON poi OFF in un determianto ordine.
Ci sono ovviamente delle condizioni da rispettare: tutte le radio devono essere spente, tutti i walky-talky su OFF etc.

Quando la fase di inserimento è finita, si può avviare il tester in fase test e scegliere quale gruppo-test testare.
Ancora da implementare ma per ogni message_in che trova nella tabella, lo spedisce alla logica che reagisce creando n message_out.
Controllo questi message_out se sono uguali a quelli insertiti nella tabella.

Più di così non ho saputo fare ma sono sicuro che non esista un modo per fare dei test dinamici in automatico.
Almeno non con logiche così complicate.

E comunque ho presentato il design ed è stato accettato, quindi nessuno pretende test dinamici (anche perchè se così fosse pretenderei che qualcuno in soc. mi faccia il design, visto che non avrei la minima idea di come farlo :D)