title: Can't get ApplicationContext in Espresso tests
body: <p>I keep getting the following error when running my Espresso tests:</p>
  
  <p><code>Attempt to invoke virtual method 'android.content.Context android.app.Instrumentation.getTargetContext()' on a null object reference</code></p>
  
  <pre><code>@RunWith(AndroidJUnit4.class)
  public class TestLogin extends AndroidTestCase {
  
      @Rule
      public ActivityTestRule&lt;MainActivity&gt; mActivityRule = new ActivityTestRule&lt;&gt;(MainActivity.class);
  
      @Test
      public void testVerifyCredentials() {
          Context context = this.getContext().getApplicationContext();
          SharedPreferences prefs = context.getSharedPreferences("current.user", Context.MODE_PRIVATE);
          assertTrue(prefs.getBoolean("IsLoggedIn", false));
      }
  }
  </code></pre>
  
  <p>I already tried this as an <code>InstrumentationTestCase</code>, and then tried instead to do <code>Context context = this.getInstrumentation().getTargetContext().getApplicationContext();</code> but that still lead to the NPE.</p>
  
  <p>What am I doing wrong?</p>
  
  <p>The <code>SessionManager</code> class I'm using in my application to manage SharedPrefs:</p>
  
  <p>package com.nullpointexecutioners.buzzfilms.helpers;</p>
  
  <p>import android.content.Context;
  import android.content.SharedPreferences;</p>
  
  <p>import com.firebase.client.Firebase;
  import com.nullpointexecutioners.buzzfilms.Major;</p>
  
  <pre><code>/**
   * Helper class for managing a session (i.e. persistence across launches of the app
   */
  public class SessionManager {
  
      private static SessionManager sInstance;
  
      private final SharedPreferences pref;
      private final SharedPreferences.Editor editor;
  
      //SharedPref file name
      private static final String PREF_NAME = "current.user";
  
      //All Shared Preferences Keys
      private static final String IS_LOGIN = "IsLoggedIn";
  
      //Username
      public static final String KEY_USERNAME = "username";
  
      //Name
      public static final String KEY_NAME = "name";
  
      //Email
      public static final String KEY_EMAIL = "email";
  
      //Major
      public static final String KEY_MAJOR = "major";
  
      //is an Admin
      public static final String IS_ADMIN = "isAdmin";
  
      final Firebase mRef = new Firebase("redacted");
  
      /**
       * Constructor for instance of SessionManager
       * @param context of session
       * @return instance of SessionManager
       */
      public static SessionManager getInstance(Context context) {
          if (sInstance == null) {
              sInstance = new SessionManager(context);
          }
          return sInstance;
      }
  
      /**
       * Constructor for SessionManager class
       * @param context of session
       */
      private SessionManager(Context context) {
          pref = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
          editor = pref.edit();
      }
  
      /**
       * Create login session
       * @param username to store in SharedPrefs
       * @param name name of a user
       * @param email to store in SharedPrefs
       * @param major major of a user
       * @param isAdmin determines if a user is admin or not
       */
      public void createLoginSession(String username, String name, String email, String major, boolean isAdmin) {
          /*Store each value into SharedPrefs*/
          editor.putBoolean(IS_LOGIN, true);
          editor.putString(KEY_USERNAME, username);
          editor.putString(KEY_NAME, name);
          editor.putString(KEY_EMAIL, email);
          if (major.equals(Major.NONE.toString())) {
              editor.putString(KEY_MAJOR, "NONE");
          } else {
              editor.putString(KEY_MAJOR, major);
          }
  
          editor.putBoolean(IS_ADMIN, isAdmin);
  
          //Commit changes to SharedPrefs
          editor.apply();
      }
  
      /**
       * Update the current Session's values
       * @param name to update
       * @param email to update
       * @param major to update
       */
      public void updateSession(String name, String email, String major) {
          /*Store the updated values into SharedPrefs*/
          editor.putString(KEY_NAME, name);
          editor.putString(KEY_EMAIL, email);
          if (major.equals(Major.NONE.toString())) {
              editor.putString(KEY_MAJOR, "NONE");
          } else {
              editor.putString(KEY_MAJOR, major);
          }
  
          //Commit changes to SharedPrefs
          editor.apply();
      }
  
      /**
       * Checks if current user is logged in
       * If false, the user is redirected to WelcomeActivity to login or register
       * @return true or false depending if we're logged in
       */
      public boolean checkLogin() {
          return pref.getBoolean(IS_LOGIN, false);
      }
  
      /**
       * Checks if current user is an Admin
       * If false, the user won't have access to Admin functions
       * @return true or false depending if the user is an Admin
       */
      public boolean checkAdmin() {
          return pref.getBoolean(IS_ADMIN, false);
      }
  
      /**
       * Getter for currently logged in user's username
       * @return current user's username
       */
      public String getLoggedInUsername() {
          String username = null;
          if (pref.contains(KEY_USERNAME) &amp;&amp; pref.getBoolean(IS_LOGIN, false)) {
              username = pref.getString(KEY_USERNAME, null);
          }
          return username;
      }
  
      /**
       * Getter for currently logged in user's name
       * @return current user's name
       */
      public String getLoggedInName() {
          String name = null;
          if (pref.contains(KEY_NAME) &amp;&amp; pref.getBoolean(IS_LOGIN, false)) {
              name = pref.getString(KEY_NAME, "name");
          }
          return name;
      }
  
      /**
       * Getter for currently logged in user's email
       * @return current user's email
       */
      public String getLoggedInEmail() {
          String email = null;
          if (pref.contains(KEY_EMAIL) &amp;&amp; pref.getBoolean(IS_LOGIN, false)) {
              email = pref.getString(KEY_EMAIL, null);
          }
          return email;
      }
  
      /**
       * Getter for currently logged in user's major
       * @return current user's major
       */
      public String getLoggedInMajor() {
          String major = null;
          if (pref.contains(KEY_MAJOR) &amp;&amp; pref.getBoolean(IS_LOGIN, false)) {
              major = pref.getString(KEY_MAJOR, null);
          }
          return major;
      }
  
      /**
       * Clears session credentials
       */
      public void logoutUser() {
          //UnAuth from Firebase
          mRef.unauth();
  
          //Clear SharedPrefs and set IS_LOGIN to false
          editor.clear();
          editor.putBoolean(IS_LOGIN, false);
          editor.commit();
      }
  
      /**
       * Getter for accessing the current SharedPrefs
       * @return this session's SharedPrefs
       */
      public SharedPreferences getPref() {
          return pref;
      }
  }
  </code></pre>