मैं एंड्रॉइड स्टूडियो में टेस्ट कैसे बना सकता हूं?


109

बस एंड्रॉइड स्टूडियो डाउनलोड किया गया है जो इंटेलीज आइडिया से दूर है।

टेस्ट कैसे बनाएंगे?

मुझे लगता है कि टेस्ट मॉड्यूल बनाने के लिए एक विकल्प है, लेकिन यह कुछ भी करने के लिए प्रतीत नहीं होता है, केवल src के साथ एक नया प्रोजेक्ट बनाएं

मैंने हॉट कुंजी CTRL + AlT + T दबाने की भी कोशिश की, जो एक मौजूदा वर्ग पर इकाई परीक्षण बनाने की अनुमति देता है, लेकिन लगता है कि इसे वर्तमान परियोजना में रखना चाहता है। बेशक यह टीडीडी के साथ मदद नहीं करता है

क्या किसी को यहाँ कोई अनुभव है?


2
मैंने एक टेस्ट प्रोजेक्ट बनाने की भी कोशिश की है। यदि आप इसे एंड्रॉइड कमांड लाइन टूल के साथ करते हैं जैसे आप एक एक्लिप्स प्रोजेक्ट के साथ करेंगे, तो आपको एक त्रुटि मिलती है क्योंकि यह AndroidManifest.xml फ़ाइल नहीं ढूंढ सकता है। ऐसा लगता है कि Google को Grundle प्रोजेक्ट से निपटने के लिए अपने Android टूल को अपडेट करने की आवश्यकता है। हालाँकि, मैं एंड्रॉइड में परीक्षण करने के लिए नया हूं, इसलिए मैं आपकी मदद नहीं कर सकता हूं = (
केज

जवाबों:


56

यह उत्तर उन लोगों के लिए है जो अभी Android परीक्षण के साथ शुरू हो रहे हैं। मैं दो सरल उदाहरण प्रदान करने में आपकी मदद करूँगा कि परीक्षण कैसे काम करता है। यदि आप अगले 10 मिनट के लिए साथ आते हैं, तो आप अपने स्वयं के ऐप में अपने परीक्षण जोड़ना शुरू करने के लिए पूरी तरह तैयार हो जाएंगे। मुझे लगता है कि आपको आश्चर्य होगा कि यह कितना आसान है। मैं निश्चित रूप से था।

Android परीक्षण के लिए परिचय

दो अलग-अलग प्रकार के परीक्षण हैं जो आप करेंगे।

  • स्थानीय इकाई परीक्षण। ये JVM (जावा वर्चुअल मशीन) पर स्थानीय रूप से चलाए जाते हैं। चूंकि वे स्थानीय हैं, वे तेज हैं। आप अपने कोड के उन हिस्सों का परीक्षण करने के लिए उनका उपयोग कर सकते हैं जिन्हें सिर्फ जावा की आवश्यकता है न कि एंड्रॉइड एपीआई की। (कभी-कभी आप स्थानीय रूप से अधिक चीजों का परीक्षण करने के लिए एक नकली एपीआई ऑब्जेक्ट बना सकते हैं। इसे मॉकिंग कहा जाता है । मॉक Contextएक उदाहरण है।)
  • यंत्र परीक्षण। ये परीक्षण एक वास्तविक डिवाइस पर या एमुलेटर में चलाए जाते हैं। यह उन्हें स्थानीय परीक्षणों की तुलना में धीमा बनाता है। हालाँकि, वे अधिक लचीले हैं क्योंकि आपके पास पूर्ण Android API आपके लिए उपलब्ध है।

एक नया प्रोजेक्ट बनाएं और आपको निम्नलिखित डिफ़ॉल्ट फ़ोल्डर दिखाई देंगे।

यहां छवि विवरण दर्ज करें

सब कुछ पहले से ही है और आपके परीक्षण बनाने के लिए आपका इंतजार कर रहा है। यह सब पहले से ही सेट है!

स्थानीय इकाई परीक्षण कैसे बनाएं

ExampleUnitTestऊपर की इमेज में दिखाई गई फाइल को खोलें । यह कुछ इस तरह दिखना चाहिए:

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        assertEquals(4, 2 + 2);
    }
}

सभी परीक्षणों को चलाने के लिए डबल ग्रीन एरो को दबाएं या केवल एक को चलाने के लिए सिंगल ग्रीन एरो को चलाएं। (इस मामले में केवल एक परीक्षण है इसलिए वे दोनों एक ही काम करते हैं।)

यहां छवि विवरण दर्ज करें

इसे पास करना चाहिए ( जब तक आप 2 + 2अभी भी 4इस उत्तर को पढ़ रहे हैं)। बधाई हो, आपने अभी अपना पहला परीक्षण चलाया है!

अपना खुद का परीक्षण करना

आइए हम अपना परीक्षण लिखें। पहले इस क्लास को अपने मुख्य ऐप प्रोजेक्ट में जोड़ें ताकि हमें परीक्षण करने के लिए कुछ हो:

public class MyClass {
    public int add(int a, int b) {
        return a + b;
    }
}

अब addition_isCorrect()टेस्ट क्लास में विधि को निम्न कोड की तरह बदलें (या किसी अन्य नाम के साथ एक और विधि जोड़ें):

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        MyClass myClass = new MyClass();
        int result = myClass.add(2, 2);
        int expected = 4;
        assertEquals(expected, result);
    }
}

इसे फिर से चलाएं और आपको इसे पास होना चाहिए। बधाई हो, आपने अभी अपना पहला टेस्ट बनाया है! (खैर, मुझे लगता है कि तकनीकी रूप से यह मेरा था, लेकिन, हे, काफी करीब है। मेरा क्या है तुम्हारा।)

इंस्ट्रूमेंटेड टेस्ट कैसे बनाएं

ExampleInstrumentedTestफ़ाइल खोलें । यह कुछ इस तरह दिखना चाहिए:

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
    @Test
    public void useAppContext() throws Exception {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        assertEquals("com.example.myapp", appContext.getPackageName());
    }
}

उन हरे बटन में से एक को फिर से दबाएं।

यहां छवि विवरण दर्ज करें

जब तक आपके पास एक वास्तविक उपकरण जुड़ा हुआ है या एमुलेटर सेट है, तब तक इसे शुरू करना चाहिए और अपना ऐप चलाना चाहिए। बधाई हो, आपने अभी-अभी अपना पहला यंत्र परीक्षण किया है!

अपना खुद का परीक्षण करना

इंस्ट्रूमेंटेड टेस्ट्स को चलाने के लिए एस्प्रेसो का इस्तेमाल करते हैं। यह अपने छोटे रोबोट उपयोगकर्ता की तरह है कि आप अपने ऐप का परीक्षण कर सकते हैं। आप इसे एक बटन दबाने या टेक्स्ट व्यू के गुणों को पढ़ने के लिए कुछ करने के लिए कह सकते हैं।

आप परीक्षण को हाथ से कैसे करें, इसके निर्देश लिख सकते हैं, लेकिन चूंकि हम अभी शुरू कर रहे हैं, इसलिए ऑटो-रिकॉर्ड फ़ंक्शन का उपयोग करें । यह सुपर सरल है।

पहले अपने UI में एक बटन जोड़ें ताकि हमारे पास काम करने के लिए कुछ हो। इसे मैने किया है:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.myapp.MainActivity">

    <Button
        android:id="@+id/myButton"
        android:text="Click me"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

</android.support.constraint.ConstraintLayout> 

फिर मेनू में रन> रिकॉर्ड एस्प्रेसो टेस्ट दबाएं ।

यहां छवि विवरण दर्ज करें

इसके शुरू होने के बाद, एमुलेटर में बटन पर क्लिक करें और फिर रिकॉर्ड डायलॉग पर ओके चुनें। यह निम्नलिखित परीक्षण कोड उत्पन्न करना चाहिए।

@LargeTest
@RunWith(AndroidJUnit4.class)
public class MainActivityTest {

    @Rule
    public ActivityTestRule<MainActivity> mActivityTestRule = new ActivityTestRule<>(MainActivity.class);

    @Test
    public void mainActivityTest() {
        ViewInteraction appCompatButton = onView(
                allOf(withId(R.id.myButton), withText("Click me"), isDisplayed()));
        appCompatButton.perform(click());
    }
}

महान! आपने अभी-अभी पहला यंत्र परीक्षण बनाया है! यह सुपर आसान था। आपको शायद इसे वास्तविक परीक्षा बनाने के लिए जोर देना चाहिए, लेकिन यह रिकॉर्डर के साथ बहुत आसान है। थोड़ा गहरा जाने के लिए यह वीडियो देखें ।

आगे के अध्ययन

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


1
शानदार जवाब @Suragch। त्वरित प्रश्न: मैं स्थानीय इकाई परीक्षण मामले के लिए समर्थन फाइलें कहां रखूंगा? यह हैकरी है, लेकिन मुझे परीक्षण के आधार से पूरा रास्ता डालकर खुशी होगी, लेकिन अगर मैं एंड्रॉइड स्टूडियो में दौड़ता हूं, तो परीक्षण root_/app से चलते हैं , हालांकि अगर मैं ग्रैड कमांड लाइन (या CI) से चलता हूं तो यह है _root । (आदर्श रूप से मैं विशिष्ट assetsफ़ोल्डरों का उपयोग करना चाहता हूं जब किसी भी तरह से चलाया जाता है)।
mm2001

@ mm2001, मैंने यह उत्तर लिखने के तरीके के रूप में खुद को परीक्षण करने के तरीके के रूप में लिखा है, इसलिए मैंने अभी तक आपके पास जितना भी प्राप्त नहीं किया है। यदि आप मेरे करने से पहले यह पता लगा लेते हैं, तो क्या आप एक टिप्पणी छोड़ सकते हैं?
सुरगाछ

मुझे यह उपयोगी लगा: stackoverflow.com/a/42751502/19506 - यह कहता है कि एक फ़ोल्डर बनाएं test/resourcesऔर वहाँ फाइलें डालें, जैसे test.txtऔर उनके साथ पहुँचें getClass().getClassLoader().getResource("test.txt")। मैंने निर्णय लिया है कि एपीके एसेट्स को सीधे एक्सेस करना एक बुरा विचार है, इसलिए मैं इससे निपटने के लिए फाइलों को कॉपी स्टेप या बिल्ड एक्सटर्नल प्रोसेस में टेस्ट करूंगा। ग्रैडल के विभिन्न संस्करणों के बारे में कुछ सवाल शेष हैं, लेकिन मैंने अभी तक इसका सामना नहीं किया है।
mm2001

36

संपादित करें: 0.1.8 तक यह अब IDE में समर्थित है । कृपया नीचे दिए गए निर्देशों का उपयोग करने के बजाय, वहां दिए गए निर्देशों का पालन करें।

बाद एंड्रॉयड Gradle प्लगइन उपयोगकर्ता गाइड मैं एक नव निर्मित परियोजना पर निम्नलिखित चरणों को करके कमांड लाइन पर काम कर परीक्षण प्राप्त करने में सक्षम था (मैं डिफ़ॉल्ट 'com.example.myapplication' पैकेज का इस्तेमाल किया):

  1. परीक्षणों के लिए एक src / instrumentTest / जावा निर्देशिका जोड़ें
  2. पैकेज com.example.myapplication.test पैकेज में एक परीक्षण वर्ग (एक्टीविटीटेस्ट को बढ़ाएं) जोड़ें
  3. वर्चुअल डिवाइस शुरू करें
  4. कमांड लाइन पर (MyApplicationProject / MyApplication निर्देशिका में) कमांड का उपयोग करें '../gradlew connectInstrumentTest'

इसने मेरे परीक्षणों को चलाया और MyApplicationProject / MyApplication / build / रिपोर्ट / instrumentTests / कनेक्ट में परीक्षण के परिणाम दिए। मैं एंड्रॉइड ऐप्स का परीक्षण करने के लिए नया हूं, लेकिन यह ठीक काम करता है।

आईडीई के भीतर से, एक ही परीक्षण वर्ग को चलाने और चलाने के लिए संभव है। आपको करने की आवश्यकता होगी

  1. एक रेपो के रूप में मावेन सेंट्रल को सूचीबद्ध करने के लिए build.gradle को अपडेट करें
  2. अद्यतन build.gradle एक साधन के रूप में JUnit 3.8 जोड़ें। TestCompile निर्भरता जैसे instrumentTestCompile 'जून: जूनियर: 3.8'
  3. 'प्रोजेक्ट स्ट्रक्चर' में मैन्युअल रूप से JUnit को स्थानांतरित करके निर्भरता क्रम में पहले स्थान पर होना चाहिए

हालाँकि यह विफल हो जाता है (परीक्षण चलाने के दौरान उपयोग किया जाने वाला क्लासपाथ परीक्षण आउटपुट निर्देशिका को याद नहीं कर रहा है)। हालांकि, मुझे यकीन नहीं है कि यह मेरी समझ के बिना काम करेगा क्योंकि यह एक Android विशिष्ट परीक्षण धावक की आवश्यकता है।


20

मैं gradle.build फ़ाइल का उपयोग करने का सुझाव दूंगा

  1. परीक्षणों के लिए एक src / androidTest / java निर्देशिका जोड़ें (जैसे क्रिस स्पष्ट करना शुरू करता है)

  2. Gradle.build फ़ाइल खोलें और वहाँ निर्दिष्ट करें:

    android {
    
        compileSdkVersion rootProject.compileSdkVersion
        buildToolsVersion rootProject.buildToolsVersion
    
        sourceSets {
    
            androidTest {
                java.srcDirs = ['androidTest/java']
            }
        }
    }
  3. "ग्रेड फ़ाइल के साथ सिंक प्रोजेक्ट" दबाएं (शीर्ष पैनल पर)। अब आपको देखना चाहिए कि एक फ़ोल्डर "जावा" ("एंड्रॉइडटेस्ट" के अंदर) एक हरे रंग का रंग है।

  4. अब आप वहां कोई भी परीक्षण फाइल बनाने और उन्हें निष्पादित करने में सक्षम हैं।


AndroidTest.setRoot ('instrumentTest') को न भूलें
IgGanapolsky

3
वर्तमान एंड्रॉइड स्टूडियो संस्करण में यह आवश्यक नहीं है, अधिक से अधिक - एंड्रॉइडटेस्ट के साथ एक नाम इंस्ट्रूमेंट के साथ सब कुछ बदलें
यूरी

'इंस्ट्रूमेंट' और 'एंड्रॉइडटेस्ट' नाम पूरी तरह से मनमाने हैं। वे आपके परीक्षण प्रोजेक्ट के लिए केवल निर्देशिका नाम हैं। आप बस 'परीक्षण' निर्देशिका बना सकते हैं। इसके अलावा, परीक्षण ढांचे में SDK के पैकेज का नाम android.test.InstrumentationTestCase है। इसलिए कैनोनिक रूप से मेरा मानना ​​है कि 'इंस्ट्रूमेंटेशन' या 'इंस्ट्रूमेंटेशन' अभी भी किसी के परीक्षणों के नामकरण के लिए समझ में आता है। निम्नलिखित सोर्सकोड
IgGanapolsky

7
कृपया, यहाँ प्रलेखन पढ़ें: tools.android.com/tech-docs/new-build-system । चूंकि संस्करण 0.9.0 इंस्ट्रूमेंटेस्ट का नाम बदलकर androidTest रखा गया था ।
यूरी चेर्नशोव 5

1
के रूप में @IgorGanapolsky नामकरण फ़ोल्डर androidTest मनमाने ढंग से नहीं है। यह फ़ोल्डर के लिए हरे रंग को चालू करने के लिए किया जाना चाहिए।
घड़ी


10

Android Studio v.2.3.3

कोड संदर्भ को हाइलाइट करें जिसे आप परीक्षण करना चाहते हैं, और हॉटकी का उपयोग करें: CTRL+ SHIFT+T

अपना सेटअप पूरा करने के लिए संवाद इंटरफ़ेस का उपयोग करें।

परीक्षण रूपरेखा को सर्वोत्तम परिणामों के लिए आपके प्रोजेक्ट पैकेज लेआउट को दर्पण करने के लिए माना जाता है, लेकिन आप मैन्युअल रूप से कस्टम परीक्षण बना सकते हैं, बशर्ते आपके पास सही निर्देशिका और सेटिंग्स का निर्माण हो।


7

अब तक (स्टूडियो 0.61) उचित परियोजना संरचना बनाए रखना पर्याप्त है। ग्रहण में अलग परीक्षण परियोजना बनाने की आवश्यकता नहीं है (नीचे देखें)।

टेस्ट संरचना


4

एंड्रॉइड स्टूडियो विकसित होता रहता है इसलिए ऊपर की प्रतिक्रियाएं अब लागू नहीं होंगी। एंड्रॉइड स्टूडियो 1.2.1.1 के वर्तमान संस्करण के लिए, परीक्षण में एक अच्छा ट्यूटोरियल है:

http://evgenii.com/blog/testing-activity-in-android-studio-tutorial-part-1/


2
हां, एएस विकसित होता रहता है, इसलिए किसी को अत्याधुनिक तकनीक के बारे में लेख बनाने के लिए मूर्खतापूर्ण है, और उस पर लागू संस्करण संख्या का उल्लेख कभी नहीं करना चाहिए। एकमात्र सुराग बहुत नीचे की तारीख है।
टॉम

3

एक बड़ा बदलाव यह लगता है कि एंड्रॉइड स्टूडियो के साथ परीक्षण एप्लिकेशन को एप्लिकेशन प्रोजेक्ट में एकीकृत किया गया है।

मुझे यकीन नहीं है कि यह आपकी विशिष्ट समस्या में मदद करता है, लेकिन मुझे ग्रैडल परियोजना के साथ परीक्षण करने पर एक मार्गदर्शिका मिली। एंड्रॉयड ग्रैड उपयोगकर्ता गाइड


3

सबसे आसान तरीका है जो मैंने अपने ब्लॉग पोस्ट में सुव्यवस्थित किया है :

  1. एक फ़ोल्डर बनाएँ जिसमें आप अपने सभी यूनिट परीक्षण (अधिमानतः com.example.app.tests) लिखेंगे
  2. एक नया परीक्षण वर्ग बनाएं (अधिमानतः NameOfClassTestedTests, अर्थात् BankAccountLoginActivityTests)
  3. इंस्ट्रूमेंटेशनटेस्टकेज़ का विस्तार करें
  4. यह सुनिश्चित करने के लिए कि हम इकाई परीक्षणों को सफल बनाने में असफल इकाई परीक्षण लिखें
  5. ध्यान दें कि एक इकाई परीक्षण विधि का नाम "परीक्षण" शब्द से शुरू होना चाहिए (अधिमानतः परीक्षण किया गया मीथोडननामExpectedResult () अर्थात testBankAccountValidationFailedShouldLogout ())
  6. इकाई परीक्षणों के लिए अपनी परियोजना को कॉन्फ़िगर करें:
  7. 'रन ...' मेनू खोलें और 'कॉन्फ़िगरेशन संपादित करें' पर क्लिक करें
  8. + बटन पर क्लिक करें
  9. Android टेस्ट टेम्पलेट चुनें
  10. अपने रन कॉन्फ़िगरेशन के लिए एक नाम इनपुट करें (अधिमानतः 'AppName टेस्ट')
  11. मॉड्यूल कॉम्बोक्स में अपना ऐप चुनें
  12. "ऑल इन पैकेज" रेडियो बटन का चयन करें (आम तौर पर आप इस विकल्प का चयन करना चाहेंगे क्योंकि यह आपके सभी परीक्षण वर्गों में सभी यूनिट परीक्षण चलाता है)
  13. चरण 1 से परीक्षा पैकेज नाम भरें (यानी com.example.app.tests)
  14. उस उपकरण का चयन करें जिस पर आप अपने परीक्षण चलाना चाहते हैं
  15. कॉन्फ़िगरेशन को लागू करें और सहेजें
  16. इकाई परीक्षण चलाएं (और असफलता की उम्मीद करें):
  17. रन मेनू से अपने नए बनाए गए टेस्ट कॉन्फ़िगरेशन का चयन करें
  18. रन पर क्लिक करें और आउटपुट कंसोल में परिणाम पढ़ें

सौभाग्य आपके कोड को और अधिक पठनीय, बनाए रखने योग्य और अच्छी तरह से परीक्षण कर रहा है!


प्रश्न इंस्ट्रूमेंटेशन टेस्ट के बारे में था! मुझे कुछ इंस्ट्रूमेंटेशन टेस्ट लिखने में भी मुश्किलें आती हैं। मेरा सवाल देखें stackoverflow.com/questions/35426990/…
मोनिका

2

एंड्रॉइड स्टूडियो एक चलती लक्ष्य की तरह रहा है, पहले एक डेवलपर पूर्वावलोकन और अब बीटा में जा रहा है। प्रोजेक्ट में टेस्ट कक्षाओं के लिए पथ समय के साथ बदल गया है, लेकिन कोई फर्क नहीं पड़ता कि आप किस संस्करण का उपयोग कर रहे हैं, पथ आपके .iml फ़ाइल में घोषित किया गया है। वर्तमान में, संस्करण 0.8.3 के साथ, आपको निम्नलिखित आंतरिक फ़ाइल के अंदर मिलेगा:

      <sourceFolder url="file://$MODULE_DIR$/src/androidTest/res" type="java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/resources" type="java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/assets" type="java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/aidl" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/java" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/groovy" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/jni" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/rs" isTestSource="true" />

.Iml फ़ाइल आपको बता रही है कि आपको अपनी परीक्षण कक्षाएं कहाँ रखनी हैं।


2

एंड्रॉइड स्टूडियो 1.1 के रूप में, हमें यूनिट टेस्ट (रोबोइलेक्ट्रिक काम करता है) लिखने के लिए आधिकारिक (प्रायोगिक) समर्थन मिला है।

स्रोत: https://sites.google.com/a/android.com/tools/tech-docs/unit-testing-support


Android परीक्षण लिखने के लिए समर्थन, नए समर्थन परीक्षण पुस्तकालय के साथ, बस बढ़ गया। आप यहाँ एक अच्छी प्रस्तुति देख सकते हैं: docs.google.com/pretation/d/…
मर्सडी बर्डन

0

प्रवेश फ़ाइल के अंदर lib से नीचे जोड़ें

 androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })

AndroidTest डाइरेक्टरी के अंदर क्लास होमएक्टिविटीटेस्ट बनाएं और टेस्ट को चलाने से पहले स्ट्रिंग रिसोर्स फाइल के अंदर flurry_api_key और भेजने वाले को जोड़ें। विफलता और सफलता के मामले में वैल्यू बदलें।

@RunWith(AndroidJUnit4.class)
public class HomeActivityTest
{
    private static final String SENDER_ID = "abc";
    private static final String RELEASE_FLURRY_API_KEY = "xyz";

    @Test
    public void gcmRegistrationId_isCorrect() throws Exception
    {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        Assert.assertEquals(SENDER_ID, appContext.getString(R.string.sender_id));
    }

    @Test
    public void flurryApiKey_isCorrect() throws Exception
    {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        Assert.assertEquals(RELEASE_FLURRY_API_KEY, appContext.getString(R.string.flurry_api_key));
    }
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.