Top 30 Advanced Android & Kotlin Concepts Quiz

30 questions. Pick an answer, or open “Show the answer” to read it.

Answers are graded in your browser. Nothing is saved, and no XP or streak is earned here. The app keeps score.

1. Question 1 of 30

   Which statement accurately describes how Kotlin extension functions fundamentally add functionality to a class?

   • aThe compiler transforms calls to them into static utility method invocations, passing the receiver object as an argument.
   • bThey create an anonymous inner class that wraps the original class and exposes the new method.
   • cThey leverage runtime reflection to dynamically attach new methods to instances of the receiver class.
   • dThey modify the original class's definition by injecting new methods into its bytecode.
   Show the answer

   Answer: a · The compiler transforms calls to them into static utility method invocations, passing the receiver object as an argument.

   Kotlin extension functions are syntactic sugar; the compiler rewrites calls to them as static utility method calls, passing the receiver instance as an argument. They do not modify the original class's bytecode, create new classes, or use reflection to add methods dynamically.

   Read the full bite: Kotlin Extension Functions: Add Methods Without Inheritance

2. Question 2 of 30

   Which scenario is explicitly identified as the biggest anti-pattern when utilizing Kotlin's scope functions?

   • aNesting multiple scope functions within each other.
   • bReturning a different data type from the lambda than the context object.
   • cUsing a scope function for a single, straightforward operation.
   • dReferring to the context object using 'it' when 'this' could be used.
   Show the answer

   Answer: a · Nesting multiple scope functions within each other.

   B is correct because the card explicitly states, "The biggest anti-pattern is nesting multiple scope functions. It becomes extremely difficult to reason about which this or it is in scope at any given moment, leading to subtle bugs and unreadable code." Option C, while something to avoid for clarity, is not labeled as the "biggest anti-pattern"; nesting is highlighted due to its complexity and potential for subtle bugs.

   Read the full bite: Kotlin Scope Functions: Cleaner Code, Clearer Choices

3. Question 3 of 30

   What is the primary advantage of using a sealed class over a regular abstract class when modeling a finite set of distinct states?

   • aIt optimizes runtime performance by pre-loading all subclass definitions into memory.
   • bIt allows for more flexible inheritance, letting any class extend it from anywhere.
   • cIt permits direct instantiation of the sealed class itself, simplifying state management.
   • dIt guarantees that all possible subclasses are explicitly handled by the compiler in 'when' expressions.
   Show the answer

   Answer: d · It guarantees that all possible subclasses are explicitly handled by the compiler in 'when' expressions.

   The card states that sealed classes enable the compiler to perform an exhaustiveness check in 'when' expressions, ensuring all possible subclasses are handled. Option B is incorrect because sealed classes restrict inheritance to a known set of types, not open it up.

   Read the full bite: Kotlin Sealed Classes: Enums for Types

4. Question 4 of 30

   A coroutine launched with GlobalScope.launch inside a Fragment keeps running and eventually crashes the app after the Fragment is destroyed. What is the root cause?

   • aGlobalScope has no lifecycle attachment, so nothing cancels the coroutine when the Fragment is destroyed, letting it keep referencing destroyed views
   • bGlobalScope coroutines always run on Dispatchers.Main, and Fragment destruction corrupts main thread state
   • csuspend functions cannot be cancelled once started, regardless of which scope launched them
   • dThe Fragment's Job automatically reparents orphaned coroutines from GlobalScope, causing a reference cycle
   Show the answer

   Answer: a · GlobalScope has no lifecycle attachment, so nothing cancels the coroutine when the Fragment is destroyed, letting it keep referencing destroyed views

   GlobalScope exists outside Android's lifecycle system entirely, so nothing ties its coroutines to a Fragment or Activity, and they keep running and can touch destroyed views after the screen is gone. Cooperative suspend functions are cancellable when properly scoped, and there is no automatic reparenting from GlobalScope.

   Read the full bite: Kotlin Coroutines on Android

5. Question 5 of 30

   An exception occurs inside an `async` block. The `Deferred` result is stored, but `await()` is never called on it. What happens to the exception?

   • aIt is handled by the nearest `CoroutineExceptionHandler` in the context.
   • bIt is caught and held within the `Deferred` object, and program execution continues.
   • cIt propagates up the coroutine hierarchy, potentially crashing the application.
   • dIt is silently ignored and permanently lost, as if it never happened.
   Show the answer

   Answer: b · It is caught and held within the `Deferred` object, and program execution continues.

   `async` catches its own exceptions and stores them in the `Deferred` result. The exception is only re-thrown when `await()` is called. Option C describes the behavior of `launch`, a common point of confusion.

   Read the full bite: Coroutine Exception Handling: launch vs. async

6. Question 6 of 30

   Which scenario is the most appropriate use case for a Kotlin SharedFlow?

   • aExecuting a complex calculation once and providing its result to a single consumer.
   • bBroadcasting real-time user authentication status updates to all active UI components.
   • cEmitting a sequence of database records, where each subscriber needs to process the entire sequence from the start.
   • dManaging a single, mutable configuration object whose latest value is always available to new observers.
   Show the answer

   Answer: b · Broadcasting real-time user authentication status updates to all active UI components.

   SharedFlow is designed for one-to-many event distribution, like broadcasting UI events or real-time updates to multiple parts of an application, as described in option B. Option D describes the use case for StateFlow, which is specialized for a single, observable piece of state.

   Read the full bite: SharedFlow: A Hot Flow for Broadcasting Events

7. Question 7 of 30

   What is the primary reason Kotlin's MutableList<E> is invariant, while List<out E> is covariant?

   • aMutableList is a mutable data structure, and mutability inherently prevents the application of variance modifiers for type safety.
   • bMutableList allows elements of type E to be both added to and retrieved from the list, requiring E to be used in both 'in' and 'out' positions.
   • cMutableList needs to support Java's ? super T wildcards, which conflicts with Kotlin's declaration-site out variance.
   • dThe MutableList interface is designed to prevent accidental runtime type casting errors, which declaration-site variance cannot guarantee.
   Show the answer

   Answer: b · MutableList allows elements of type E to be both added to and retrieved from the list, requiring E to be used in both 'in' and 'out' positions.

   The card explains that a generic type must remain invariant if it is used in both 'in' (consumer, like add) and 'out' (producer, like get) positions, which is precisely the case for MutableList. Option A is tempting because mutability is the context, but the direct reason for invariance is the dual usage of the generic type in 'in' and 'out' positions, as per Kotlin's variance rules.

   Read the full bite: Kotlin's `in` and `out`: Declaration-Site Variance

8. Question 8 of 30

   What is the fundamental reason Kotlin's reified type parameters are exclusively usable with inline functions?

   • aInline functions are required to access the private members of the generic type T at runtime.
   • bInline functions ensure that the generic type's Class object is implicitly passed as a hidden argument.
   • cThe compiler uses inline functions to substitute the actual type argument directly into the function's bytecode at the call site.
   • dReified types introduce runtime performance penalties that only inline functions can mitigate through optimization.
   Show the answer

   Answer: c · The compiler uses inline functions to substitute the actual type argument directly into the function's bytecode at the call site.

   The card states that when an inline function is called, the compiler copies its body to the call site and replaces the reified generic type with the actual type argument. This compile-time substitution is the core mechanism that inline functions enable for reified types. Option B describes a workaround that reified types aim to eliminate, not how they function with inline.

   Read the full bite: Reified Type Parameters: Accessing Generic Types at Runtime

9. Question 9 of 30

   What is the immediate output of a successfully executed Kotlin type-safe builder block?

   • aA hierarchical tree of interconnected Kotlin objects representing the defined structure.
   • bA set of validation rules ensuring that the generated structure adheres to specific type constraints.
   • cA string formatted according to the builder's structure, such as HTML or XML.
   • dA compiled DSL definition that can be reused to generate various data structures.
   Show the answer

   Answer: a · A hierarchical tree of interconnected Kotlin objects representing the defined structure.

   The card explicitly states that a builder block "doesn't generate a string" but rather "instantiate and link HTML, Head, and Title objects into a tree," with the "final result is a root HTML object." While builders are often used to eventually produce strings, their immediate output is an object hierarchy. Option C is a common misconception because builders are frequently used for markup generation.

   Read the full bite: Kotlin's Type-Safe Builders: Code as Data

10. Question 10 of 30

    For which scenario would you typically NOT use the Android Gradle Plugin (AGP)?

    • aBuilding a debug version of an Android application
    • bPackaging an Android App Bundle (AAB) for release to the Google Play Store
    • cCreating a shared library (AAR) for use in multiple Android apps
    • dDeveloping a pure Kotlin library intended for a backend service
    Show the answer

    Answer: d · Developing a pure Kotlin library intended for a backend service

    AGP is specifically designed for projects that produce Android artifacts like APKs, AABs, or AARs. For non-Android projects, such as a pure Kotlin backend service, standard Gradle plugins for Kotlin or Java would be used instead of AGP. Building debug versions of Android apps is a core function of AGP.

    Read the full bite: Android Gradle Plugin (AGP): The Engine of Your Android Build

11. Question 11 of 30

    What is a significant limitation to consider when using the Android Studio Profiler for performance measurement?

    • aIt cannot effectively diagnose issues related to network usage or battery drain.
    • bThe overhead from its instrumentation means performance metrics may not perfectly reflect a normal user's experience.
    • cIt completely replaces the need for automated performance benchmarks in a CI pipeline.
    • dIts primary purpose is functional testing, not detailed performance analysis.
    Show the answer

    Answer: b · The overhead from its instrumentation means performance metrics may not perfectly reflect a normal user's experience.

    The card states that "The instrumentation it adds creates performance overhead, so the numbers you see are not 100% true to a normal user's experience," directly supporting option B. While powerful, the Profiler is explicitly noted as "not a replacement for automated benchmark tests" (option C), which are better for catching regressions over time.

    Read the full bite: Android Studio Profiler: Find Your App's Bottlenecks

12. Question 12 of 30

    Which of the following is NOT a capability or primary use case of the Android Layout Inspector?

    • aInspecting the runtime properties of a selected View or Composable.
    • bVisualizing a live 3D model of the UI component tree.
    • cDebugging application logic issues by stepping through code execution.
    • dIdentifying why a UI element has unexpected padding or positioning.
    Show the answer

    Answer: c · Debugging application logic issues by stepping through code execution.

    The Layout Inspector is designed for UI hierarchy and visual debugging, providing insights into component properties and layout issues. It is explicitly stated that it is not for debugging application logic; that task is handled by the debugger.

    Read the full bite: Layout Inspector: Debug Your UI Hierarchy

13. Question 13 of 30

    What are the primary reasons R8 is enabled by default for Android release builds?

    • aTo automatically fix common runtime errors and ensure compatibility across various Android versions.
    • bTo convert all Java/Kotlin code into native machine code for optimal runtime performance.
    • cTo reduce the app's overall size and make its compiled code more difficult to reverse-engineer.
    • dTo encrypt sensitive data within the application and significantly speed up the build process.
    Show the answer

    Answer: c · To reduce the app's overall size and make its compiled code more difficult to reverse-engineer.

    The card states R8's purpose is to "shrink and obfuscate your Android app," which means it reduces APK size and deters reverse-engineering. It explicitly mentions that R8 slows down build times, making options suggesting faster compilation incorrect. Obfuscation makes code harder to understand, but it is not encryption.

    Read the full bite: R8: Shrinking and Obfuscating Android Code

14. Question 14 of 30

    What is the immediate and critical action required after starting an Android foreground service to ensure its proper operation?

    • aImplement onStartCommand() to return START_STICKY to ensure the service restarts if killed by the system.
    • bBind the service to an activity to maintain its lifecycle connection to the UI.
    • cDeclare specific foreground service types in the manifest, like FOREGROUND_SERVICE_MEDIA_PLAYBACK.
    • dInvoke startForeground() within a few seconds, providing a unique ID and a persistent notification.
    Show the answer

    Answer: d · Invoke startForeground() within a few seconds, providing a unique ID and a persistent notification.

    The card states that "within a short time limit (a few seconds), the service must call startForeground(), passing it a unique ID and a Notification object." This action signals to the OS that the user is aware of the ongoing work, preventing termination. Option C is a prerequisite, not an immediate action after starting the service.

    Read the full bite: Android Foreground Services: Work the User Can See

15. Question 15 of 30

    For which of the following background tasks is WorkManager the most appropriate solution?

    • aUploading user-generated content to a server when network connectivity is available, even if the app is closed.
    • bPerforming a quick database query and updating the UI immediately after a user action.
    • cPlaying continuous audio in the background that the user can control from a notification.
    • dDisplaying a reminder notification at precisely 3:00 PM every weekday.
    Show the answer

    Answer: a · Uploading user-generated content to a server when network connectivity is available, even if the app is closed.

    WorkManager is designed for guaranteed, deferrable background work, such as uploading data when network conditions are met, even if the app is no longer active. Option D requires precise timing, which is better handled by AlarmManager, while options A and D are for Foreground Services and immediate foreground tasks, respectively.

    Read the full bite: WorkManager: Guaranteed, Deferrable Background Work

16. Question 16 of 30

    Which scenario best highlights Data Binding's unique advantage over View Binding?

    • aOptimizing layout inflation performance for complex UI hierarchies.
    • bReducing boilerplate code by removing findViewById calls.
    • cAutomatically updating UI elements when their associated data models change.
    • dEnsuring type-safe access to all views defined in a layout.
    Show the answer

    Answer: c · Automatically updating UI elements when their associated data models change.

    Data Binding excels at linking UI components directly to observable data sources in XML, enabling automatic UI updates when the data changes. While View Binding also provides type-safe access to views and eliminates findViewById calls, it does not offer this automatic data-to-UI synchronization, making it suitable only for simpler view access.

    Read the full bite: Data Binding: Link Android UI to Data in XML

17. Question 17 of 30

    Which animation scenario is the most appropriate use case for MotionLayout?

    • aA button briefly changing its background color when a user taps it.
    • bAn icon rotating 360 degrees when a user long-presses it.
    • cA complex UI element, like a collapsing toolbar, smoothly transitioning between expanded and collapsed states based on scroll.
    • dA single image fading in smoothly when it becomes visible on the screen.
    Show the answer

    Answer: c · A complex UI element, like a collapsing toolbar, smoothly transitioning between expanded and collapsed states based on scroll.

    MotionLayout is designed for complex, multi-element UI choreography and interactive animations, such as a collapsing toolbar transitioning between states based on user scroll. Simple, one-off animations on a single view, like a button press effect or a fade-in, are better handled by simpler APIs like ViewPropertyAnimator or ObjectAnimator.

    Read the full bite: MotionLayout: Animate Layouts with States, Not Code

18. Question 18 of 30

    After loading an XML-defined Property Animation, which method is used to specify the target View that will be animated?

    • aAnimator.applyTo()
    • bAnimator.setTarget()
    • cAnimatorInflater.loadAnimator()
    • dView.startAnimation()
    Show the answer

    Answer: b · Animator.setTarget()

    The card explicitly states that after loading the Animator object, you call setTarget() on that object to link it to your target View. View.startAnimation() is used for the older View Animation system, not for Property Animations.

    Read the full bite: Android View Animation: A Blueprint for Motion

19. Question 19 of 30

    Which scenario most appropriately utilizes a Compose side-effect API?

    • aTriggering a network request to fetch data when a screen first appears.
    • bDetermining if a button should be enabled based on form input validity.
    • cFiltering a large dataset to display only relevant items in a list.
    • dChanging the background color of a composable based on a theme setting.
    Show the answer

    Answer: a · Triggering a network request to fetch data when a screen first appears.

    Fetching data is a non-UI action that needs to be tied to the composable's lifecycle, preventing unpredictable execution during recomposition, which is the purpose of side-effect APIs. The other options describe UI calculations or derived state that should be handled directly within the composable's body or with derivedStateOf, not with side-effects.

    Read the full bite: Compose Side-Effects: Escaping the Pure Function

20. Question 20 of 30

    Which scenario best justifies the use of CompositionLocal in a Jetpack Compose application?

    • aPassing a User object to a UserProfile composable, which is its primary data dependency.
    • bManaging the mutable state of a user input field that changes frequently.
    • cEnsuring all composables automatically recompose whenever any data in the UI tree changes.
    • dProviding a global analytics client instance to various deeply nested composables without explicit parameter passing.
    Show the answer

    Answer: d · Providing a global analytics client instance to various deeply nested composables without explicit parameter passing.

    CompositionLocal is ideal for ambient, semi-static data like a singleton service that needs to be accessed by many composables in a subtree, avoiding 'prop drilling'. Using it for mutable state or primary data dependencies (options A and C) is discouraged as it hides dependencies and complicates testing. Option C describes a side effect, not the primary justification for its use.

    Read the full bite: CompositionLocal: Implicitly Pass Data Down the UI Tree

21. Question 21 of 30

    Which of the following scenarios is LEAST suitable for a Compose UI test?

    • aConfirming that a Button composable from the Material library correctly triggers its onClick lambda when tapped.
    • bTesting the end-to-end user flow of a multi-screen registration process.
    • cAsserting that a form's input fields are correctly validated and error messages appear.
    • dVerifying that a custom composable displays a loading spinner when an asynchronous operation begins.
    Show the answer

    Answer: a · Confirming that a Button composable from the Material library correctly triggers its onClick lambda when tapped.

    The card explicitly advises against testing the behavior of standard library composables, as this is trusting the framework's implementation. Other options describe valid scenarios for Compose UI tests, focusing on application-specific UI logic and state changes.

    Read the full bite: Compose UI Testing: Find Nodes, Assert State, Perform Actions

22. Question 22 of 30

    Under which circumstance is the implementation of an Android Domain Layer most beneficial?

    • aWhen the application primarily involves simple data fetching and display operations.
    • bWhen a single ViewModel needs to manage complex UI state and user input.
    • cWhen the primary goal is to abstract data sources and manage data persistence.
    • dWhen business logic, whether complex or simple, needs to be reused across multiple ViewModels or would otherwise bloat a ViewModel.
    Show the answer

    Answer: d · When business logic, whether complex or simple, needs to be reused across multiple ViewModels or would otherwise bloat a ViewModel.

    The Domain Layer is explicitly recommended for centralizing complex business logic or simple rules that need to be reused across multiple ViewModels, preventing ViewModel bloat. Option A describes when not to use it, while options B and D describe responsibilities of the UI Layer (ViewModel) and Data Layer (Repositories), respectively.

    Read the full bite: Android's Domain Layer: Your Business Logic's Home

23. Question 23 of 30

    When is it inappropriate to use deep linking with Android's Navigation Component?

    • aTo handle a web link that opens a particular product detail page
    • bTo move from one fragment to another within the app's established navigation flow
    • cTo navigate to a specific screen from a push notification
    • dTo allow Google Search results to directly open specific app content
    Show the answer

    Answer: b · To move from one fragment to another within the app's established navigation flow

    The card explicitly states, "Do not use deep links for navigating between screens within your app. For internal navigation, always use Navigation Component actions." Options A, B, and D describe valid and intended use cases for deep linking.

    Read the full bite: Deep Linking with Android's Navigation Component

24. Question 24 of 30

    Which of the following best describes how Navigation Safe Args prevents runtime crashes when passing data?

    • aIt automatically serializes complex data objects into smaller, fragmented parts to avoid Android's TransactionTooLargeException.
    • bIt generates type-safe classes that enable compile-time validation of arguments, preventing mismatches before runtime.
    • cIt provides a custom Bundle implementation that dynamically adjusts its capacity to accommodate any data size.
    • dIt performs runtime type checking on all passed arguments, throwing a specific SafeArgsException if a type mismatch occurs.
    Show the answer

    Answer: b · It generates type-safe classes that enable compile-time validation of arguments, preventing mismatches before runtime.

    Safe Args generates type-safe code, allowing the compiler to validate arguments at build time, thus preventing runtime errors. Distractor C is incorrect because the card explicitly advises against passing large objects with Safe Args due to Bundle size limits, recommending shared ViewModels instead.

    Read the full bite: Navigation Safe Args: Type-Safe Navigation in Android

25. Question 25 of 30

    When would Room's relational query feature, mapping related data to nested objects, typically lead to significant performance issues?

    • aWhen the underlying database schema is highly normalized, requiring multiple table joins.
    • bWhen fetching a large collection of parent objects, where each parent also requires its own nested list of related child objects.
    • cWhen modeling a many-to-many relationship that requires an intermediate junction table.
    • dWhen retrieving a single parent object along with all its associated child objects for a detailed view.
    Show the answer

    Answer: b · When fetching a large collection of parent objects, where each parent also requires its own nested list of related child objects.

    The card explicitly states that fetching a large list of items, each with its own nested list of related data, can lead to the 'N+1' query problem and significant performance degradation. This is the scenario described in option B, whereas option D describes the ideal use case for this feature.

    Read the full bite: Room: Querying Relational Data Without Manual Joins

26. Question 26 of 30

    Which scenario most strongly indicates that an instrumented test is the appropriate choice for your Room database?

    • aWhen validating complex DAO queries, intricate relationships, or schema migrations.
    • bFor integration into a continuous integration (CI) pipeline where test execution speed is paramount.
    • cTo confirm the Room library itself is correctly handling data persistence.
    • dWhen needing rapid feedback on basic Create, Read, Update, Delete (CRUD) operations.
    Show the answer

    Answer: a · When validating complex DAO queries, intricate relationships, or schema migrations.

    Option A aligns with the card's recommendation to use instrumented tests as the "source of truth" for complex DAO logic and migrations due to their accuracy. Option D describes the ideal use case for faster local JVM tests, while Option C contradicts the advice to not test Room's own functionality.

    Read the full bite: Testing Room Databases: On-Device vs. Local JVM

27. Question 27 of 30

    Which scenario best exemplifies the primary use case for Android's FileProvider?

    • aDirectly exposing a file's absolute path to another app for quick access.
    • bProviding access to media files (like photos or videos) located in public shared directories.
    • cSharing a file from your app's private internal storage with another application.
    • dTransferring a large file between two components (e.g., Activities) within the same application.
    Show the answer

    Answer: c · Sharing a file from your app's private internal storage with another application.

    Option C is correct because FileProvider's core purpose is to securely share files from an app's private storage with other applications, replacing insecure direct path exposure. Option A describes the insecure method (file:/// URIs) that FileProvider was specifically designed to prevent, not its intended use.

    Read the full bite: FileProvider: Securely Share Files Between Apps

28. Question 28 of 30

    What is the most significant operational challenge when implementing certificate pinning in a client application?

    • aIt significantly increases the computational overhead for every TLS handshake, impacting performance.
    • bIt prevents the use of content delivery networks (CDNs) that rely on dynamic certificate issuance.
    • cIt can lead to service outages if server certificates are renewed without a corresponding client application update.
    • dIt requires frequent updates to the operating system's trusted root certificate store.
    Show the answer

    Answer: c · It can lead to service outages if server certificates are renewed without a corresponding client application update.

    The card explicitly states that if a server certificate changes and the client application is not updated with the new pin, all network requests will fail, causing service outages. This brittleness is highlighted as the primary operational risk. Pinning actually reduces reliance on the broad trust of the OS CA store, rather than requiring updates to it.

    Read the full bite: Certificate Pinning: Trusting Only Your Own Servers

29. Question 29 of 30

    Which scenario would prevent OkHttp from successfully storing a network response in its disk cache, even if caching is enabled and the server provides appropriate cache-control headers?

    • aThe application code retrieves the response but only inspects its headers before closing the response stream without consuming the body.
    • bThe response contains sensitive user data, which OkHttp automatically detects and prevents from being written to disk.
    • cThe OkHttp client is configured to use a shared cache directory that is also accessed by another OkHttp instance.
    • dThe server responds with a 304 Not Modified status code, indicating the client's cached version is still fresh.
    Show the answer

    Answer: a · The application code retrieves the response but only inspects its headers before closing the response stream without consuming the body.

    The card explicitly states that for a response to be written to the cache, its body must be fully read and closed by the application. Failing to consume the body prevents the response from being stored. While a non-exclusive cache directory (Option C) can cause issues, the unconsumed body is a direct, common coding error preventing storage of a specific response.

    Read the full bite: OkHttp Caching: Beyond Simple Hits and Misses

30. Question 30 of 30

    What is the primary advantage of using Hilt's testing features in Android?

    • aIt completely removes the need for manual mock object creation in tests.
    • bIt allows testing of classes that do not use Hilt for dependency injection.
    • cIt automatically generates all necessary test data for UI tests.
    • dIt simplifies the process of replacing real application dependencies with test-specific fakes.
    Show the answer

    Answer: d · It simplifies the process of replacing real application dependencies with test-specific fakes.

    The core purpose of Hilt testing is to automate the swapping of production dependencies with test doubles, enabling isolated testing without manual setup. While Hilt reduces boilerplate, you still create the fake implementations yourself, making option A incorrect. Hilt testing is specifically for classes managed by Hilt, contradicting option B.

    Read the full bite: Testing with Hilt: Swapping Dependencies for Isolation