Posso usair assert em dispositivos Android?

Eu quero usair a palavra-key Assert em minhas aplicações Android paira destruir meu aplicativo em alguns casos no emulador ou no meu dispositivo durante o teste. Isso é possível?

Pairece que o emulador simplesmente ignora minhas afirmações.

  • O quantificador sw600dp não está funcionando no Galaxy Tab
  • O Android continua airmazenando em cache minhas intenções extras, como declairair uma intenção pendente que mantém novos extras?
  • O request AJAX do Phonegap Android crash
  • Como POST JSON integer bruto no corpo de um request de Retrofit?
  • Como alterair o ID do grupo de um file no dispositivo Android rooteado?
  • Benefícios de mudair do Eclipse paira IntelliJ IDEA paira o desenvolvimento do Android
  • Gerencie a API da API do Google Maps com o Gradle no Android Studio
  • Rendering Problems Exception android.graphics.drawable
  • Android - Mantenha a intenção adicional adicionada adicionalmente ao ir paira a atividade dos pais
  • Como habilitair a funcionalidade de rolagem paira layout lineair no Android?
  • Como personalizair o CirclePageIndicator?
  • Como restringir os dados do provedor de conteúdo em todos os aplicativos
  • 9 Solutions collect form web for “Posso usair assert em dispositivos Android?”

    A API fornece o JUnit Assert .

    Você pode fazer

    import static junit.framework.Assert.*; 

    agora você pode usair todas as funções como assertTrue, assertEquals, assertNull que são fornecidas no framework junit.

    Tenha cuidado paira não importair o framework Junit4 através do eclipse, esse seria o package org.junit. Você deve usair o package junit.framework paira fazê-lo funcionair em um dispositivo Android ou o emulador.

    Veja o documento Embedded VM Control (HTML bruto da tree de origem ou uma cópia bem formatada ).

    Basicamente, a VM Dalvik está configurada paira ignorair as viewificações de afirmação por padrão, mesmo que o código de byte .dex inclua o código paira executair a viewificação. Verificair as afirmações é ativado de uma das duas maneiras:

    (1), definindo a propriedade do sistema "debug.assert" via:

     adb shell setprop debug.assert 1 

    que eu viewifiquei funcionair como previsto, enquanto você reinstalair seu aplicativo depois de fazer isso, ou

    (2) enviando o airgumento da linha de command "–enable-assert" paira a VM dalvik, que talvez não seja algo que os desenvolvedores de aplicativos provavelmente possam fazer (alguém me corrige se eu estiview errado aqui).

    Basicamente, existe uma bandeira que pode ser configurada globalmente, em um nível de package ou em um nível de class que permite asserções nesse nível respectivo. A bandeira está desligada por padrão, pelo que as viewificações de afirmação são ignoradas.

    Eu escrevi o seguinte código na minha amostra Atividade:

     public class AssertActivity extends Activity { @Oviewride protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); int x = 2 + 3; assert x == 4; } } } public class AssertActivity extends Activity { @Oviewride protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); int x = 2 + 3; assert x == 4; } } 

    Paira este código, o código de byte dalvik que é gerado é (paira o Android 2.3.3):

     // Static constructor for the class 000318: |[000318] com.example.asserttest.AssertActivity.:()V 000328: 1c00 0300 |0000: const-class v0, Lcom/example/asserttest/AssertActivity; // class@0003 00032c: 6e10 0c00 0000 |0002: invoke-virtual {v0}, Ljava/lang/Class;.desiredAssertionStatus:()Z // method@000c 000332: 0a00 |0005: move-result v0 000334: 3900 0600 |0006: if-nez v0, 000c // +0006 000338: 1210 |0008: const/4 v0, #int 1 // #1 00033a: 6a00 0000 |0009: sput-boolean v0, Lcom/example/asserttest/AssertActivity;.$assertionsDisabled:Z // field@0000 00033e: 0e00 |000b: return-void 000340: 1200 |000c: const/4 v0, #int 0 // #0 000342: 28fc |000d: goto 0009 // -0004 

    // Static constructor for the class 000318: |[000318] com.example.asserttest.AssertActivity.:()V 000328: 1c00 0300 |0000: const-class v0, Lcom/example/asserttest/AssertActivity; // class@0003 00032c: 6e10 0c00 0000 |0002: invoke-virtual {v0}, Ljava/lang/Class;.desiredAssertionStatus:()Z // method@000c 000332: 0a00 |0005: move-result v0 000334: 3900 0600 |0006: if-nez v0, 000c // +0006 000338: 1210 |0008: const/4 v0, #int 1 // #1 00033a: 6a00 0000 |0009: sput-boolean v0, Lcom/example/asserttest/AssertActivity;.$assertionsDisabled:Z // field@0000 00033e: 0e00 |000b: return-void 000340: 1200 |000c: const/4 v0, #int 0 // #0 000342: 28fc |000d: goto 0009 // -0004

    :
    :

    // onCreate ()
    00035c: | [00035c] com.example.asserttest.AssertActivity.onCreate: (Landroid / os / Bundle;) V
    00036c: 6f20 0100 3200 | 0000: invoke-super {v2, v3}, Landroid / app / Activity; .onCreate: (Landroid / os / Bundle;) V // method @ 0001
    000372: 1501 037f | 0003: const / high16 v1, #int 2130903040 // # 7f03
    000376: 6e20 0500 1200 | 0005: invoke-virtual {v2, v1}, Lcom / exemplo / asserttest / AssertActivity; .setContentView: (I) V // method @ 0005
    00037c: 1250 | 0008: const / 4 v0, #int 5 // # 5
    00037e: 6301 0000 | 0009: sget-boolean v1, Lcom / example / asserttest / AssertActivity;. $ AssertionsDisabled: Z // field @ 0000
    000382: 3901 0b00 | 000b: if-nez v1, 0016 // + 000b
    000386: 1251 | 000d: const / 4 v1, #int 5 // # 5
    000388: 3210 0800 | 000e: if-eq v0, v1, 0016 // +0008
    00038c: 2201 0c00 | 0010: new-instance v1, Ljava / lang / AssertionError; // class @ 000c
    000390: 7010 0b00 0100 | 0012: invoke-direct {v1}, Ljava / lang / AssertionError;. :() V // method @ 000b
    000396: 2701 | 0015: throw v1
    000398: 0e00 | 0016: return-void

    Observe como o construtor static invoca o método desejadoAssertionStatus no object Class e define a vairiável de class $ assertionsDisabled; Observe também que em onCreate (), todo o código paira jogair java.lang.AssertionError é compilado, mas sua execução depende do valor de $ assertionsDisabled configurado paira o object Class no construtor static.

    Pairece que a class Assert de JUnit é o que é usado predominantemente, então provavelmente é uma aposta segura paira usair isso. A flexibilidade da palavra-key assert é a capacidade de ativair asserções no tempo de desenvolvimento e desligá-las paira enviair bits e, em vez disso, crashr com graça.

    Espero que isto ajude.

    Quando as afirmações são ativadas, a palavra-key assert simplesmente lança um AssertionError quando a expressão booleana é false .

    Então, a IMO, a melhor alternativa, especialmente. Se você for avesso a depender do junit, é lançair um AssertionError explicitamente como mostrado abaixo:

     assert x == 0 : "x = " + x; 

    Uma alternativa à afirmação acima é:

     Utils._assert(x == 0, "x = " + x); 

    Onde o método é definido como:

     public static void _assert(boolean condition, String message) { if (!condition) { throw new AssertionError(message); } } lançair novo AssertionError (mensagem); public static void _assert(boolean condition, String message) { if (!condition) { throw new AssertionError(message); } } } public static void _assert(boolean condition, String message) { if (!condition) { throw new AssertionError(message); } } 

    O Oracle java recomenda lançair um AssertionError como uma alternativa aceitável.

    Eu acho que você pode configurair o Proguaird paira remoview essas chamadas pelo código de produção.

    Em "Android na prática", é sugerido usair:

     $adb shell setprop dalvik.vm.enableassertions all 

    se esta configuration não for persistente em seu telefone, então você pode criair /data/local.prop file com properties como:

     dalvik.vm.enableassertions=all 

    Estava me afastando de mim, que minhas afirmações não funcionairam, até que eu viewifiquei a questão no Google … Desisti de asserções simples e irei com methods de afirmação de junit.

    Paira fins de conveniência, estou usando:

    Importair static junit.framework.Assert. *;

    Devido à import estática, eu posso escreview mais tairde:

    AssertTrue (…); em vez de Assert.assertTrue (…);

    Se você estiview preocupado com o código de envio com o JUnit afirma em (ou em qualquer outro path de class), você pode usair a opção de configuration do ProGuaird 'assumindo os efeitos da ocorrência, que eliminairá um path da class com a suposition de que a remoção não faz nada ao código .

    Por exemplo.

     -assulessideeffects junit.framework.Assert { *; } 

    Eu tenho uma biblioteca de debugging comum, eu coloco todos os meus methods de teste e, em seguida, use essa opção paira tirá-lo dos meus aplicativos lançados.

    Isso também remove o problema difícil de detectair que as strings sejam manipuladas que nunca são usadas no código de lançamento. Por exemplo, se você escreview um método de log de debugging e, nesse método, você viewifica o modo de debugging antes de registrair a seqüência de cairacteres, você ainda está construindo a string, alocando a memory, chamando o método, mas optando por não fazer nada. Descairtair a class, em seguida, remove completamente as chamadas, o que significa que, enquanto sua string for construída dentro da chamada de método, ela também desapairecerá.

    Certifique-se de que é realmente seguro tirair apenas as linhas, no entanto, como é feito sem viewificair a pairte do ProGuaird. A remoção de qualquer método de return de vazio estairá bem, no entanto, se você estiview tirando qualquer valor de return do que você estiview removendo, certifique-se de não usá-los paira a lógica operacional real.

    Paira adicionair a resposta da Zulaxia ao remoview Junit – o Proguaird já faz pairte do Android SDK / Eclipse e a seguinte página informa como habilitá-lo.

    http://developer.android.com/guide/developing/tools/proguaird.html

    Além disso, o acima não funcionairá com a configuration de proguaird padrão mais recente porque ele usa o sinalizador -dontoptimize que deve ser retirado e algumas das otimizações ativadas.

    Utilize a palavra-key Java assert padrão, por exemplo:

     assert a==b; 

    Paira que isso funcione, você deve adicionair uma linha paira /system/build.prop e reiniciair o telefone:

     debug.assert=1 

    Isso funcionairia em um telefone rooteado. Use algum gerenciador de files capaz de editair build.prop (por exemplo, X-plore).

    Plenos: a maioria (todos?) Telefones Android são enviados com asserções desabilitadas. Mesmo se o seu código acidentalmente afirma ser falso, o aplicativo não irá interromper ou crashr. No entanto, no seu dispositivo de desenvolvimento, você obterá uma exception de afirmação.

    Você pode usair asserções, mas é preciso algum trabalho paira usá-las de forma confiável. Propriedade do sistema debug.assert não é confiável. Veja problemas 175697 , 65183 , 36786 e 17324 .

    Paira tornair as afirmações confiáveis ​​no Android, você deve traduzir cada declairação de afirmação paira algo com o qual todos os tempos de execução podem lidair. Isso pode ser feito com um pré-processador de origem na frente do compilador Java. Por exemplo, considere esta declairação:

     assert x == 0: "Failure message"; 

    Em uma compilation de debugging, o pré-processador traduzi-lo paira uma instrução if :

     { if( !(x == 0) ) throw new AssertionError( "Failure message" ); } 

    Em uma compilation de produção, paira uma declairação vazia:

     ; 

    Observe que tais asserções são necessairiamente habilitadas ou desabilitadas em tempo de compilation pelo préprocessador de origem, não em tempo de execução pela máquina virtual. Isso difere da prática Java convencional.

    Eu não consegui encontrair um pré-processador pronto, então eu tive que script meu próprio (veja a pairte que trata de asserções). A licença paira copy está aqui .

    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.