Android

Question

में जोर से फेंकने का परीक्षण कैसे करें एंड्रॉइड में एक जोर देने के लिए एक और शानदार तरीका है?

public void testGetNonExistingKey() { 
     try { 
      alarm.getValue("NotExistingValue"); 
      fail(); 
     } catch (ElementNotFoundException e) { 

     } 
} 

ऐसा कुछ काम नहीं करता है ?!

@Test(expected=ElementNotFoundException .class) 

धन्यवाद, मार्क

Answer 1

आप एक junit4 परीक्षण धावक का उपयोग कर रहे हैं? यदि आप जूनिट 3 टेस्ट रनर चला रहे हैं तो @ टेस्ट एनोटेशन काम नहीं करेगा। आप जिस संस्करण का उपयोग कर रहे हैं उसे जांचें।

दूसरा, आपके कोड में अपवादों की जांच करने का अनुशंसित तरीका नियम (जूनिट 4.7 में पेश किया गया) का उपयोग करना है।

@Rule 
public ExpectedException exception = ExpectedException.none(); 

@Test 
public void throwsIllegalArgumentExceptionIfIconIsNull() { 
    // do something 

    exception.expect(IllegalArgumentException.class); 
    exception.expectMessage("Icon is null, not a file, or doesn't exist."); 
    new DigitalAssetManager(null, null); 
} 

आप @Test उपयोग करने के लिए जारी रख सकते हैं (उम्मीद = IOException.class), लेकिन इसके बाद के संस्करण लाभ यह है कि अगर एक अपवाद exception.expect कहा जाता है से पहले फेंक दिया जाता है, तो परीक्षण असफल हो जायेगी है।

Answer 2

इस तरह मैं इसे करता हूं। मैं assertThrowsException नामक एक स्थैतिक विधि बनाता हूं जो तर्क के रूप में एक अपेक्षित अपवाद वर्ग और एक रननेबल के रूप में होता है जिसमें परीक्षण के तहत कोड होता है।

import junit.framework.Assert; 

public SpecialAsserts { 
    public void assertThrowsException(final Class<? extends Exception> expected, final Runnable codeUnderTest) { 
     try { 
      codeUnderTest.run(); 
      Assert.fail("Expecting exception but none was thrown."); 
     } catch(final Throwable result) { 
      if (!expected.isInstance(result)) { 
       Assert.fail("Exception was thrown was unexpected."); 
      } 
     } 
    } 
} 

यह (कि AndroidTestCase या उसके डेरिवेटिव में से एक प्रदान करता है) अपने परीक्षण वर्ग में विशेष ज़ोर उपयोग करने के लिए नमूना कोड है:

public void testShouldThrowInvalidParameterException() { 

    SpecialAsserts.assertThrowsException(InvalidParameterException.class, new Runnable() { 
     public void run() { 
      callFuncThatShouldThrow(); 
     } 
    }); 

} 

हाँ, वहाँ बहुत काम है, लेकिन यह बेहतर है जूनिट 4 को एंड्रॉइड पर पोर्ट करने से पहले।

Answer 3

मैंने कुछ सुधारों के साथ hopia's answer के समान कुछ किया। मैंने इसे अपवाद ऑब्जेक्ट वापस कर दिया ताकि आप इसका संदेश या किसी अन्य गुण की जांच कर सकें, और मैंने Runnable को प्रतिस्थापित करने के लिए Testable इंटरफ़ेस घोषित किया क्योंकि Runnable आपके कोड को टेस्ट फेंक अपवादों के नीचे नहीं जाने देता है।

public interface Testable { 
    public void run() throws Exception; 
} 

public <T extends Exception> T assertThrows(
     final Class<T> expected, 
     final Testable codeUnderTest) throws Exception { 
    T result = null; 
    try { 
     codeUnderTest.run(); 
     fail("Expecting exception but none was thrown."); 
    } catch(final Exception actual) { 
     if (expected.isInstance(actual)) { 
      result = expected.cast(actual); 
     } 
     else { 
      throw actual; 
     } 
    } 
    return result; 
} 

यहां कॉल करने का एक उदाहरण दिया गया है।

InvalidWordException ex = assertThrows(
    InvalidWordException.class, 
    new Testable() { 
     @Override 
     public void run() throws Exception { 
      model.makeWord("FORG", player2); 
     } 
    }); 

assertEquals(
     "message", 
     "FORG is not in the dictionary.", 
     ex.getMessage()); 

Answer 4

जूनिट 3 के साथ निम्नलिखित मदद कर सकता है।

public static void assertThrows(Class<? extends Throwable> expected, 
     Runnable runnable) { 
    try { 
     runnable.run(); 
    } catch (Throwable t) { 
     if (!expected.isInstance(t)) { 
      Assert.fail("Unexpected Throwable thrown."); 
     } 
     return; 
    } 
    Assert.fail("Expecting thrown Throwable but none thrown."); 
} 

public static void assertNoThrow(Runnable runnable) { 
    try { 
     runnable.run(); 
    } catch (Throwable t) { 
     Assert.fail("Throwable was unexpectedly thrown."); 
    } 
}