Simulazione di "ora più veloce" in linux

Question

Ho un'app Java che gira su Linux che ha un sacco di eventi e logiche di business che ruotano attorno a orari e date.

Per il test, è possibile modificare qualcosa nel tempo andando più veloce. Diciamo, facciamo un intero anno di computer in un'ora di muro?

Answer 1

È possibile scrivere un'interfaccia wrapper per le chiamate di ora/data. Avere un'implementazione reale che fa le chiamate di sistema reali e un'implementazione di test che può fare tutto ciò che si desidera (eseguire date più veloci, più lente, false, ecc.).

Answer 2

Se le chiamate di sistema per ottenere l'ora di sistema (ad esempio System.currentTimeMillis()), presumibilmente, è possibile accelerare il tempo modificando l'ora del sistema. Questo dovrebbe riflettere sul tempo che vedi nella tua applicazione.

Se si utilizzano altri metodi per calcolare il tempo (tempo trascorso dall'avvio JVM (ad esempio System.nanoTime()), server di riferimento orario ecc.), La risposta è che non è possibile.

---

Non posso sottolineare abbastanza che sto solo spiegando come fare quello che hai chiesto, e questo è solo un bene per il test di integrazione, quando si prende in considerazione qualsiasi altra cosa si stanno interessando su detta macchina.

Questo non dovrebbe essere una sostituzione di alcun tipo per un corretto ed esteso test delle unità.

Answer 3

È necessario progettare il sistema in modo da poter "ripianificare" l'orologio durante il test. Per alcune classi di sistema, esiste una coda eventi che memorizza gli eventi pianificati in ordine cronologico. In qualsiasi momento della simulazione, l'evento successivo è il primo elemento in coda; puoi estrarlo dalla coda e regolare l'ora effettiva in modo che corrisponda all'ora in cui si verifica l'evento. Poiché sono in programma nuovi eventi, vengono aggiunti alla coda. Pertanto, è possibile elaborare gli eventi con la stessa rapidità consentita dal sistema, piuttosto che dover attendere l'intervallo di tempo effettivo. Ma devi progettare il tuo sistema per consentire a tale meccanismo di funzionare.

Answer 4

Un approccio che funziona meglio per il test delle unità è quello di astrarre il modo in cui l'ora corrente è accessibile nel codice.

Invece di chiamare direttamente System.currentTimeMillis() è possibile fornire la propria implementazione.

Qualcosa di simile (pseudo-codice):

class MyTime { 
    private static TimeInterface CurrentTimeInterface = new DefaultTimeImpl(); 

    public setTimeInterface(TimeInterface timeInterface) { 
     CurrentTimeInterface = timeInterface; 
    } 

    public int getTime() { CurrentTimeInterface.getTime(); } 

} 

class DefaultTimeImpl implements TimeInterface { 
    public int getTime() { return System.currentTimeMillis(); } 
} 

class TestTimeImpl implements TimeInterface { 
    private int CurrentTimeMillis = 0; 
    public int getTime() { return CurrentTimeMillis; } 
    public void setTime(int timeMillis) { CurrentTimeMillis = timeMillis} 
    public void sleep(int millis) { CurrentTimeMillis += millis; } 
} 

Quindi, ovunque si avrebbe chiamato System.getTimeMillis() invece chiamare MyTime.getTime(). Quando esegui il test del codice, crea semplicemente un TestTimeImpl e chiama MyTime.setTimeInterface (testTimeImpl). Quindi, quando si desidera che il tempo faccia avanzare la chiamata testTimeImpl.sleep() o testTimeImpl.setTime().

Ciò consente di simulare qualsiasi momento fino al millisecondo.