एंड्रॉइड टेस्ट फ्रेमवर्क के साथ Android AsyncTask परीक्षण


97

मेरे पास एक बहुत ही सरल AsyncTask कार्यान्वयन उदाहरण है और इसे Android JUnit ढांचे का उपयोग करके परीक्षण करने में समस्या हो रही है।

यह ठीक काम करता है जब मैं तुरंत आवेदन करता हूं और इसे सामान्य अनुप्रयोग में निष्पादित करता हूं। हालाँकि जब इसे किसी Android परीक्षण फ्रेमवर्क क्लासेस (यानी AndroidTestCase , ActivityUnitTestCase , ActivityInstrumentationTestCase2 आदि) से निष्पादित किया जाता है , तो यह अजीब व्यवहार करता है:

  • यह doInBackground()विधि को सही ढंग से निष्पादित करता है
  • हालांकि वह अपने सूचना विधियां (में से किसी का आह्वान नहीं करता है onPostExecute(), onProgressUpdate(), आदि) - बस चुपचाप उन्हें किसी भी त्रुटि के बिना दिखाए ध्यान नहीं देता।

यह बहुत ही सरल AsyncTask उदाहरण है:

package kroz.andcookbook.threads.asynctask;

import android.os.AsyncTask;
import android.util.Log;
import android.widget.ProgressBar;
import android.widget.Toast;

public class AsyncTaskDemo extends AsyncTask<Integer, Integer, String> {

AsyncTaskDemoActivity _parentActivity;
int _counter;
int _maxCount;

public AsyncTaskDemo(AsyncTaskDemoActivity asyncTaskDemoActivity) {
    _parentActivity = asyncTaskDemoActivity;
}

@Override
protected void onPreExecute() {
    super.onPreExecute();
    _parentActivity._progressBar.setVisibility(ProgressBar.VISIBLE);
    _parentActivity._progressBar.invalidate();
}

@Override
protected String doInBackground(Integer... params) {
    _maxCount = params[0];
    for (_counter = 0; _counter <= _maxCount; _counter++) {
        try {
            Thread.sleep(1000);
            publishProgress(_counter);
        } catch (InterruptedException e) {
            // Ignore           
        }
    }
}

@Override
protected void onProgressUpdate(Integer... values) {
    super.onProgressUpdate(values);
    int progress = values[0];
    String progressStr = "Counting " + progress + " out of " + _maxCount;
    _parentActivity._textView.setText(progressStr);
    _parentActivity._textView.invalidate();
}

@Override
protected void onPostExecute(String result) {
    super.onPostExecute(result);
    _parentActivity._progressBar.setVisibility(ProgressBar.INVISIBLE);
    _parentActivity._progressBar.invalidate();
}

@Override
protected void onCancelled() {
    super.onCancelled();
    _parentActivity._textView.setText("Request to cancel AsyncTask");
}

}

यह एक परीक्षण का मामला है। यहाँ AsyncTaskDemoActivity एक बहुत ही सरल गतिविधि है जो मोड में AsyncTask के परीक्षण के लिए UI प्रदान करती है:

package kroz.andcookbook.test.threads.asynctask;
import java.util.concurrent.ExecutionException;
import kroz.andcookbook.R;
import kroz.andcookbook.threads.asynctask.AsyncTaskDemo;
import kroz.andcookbook.threads.asynctask.AsyncTaskDemoActivity;
import android.content.Intent;
import android.test.ActivityUnitTestCase;
import android.widget.Button;

public class AsyncTaskDemoTest2 extends ActivityUnitTestCase<AsyncTaskDemoActivity> {
AsyncTaskDemo _atask;
private Intent _startIntent;

public AsyncTaskDemoTest2() {
    super(AsyncTaskDemoActivity.class);
}

protected void setUp() throws Exception {
    super.setUp();
    _startIntent = new Intent(Intent.ACTION_MAIN);
}

protected void tearDown() throws Exception {
    super.tearDown();
}

public final void testExecute() {
    startActivity(_startIntent, null, null);
    Button btnStart = (Button) getActivity().findViewById(R.id.Button01);
    btnStart.performClick();
    assertNotNull(getActivity());
}

}

यह सब कोड ठीक काम कर रहा है, इस तथ्य को छोड़कर कि एंड्रॉइड टेस्टिंग फ्रेमवर्क के भीतर निष्पादित होने पर AsyncTask इसे लागू नहीं करता है। कोई विचार?

जवाबों:


125

मैं कुछ यूनिट-टेस्ट को लागू करते समय एक समान समस्या से मिला। मुझे कुछ सेवा का परीक्षण करना था जो एक्ज़ीक्यूटर्स के साथ काम करता था, और मुझे अपने एप्लिकेशन कॉलस्टेस क्लासेस से टेस्ट विधियों के साथ मेरी सेवा कॉलबैक सिंक-एड की आवश्यकता थी। आमतौर पर कॉलबैक एक्सेस करने से पहले परीक्षण विधि स्वयं समाप्त हो जाती है, इसलिए कॉलबैक के माध्यम से भेजे गए डेटा का परीक्षण नहीं किया जाएगा। @UiThreadTest बस्ट लागू करने की कोशिश अभी भी काम नहीं किया।

मुझे निम्नलिखित विधि मिली, जिसने काम किया, और मैं अभी भी इसका उपयोग करता हूं। मैं बस प्रतीक्षा-सूचना को लागू करने के लिए CountDownLatch सिग्नल ऑब्जेक्ट्स का उपयोग करता हूं (आप सिंक्रोनाइज़ (लॉक) {... lock.ify ();}; हालांकि यह बदसूरत कोड) तंत्र में परिणाम देता है।

public void testSomething(){
final CountDownLatch signal = new CountDownLatch(1);
Service.doSomething(new Callback() {

  @Override
  public void onResponse(){
    // test response data
    // assertEquals(..
    // assertTrue(..
    // etc
    signal.countDown();// notify the count down latch
  }

});
signal.await();// wait for callback
}

1
क्या है Service.doSomething()?
पीटर अज़ताई

11
मैं एक AsynchTask का परीक्षण कर रहा हूं। क्या, और, ठीक है, पृष्ठभूमि का काम लगता है कि कभी भी बुलाया नहीं जाता है और हमेशा के लिए इंतजार कर रहा है :(
Ixx

@ XXX, क्या आपने task.execute(Param...)पहले कॉल किया था await()और अंदर डाला countDown()था onPostExecute(Result)? (देखें stackoverflow.com/a/5722193/253468 ) इसके अलावा @PeterAjtai, Service.doSomethingएक async कॉल है task.execute
ट्वीस्टेरोब

क्या एक प्यारा और सरल उपाय है।
मैकीज बेसिकिक

Service.doSomething()वह जगह है जहाँ आपको अपनी सेवा / एसिंक्स टास्क कॉल को बदलना चाहिए। signal.countDown()किसी भी विधि पर कॉल करना सुनिश्चित करें जिसे आपको लागू करने की आवश्यकता है या आपका परीक्षण अटक जाएगा।
विक्टर आर। ओलिवेरा

94

मुझे बहुत सारे करीबी जवाब मिले लेकिन उनमें से किसी ने भी सभी हिस्सों को सही ढंग से नहीं रखा। तो अपने JUnit परीक्षण मामलों में android.os.AsyncTask का उपयोग करते समय यह एक सही कार्यान्वयन है।

 /**
 * This demonstrates how to test AsyncTasks in android JUnit. Below I used 
 * an in line implementation of a asyncTask, but in real life you would want
 * to replace that with some task in your application.
 * @throws Throwable 
 */
public void testSomeAsynTask () throws Throwable {
    // create  a signal to let us know when our task is done.
    final CountDownLatch signal = new CountDownLatch(1);

    /* Just create an in line implementation of an asynctask. Note this 
     * would normally not be done, and is just here for completeness.
     * You would just use the task you want to unit test in your project. 
     */
    final AsyncTask<String, Void, String> myTask = new AsyncTask<String, Void, String>() {

        @Override
        protected String doInBackground(String... arg0) {
            //Do something meaningful.
            return "something happened!";
        }

        @Override
        protected void onPostExecute(String result) {
            super.onPostExecute(result);

            /* This is the key, normally you would use some type of listener
             * to notify your activity that the async call was finished.
             * 
             * In your test method you would subscribe to that and signal
             * from there instead.
             */
            signal.countDown();
        }
    };

    // Execute the async task on the UI thread! THIS IS KEY!
    runTestOnUiThread(new Runnable() {

        @Override
        public void run() {
            myTask.execute("Do something");                
        }
    });       

    /* The testing thread will wait here until the UI thread releases it
     * above with the countDown() or 30 seconds passes and it times out.
     */        
    signal.await(30, TimeUnit.SECONDS);

    // The task is done, and now you can assert some things!
    assertTrue("Happiness", true);
}

1
एक संपूर्ण उदाहरण लिखने के लिए धन्यवाद ... मुझे इसे लागू करने में बहुत छोटी समस्याएं हो रही थीं।
पीटर अज़ताई

सिर्फ 1 साल बाद, और आपने मुझे बचा लिया। शुक्रिया बिली ब्रैकीन!
MaTT

8
यदि आप एक परीक्षण असफलता के रूप में गिनना चाहते हैं, तो आप कर सकते हैं:assertTrue(signal.await(...));
जरीट मिलार्ड

4
अरे बिली मैं इस कार्यान्वयन की कोशिश की है, लेकिन runTestOnUiThread नहीं मिला है। क्या परीक्षण के मामले में AndroidTestCase का विस्तार होना चाहिए या क्या उसे ActivInstrumentationTestCase2 का विस्तार करने की आवश्यकता है?
डग रे

3
@DougRay मेरे पास एक ही मुद्दा था- यदि आप इंस्ट्रूमेंटेशनटेस्ट को बढ़ाते हैं तो runTestOnUiThread मिल जाएगा।
लूमिनायर

25

इससे निपटने का तरीका यह है कि किसी भी कोड को चलाने के लिए जो एक AsyncTask को आमंत्रित करता है runTestOnUiThread() :

public final void testExecute() {
    startActivity(_startIntent, null, null);
    runTestOnUiThread(new Runnable() {
        public void run() {
            Button btnStart = (Button) getActivity().findViewById(R.id.Button01);
            btnStart.performClick();
        }
    });
    assertNotNull(getActivity());
    // To wait for the AsyncTask to complete, you can safely call get() from the test thread
    getActivity()._myAsyncTask.get();
    assertTrue(asyncTaskRanCorrectly());
}

मुख्य एप्लिकेशन UI की तुलना में डिफ़ॉल्ट रूप से एक अलग थ्रेड में परीक्षण रन करता है। AsyncTask के प्रलेखन का कहना है कि कार्य उदाहरण और निष्पादित करने के लिए कॉल () मुख्य UI थ्रेड पर होना चाहिए; ऐसा इसलिए है क्योंकि AsyncTask मुख्य थ्रेड पर निर्भर करता है Looperऔर MessageQueueइसके आंतरिक हैंडलर के ठीक से काम करने के लिए।

ध्यान दें:

मैंने पहले @UiThreadTestपरीक्षण विधि पर एक डेकोरेटर के रूप में उपयोग करने की सिफारिश की थी ताकि परीक्षण को मुख्य थ्रेड पर चलाने के लिए मजबूर किया जा सके, लेकिन यह एक AsyncTask के परीक्षण के लिए बिल्कुल सही नहीं है क्योंकि जब आपकी परीक्षा विधि मुख्य थ्रेड पर चल रही होती है तो कोई संदेश संसाधित नहीं होता है मुख्य MessageQueue - संदेशों सहित AsyncTask इसकी प्रगति के बारे में भेजता है, जिससे आपका परीक्षण लटका हुआ है।


उसने मुझे बचाया ... हालाँकि मुझे अभी तक "runTestOnUiThread" कॉल करना था, अन्यथा मुझे एक और धागा मिला, "मुझे यह तरीका मुख्य एप्लिकेशन थ्रेड से नहीं बुलाया जा सकता"
Matthieu

@ मैथ्यू आप डेकोरेटर के runTestOnUiThread()साथ एक परीक्षण विधि से उपयोग कर रहे थे @UiThreadTest? यह काम नहीं करेगा। यदि एक परीक्षण विधि नहीं है @UiThreadTest, तो यह डिफ़ॉल्ट रूप से अपने गैर-मुख्य थ्रेड पर चलना चाहिए।
एलेक्स प्रिट्ज़लाव

1
वह जवाब शुद्ध गहना है। अद्यतन पर जोर देने के लिए इसे फिर से तैयार किया जाना चाहिए, यदि आप वास्तव में प्रारंभिक उत्तर रखना चाहते हैं, तो इसे कुछ पृष्ठभूमि स्पष्टीकरण और एक सामान्य नुकसान के रूप में डालें।
Snicolas

1
डॉक्यूमेंटेशन मेथड Deprecated in API level 24 डेवलपर डेवलपर.
android.com/reference/android/test/…

1
पदावनत, InstrumentationRegistry.getInstrumentation().runOnMainSync()बजाय उपयोग !
Marco7757

5

यदि आपको कॉलर थ्रेड में AsyncTask को निष्पादित करने में कोई आपत्ति नहीं है (यूनिट टेस्टिंग के मामले में ठीक होना चाहिए), तो आप वर्तमान थ्रेड में एक्जिक्यूटर का उपयोग कर सकते हैं जैसा कि https://stackoverflow.com/a/6583868/1266123 में वर्णित है।

public class CurrentThreadExecutor implements Executor {
    public void execute(Runnable r) {
        r.run();
    }
}

और फिर आप इस तरह से अपने यूनिट टेस्ट में अपना AsyncTask चलाते हैं

myAsyncTask.executeOnExecutor(new CurrentThreadExecutor(), testParam);

यह केवल हनीकोम्ब और उच्चतर के लिए काम कर रहा है।


यह ऊपर जाना चाहिए
स्टीफनटो

5

मैंने एंड्रॉइड के लिए पर्याप्त इकाइयाँ लिखी हैं और बस यह साझा करना चाहता हूँ कि कैसे करें।

सबसे पहले, यहाँ सहायक वर्ग है जो प्रतीक्षा करने और वेटर को रिहा करने के लिए जिम्मेदार है। कुछ खास नहीं:

SyncronizeTalker

public class SyncronizeTalker {
    public void doWait(long l){
        synchronized(this){
            try {
                this.wait(l);
            } catch(InterruptedException e) {
            }
        }
    }



    public void doNotify() {
        synchronized(this) {
            this.notify();
        }
    }


    public void doWait() {
        synchronized(this){
            try {
                this.wait();
            } catch(InterruptedException e) {
            }
        }
    }
}

इसके बाद, एक विधि के साथ इंटरफ़ेस बनाने की अनुमति देता है जिसे AsyncTaskकाम किए जाने पर कहा जाना चाहिए । यकीन है कि हम भी अपने परिणामों का परीक्षण करना चाहते हैं:

TestTaskItf

public interface TestTaskItf {
    public void onDone(ArrayList<Integer> list); // dummy data
}

अगला हमारे टास्क के कुछ कंकाल बनाने देता है जिन्हें हम परीक्षण करते हैं:

public class SomeTask extends AsyncTask<Void, Void, SomeItem> {

   private ArrayList<Integer> data = new ArrayList<Integer>(); 
   private WmTestTaskItf mInter = null;// for tests only

   public WmBuildGroupsTask(Context context, WmTestTaskItf inter) {
        super();
        this.mContext = context;
        this.mInter = inter;        
    }

        @Override
    protected SomeItem doInBackground(Void... params) { /* .... job ... */}

        @Override
    protected void onPostExecute(SomeItem item) {
           // ....

       if(this.mInter != null){ // aka test mode
        this.mInter.onDone(data); // tell to unitest that we finished
        }
    }
}

अंत में - हमारा सबसे पुराना वर्ग:

TestBuildGroupTask

public class TestBuildGroupTask extends AndroidTestCase  implements WmTestTaskItf{


    private SyncronizeTalker async = null;

    public void setUP() throws Exception{
        super.setUp();
    }

    public void tearDown() throws Exception{
        super.tearDown();
    }

    public void test____Run(){

         mContext = getContext();
         assertNotNull(mContext);

        async = new SyncronizeTalker();

        WmTestTaskItf me = this;
        SomeTask task = new SomeTask(mContext, me);
        task.execute();

        async.doWait(); // <--- wait till "async.doNotify()" is called
    }

    @Override
    public void onDone(ArrayList<Integer> list) {
        assertNotNull(list);        

        // run other validations here

       async.doNotify(); // release "async.doWait()" (on this step the unitest is finished)
    }
}

बस इतना ही।

आशा है कि यह किसी की मदद करेगा।


4

यदि आप doInBackgroundविधि से परिणाम का परीक्षण करना चाहते हैं तो इसका उपयोग किया जा सकता है । onPostExecuteविधि को ओवरराइड करें और वहां परीक्षण करें। CountDownLatch का उपयोग करने के लिए AsyncTask की प्रतीक्षा करने के लिए। latch.await()प्रतीक्षा करता है 0 से 1 से उलटी गिनती रन (जो आरंभीकरण के दौरान सेट है) (जो द्वारा किया जाता है तक countdown()विधि)।

@RunWith(AndroidJUnit4.class)
public class EndpointsAsyncTaskTest {

    Context context;

    @Test
    public void testVerifyJoke() throws InterruptedException {
        assertTrue(true);
        final CountDownLatch latch = new CountDownLatch(1);
        context = InstrumentationRegistry.getContext();
        EndpointsAsyncTask testTask = new EndpointsAsyncTask() {
            @Override
            protected void onPostExecute(String result) {
                assertNotNull(result);
                if (result != null){
                    assertTrue(result.length() > 0);
                    latch.countDown();
                }
            }
        };
        testTask.execute(context);
        latch.await();
    }

-1

उन समाधानों में से अधिकांश को प्रत्येक परीक्षण के लिए या अपनी कक्षा संरचना को बदलने के लिए बहुत सारे कोड की आवश्यकता होती है। अगर आपको परीक्षण के तहत कई स्थितियां या आपके प्रोजेक्ट पर कई AsyncTasks के कारण मुझे उपयोग करना बहुत मुश्किल लगता है।

एक पुस्तकालय है जो परीक्षण की प्रक्रिया को आसान बनाता है AsyncTask। उदाहरण:

@Test
  public void makeGETRequest(){
        ...
        myAsyncTaskInstance.execute(...);
        AsyncTaskTest.build(myAsyncTaskInstance).
                    run(new AsyncTest() {
                        @Override
                        public void test(Object result) {
                            Assert.assertEquals(200, (Integer)result);
                        }
                    });         
  }       
}

मूल रूप से, यह आपके AsyncTask को चलाता है और परिणाम के परीक्षण के बाद इसे वापस postComplete()बुलाया जाता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.