Instrumented tests in Android Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to annotate an instrumented test class.

Android Kotlin

import androidx.test.ext.junit.runners.AndroidJUnit4

@[1]
class ExampleInstrumentedTest {
}

Drag options to blanks, or click blank then click option'

ABefore

BRunWith(AndroidJUnit4::class)

CTest

DIgnore

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Test instead of @RunWith for the class annotation.

Forgetting to specify the test runner causes the test not to run on device.

The @RunWith(AndroidJUnit4::class) annotation tells the test runner to use the AndroidJUnit4 class for instrumented tests.

2fill in blank

medium

Complete the code to mark a function as an instrumented test.

Android Kotlin

import org.junit.Test

class ExampleInstrumentedTest {
    @[1]
    fun useAppContext() {
        // test code here
    }
}

Drag options to blanks, or click blank then click option'

ATest

BBefore

CIgnore

DAfter

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Before or @After instead of @Test for test methods.

Forgetting to annotate test functions causes them not to run.

The @Test annotation marks a function as a test method to be run by the test runner.

3fill in blank

hard

Fix the error in the code to get the app context in an instrumented test.

Android Kotlin

import androidx.test.platform.app.InstrumentationRegistry

val appContext = InstrumentationRegistry.[1].targetContext

Drag options to blanks, or click blank then click option'

AgetInstrumentation()

BgetContext()

CgetTargetContext()

DgetApplicationContext()

Attempts:

3 left

💡 Hint

Common Mistakes

Calling getContext() or getTargetContext() directly on InstrumentationRegistry causes errors.

Using getApplicationContext() is not available here.

The getInstrumentation() method returns the Instrumentation instance, from which you can get the target context.

4fill in blank

hard

Fill both blanks to launch an activity in an instrumented test.

Android Kotlin

import androidx.test.core.app.ActivityScenario

val scenario = ActivityScenario.[1](MainActivity::class.[2])

Drag options to blanks, or click blank then click option'

Alaunch

Bjava

Cstart

Dkotlin

Attempts:

3 left

💡 Hint

Common Mistakes

Using start() instead of launch() causes errors.

Passing MainActivity::class without .java causes type errors.

ActivityScenario.launch() starts the activity for testing. The java property gets the Java class reference.

5fill in blank

hard

Fill all three blanks to assert the app package name in an instrumented test.

Android Kotlin

import androidx.test.platform.app.InstrumentationRegistry
import org.junit.Assert.*

val appContext = InstrumentationRegistry.[1].targetContext
assertEquals("[2]", appContext.[3].packageName)

Drag options to blanks, or click blank then click option'

AgetInstrumentation()

Bcom.example.myapp

CapplicationContext

DgetContext()

Attempts:

3 left

💡 Hint

Common Mistakes

Using getContext() instead of getInstrumentation() causes errors.

Accessing packageName directly on appContext without applicationContext may cause issues.

Use getInstrumentation() to get the Instrumentation, then get the applicationContext from the target context to check the package name.

Practice

1. What is the main purpose of instrumented tests in Android development?

easy

A. To test only the backend logic without UI

B. To write unit tests that run on the local JVM

C. To run tests on real devices or emulators to check app behavior

D. To create UI layouts for the app

Solution

1. Step 1: Understand what instrumented tests do

   Instrumented tests run on actual devices or emulators to test app behavior in a real environment.

2. Step 2: Compare with other test types

   Unit tests run locally on JVM and do not test device features or UI on real devices.

3. Final Answer:

   To run tests on real devices or emulators to check app behavior -> Option C

4. Quick Check:

   Instrumented tests = run on device/emulator [OK]

Hint: Instrumented tests run on devices, not just local JVM [OK]

Common Mistakes:

• Confusing instrumented tests with unit tests
• Thinking instrumented tests only test backend logic
• Assuming instrumented tests create UI layouts

2. Which annotation is required to run an instrumented test with AndroidJUnit4?

easy

A. @RunWith(AndroidJUnit4::class)

B. @Ignore

C. @Before

D. @Test

Solution

1. Step 1: Identify the runner annotation

   Instrumented tests need the @RunWith(AndroidJUnit4::class) annotation to specify the test runner.

2. Step 2: Differentiate from other annotations

   @Test marks test methods, @Before runs setup code, @Ignore skips tests; none specify the runner.

3. Final Answer:

   @RunWith(AndroidJUnit4::class) -> Option A

4. Quick Check:

   Runner annotation = @RunWith(AndroidJUnit4::class) [OK]

Hint: Use @RunWith(AndroidJUnit4::class) to set test runner [OK]

Common Mistakes:

• Using @Test instead of @RunWith for runner
• Confusing @Before with runner annotation
• Forgetting to add any runner annotation

3. Given this instrumented test code snippet, what will be the output?

val appContext = InstrumentationRegistry.getInstrumentation().targetContext
val packageName = appContext.packageName
println(packageName)

medium

A. An empty string

B. The package name of the app under test

C. The package name of the test app

D. A runtime exception

Solution

1. Step 1: Understand InstrumentationRegistry usage

   InstrumentationRegistry.getInstrumentation().targetContext returns the context of the app under test, not the test app.

2. Step 2: Extract package name from app context

   appContext.packageName gives the package name of the app being tested, which is printed.

3. Final Answer:

   The package name of the app under test -> Option B

4. Quick Check:

   targetContext.packageName = app package [OK]

Hint: targetContext is app under test, not test app [OK]

Common Mistakes:

• Confusing targetContext with testContext
• Expecting empty string instead of package name
• Assuming runtime exception without cause

4. What is wrong with this instrumented test code?

@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
  @Test
  fun useAppContext() {
    val context = InstrumentationRegistry.getContext()
    assertEquals("com.example.app", context.packageName)
  }
}

medium

A. InstrumentationRegistry.getContext() is deprecated; should use getInstrumentation().targetContext

B. Missing @Before annotation for setup

C. assertEquals syntax is incorrect

D. Missing @RunWith annotation

Solution

1. Step 1: Check InstrumentationRegistry usage

   InstrumentationRegistry.getContext() is deprecated and does not return the app context; getInstrumentation().targetContext should be used.

2. Step 2: Verify other parts of the code

   @RunWith is present, assertEquals syntax is correct, and @Before is not required here.

3. Final Answer:

   InstrumentationRegistry.getContext() is deprecated; should use getInstrumentation().targetContext -> Option A

4. Quick Check:

   Use getInstrumentation().targetContext, not getContext() [OK]

Hint: Use getInstrumentation().targetContext, not getContext() [OK]

Common Mistakes:

• Using deprecated getContext() method
• Assuming @Before is mandatory for all tests
• Thinking assertEquals syntax is wrong

5. You want to write an instrumented test that verifies a button click updates a TextView on a real device. Which steps should you follow to correctly implement this test?

hard

A. Use @RunWith(AndroidJUnit4::class), get test context, launch activity, perform click, check TextView text

B. Write a unit test with @Test, mock the button click, and check TextView text without device

C. Write a UI test without annotations, directly call button click method and check TextView

D. Use @RunWith(AndroidJUnit4::class), get app context with InstrumentationRegistry.getInstrumentation().targetContext, launch activity, perform click, check TextView text

Solution

1. Step 1: Setup instrumented test with correct runner and context

   Use @RunWith(AndroidJUnit4::class) and get app context via InstrumentationRegistry.getInstrumentation().targetContext to access real app environment.

2. Step 2: Launch activity, perform UI action, and verify result

   Launch the activity, simulate button click, and check if TextView text updates as expected on device/emulator.

3. Final Answer:

   Use @RunWith(AndroidJUnit4::class), get app context with InstrumentationRegistry.getInstrumentation().targetContext, launch activity, perform click, check TextView text -> Option D

4. Quick Check:

   Instrumented UI test = runner + app context + UI actions [OK]

Hint: Instrumented UI tests need real context and runner [OK]

Common Mistakes:

• Using test context instead of app context
• Writing unit tests for UI behavior
• Skipping @RunWith annotation