libraries/aupt-lib/src/android/support/test/aupt/AuptTestCase.java - platform/platform_testing - Git at Google

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.support.test.aupt;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import android.accounts.Account;
 import android.accounts.AccountManager;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.os.Bundle;
 import android.os.Environment;
 import android.os.SystemClock;
 import android.support.test.uiautomator.By;
 import android.support.test.uiautomator.UiDevice;
 import android.support.test.uiautomator.UiWatcher;
 import android.test.InstrumentationTestCase;
 import android.test.InstrumentationTestRunner;
 import android.util.Log;

 import junit.framework.Assert;

 /**
  * Base class for AuptTests.
  */
 public class AuptTestCase extends InstrumentationTestCase {
     private static final String SDCARD =
             Environment.getExternalStorageDirectory().getAbsolutePath();
     private static final String RECORD_MEMINFO_PARAM = "record_meminfo";
     private static final long DEFAULT_SHORT_SLEEP = 5 * 1000;
     private static final long DEFAULT_LONG_SLEEP = 30 * 1000;
     protected static final int STEPS_BACK = 10;
     protected static final int RECOVERY_SLEEP = 2000;
     private static final String TAG = AuptTestCase.class.getSimpleName();

     private boolean mRecordMeminfo = false;
     private UiWatchers mWatchers;
     private IProcessStatusTracker mProcessStatusTracker;
     private DataCollector mDataCollector;

     // We want to periodically collect dumpheap output if the process grows to large to proactivelly
     // help with catching memory leaks, but don't want to do it too often so it does not disturb the
     // test. We are going to limit the total number of dumpheap commands per proccess to 5 by
     // default, rate limit it to one per hour be default, and only do it for monitored processes
     // which grow larger than a certain size (200MB by default).
     private boolean mDumpheapEnabled = false;
     private long mDumpheapThreshold;
     private long mDumpheapInterval ;
     private long mMaxDumpheaps;
     private Map<String, Long> mLastDumpheap = new HashMap<String, Long>();
     private Map<String, Long> mDumpheapCount = new HashMap<String, Long>();

     private UiDevice mDevice;

     public static class MemHealthRecord {
         public enum Context { FOREGROUND, BACKGROUND };

         private final long mTimeMs;
         private final long mDalvikHeap;
         private final long mNativeHeap;
         private final long mPss;
         private final Context mContext;

         public MemHealthRecord(long timeMs, long dalvikHeap, long nativeHeap, long pss,
                 Context context) {
             mTimeMs = timeMs;
             mDalvikHeap = dalvikHeap;
             mNativeHeap = nativeHeap;
             mPss = pss;
             mContext = context;
         }

         public static List<Long> getForegroundDalvikHeap(Collection<MemHealthRecord> samples) {
             List<Long> ret = new ArrayList<>(samples.size());
             for (MemHealthRecord sample : samples) {
                 if (Context.FOREGROUND.equals(sample.mContext)) {
                     ret.add(sample.mDalvikHeap);
                 }
             }
             return ret;
         }

         public static List<Long> getBackgroundDalvikHeap(Collection<MemHealthRecord> samples) {
             List<Long> ret = new ArrayList<>(samples.size());
             for (MemHealthRecord sample : samples) {
                 if (Context.BACKGROUND.equals(sample.mContext)) {
                     ret.add(sample.mDalvikHeap);
                 }
             }
             return ret;
         }

         public static List<Long> getForegroundNativeHeap(Collection<MemHealthRecord> samples) {
             List<Long> ret = new ArrayList<>(samples.size());
             for (MemHealthRecord sample : samples) {
                 if (Context.FOREGROUND.equals(sample.mContext)) {
                     ret.add(sample.mNativeHeap);
                 }
             }
             return ret;
         }

         public static List<Long> getBackgroundNativeHeap(Collection<MemHealthRecord> samples) {
             List<Long> ret = new ArrayList<>(samples.size());
             for (MemHealthRecord sample : samples) {
                 if (Context.BACKGROUND.equals(sample.mContext)) {
                     ret.add(sample.mNativeHeap);
                 }
             }
             return ret;
         }

         public static List<Long> getForegroundPss(Collection<MemHealthRecord> samples) {
             List<Long> ret = new ArrayList<>(samples.size());
             for (MemHealthRecord sample : samples) {
                 if (Context.FOREGROUND.equals(sample.mContext)) {
                     ret.add(sample.mPss);
                 }
             }
             return ret;
         }

         public static List<Long> getBackgroundPss(Collection<MemHealthRecord> samples) {
             List<Long> ret = new ArrayList<>(samples.size());
             for (MemHealthRecord sample : samples) {
                 if (Context.BACKGROUND.equals(sample.mContext)) {
                     ret.add(sample.mPss);
                 }
             }
             return ret;
         }

         private static Long getMax(Collection<Long> samples) {
             Long max = null;
             for (Long sample : samples) {
                 if (max == null || sample > max) {
                     max = sample;
                 }
             }
             return max;
         }

         private static Long getAverage(Collection<Long> samples) {
             if (samples.size() == 0) {
                 return null;
             }

             double sum = 0;
             for (Long sample : samples) {
                 sum += sample;
             }
             return (long) (sum / samples.size());
         }
     }

     private Map<String, List<MemHealthRecord>> mMemHealthRecords;
     private String[] mProcsToTrack;
     private String mResultsDirectory;

     public void setMemHealthRecords(Map<String, List<MemHealthRecord>> records) {
         mMemHealthRecords = records;
     }

     @Override
     protected void setUp() throws Exception {
         super.setUp();

         mDevice = UiDevice.getInstance(getInstrumentation());
         mWatchers = new UiWatchers();
         mWatchers.registerAnrAndCrashWatchers(getInstrumentation());
         mDevice.registerWatcher("LockScreenWatcher", new LockScreenWatcher());
         mRecordMeminfo = "true".equals(getParams().getString(RECORD_MEMINFO_PARAM, "false"));

         mDevice.setOrientationNatural();

         mResultsDirectory = SDCARD + "/" + getParams().getString(
                 "outputLocation", "aupt_results");

         String processes = getParams().getString("trackMemory", null);
         if (processes != null) {
             mProcsToTrack = processes.split(",");
         } else {
             readProcessesFromFile();
         }

         mDumpheapEnabled = "true".equals(getParams().getString("enableDumpheap"));
         if (mDumpheapEnabled) {
             mDumpheapThreshold = getLongParam("dumpheapThreshold", 200 * 1024 * 1024); // 200MB
             mDumpheapInterval = getLongParam("dumpheapInterval", 60 * 60 * 1000); // one hour
             mMaxDumpheaps = getLongParam("maxDumpheaps", 5);
         }
     }

     private void readProcessesFromFile() {
         File trackFile = new File(SDCARD + "/track_memory.txt");
         if (trackFile.exists()) {
             BufferedReader in = null;
             try {
                 in = new BufferedReader(new InputStreamReader(new FileInputStream(trackFile)));
                 String processes = in.readLine();
                 in.close();

                 if (!"".equals(processes)) {
                     mProcsToTrack = processes.split(",");
                 }
             } catch (FileNotFoundException e) {
                 Log.e(TAG, "Error opening track file", e);
             } catch (IOException e) {
                 Log.e(TAG, "Error opening track file", e);
             }
         }
     }

     /**
      * {@inheritDoc}
      */
     @Override
     protected void tearDown() throws Exception {
         mDevice.removeWatcher("LockScreenWatcher");
         mDevice.unfreezeRotation();

         saveMemoryStats();

         super.tearDown();
     }

     private class LockScreenWatcher implements UiWatcher {

         @Override
         public boolean checkForCondition() {
             if (mDevice.hasObject(By.desc("Slide area."))) {
                 mDevice.pressMenu();
                 return true;
             }
             return false;
         }
     }

     /**
      * Looks up a parameter or returns a default value if parameter is not
      * present.
      * @param key
      * @param defaultValue
      * @return passed in parameter or default value if parameter is not found.
      */
     public long getLongParam(String key, long defaultValue) throws NumberFormatException {
         if (getParams().containsKey(key)) {
             return Long.parseLong(getParams().getString(key));
         } else {
             return defaultValue;
         }
     }

     /**
      * Returns the timeout for short sleep. Can be set with shortSleep command
      * line option. Default is 5 seconds.
      * @return time in milliseconds
      */
     public long getShortSleep() {
         return getLongParam("shortSleep", DEFAULT_SHORT_SLEEP);
     }

     /**
      * Returns the timeout for long sleep. Can be set with longSleep command
      * line option. Default is 30 seconds
      * @return time in milliseconds.
      */
     public long getLongSleep() {
         return getLongParam("longSleep", DEFAULT_LONG_SLEEP);
     }

     /**
      * Press back button repeatedly in order to attempt to bring the app back to home screen.
      * This is intended so that an app can recover if the previous session left an app in a weird
      * state.
      */
     public void navigateToHome() {
         int iterations = 0;
         String launcherPkg = mDevice.getLauncherPackageName();
         while (!launcherPkg.equals(mDevice.getCurrentPackageName())
                 && iterations < STEPS_BACK) {
             mDevice.pressBack();
             SystemClock.sleep(RECOVERY_SLEEP);
             iterations++;
         }
     }

     /**
      * Writes out condensed memory data about the running processes.
      * @param notes about when the dump was taken.
      */
     public void dumpMemInfo(String notes) {
         if (mRecordMeminfo) {
             mDevice.waitForIdle();
             mDataCollector.dumpMeminfo(notes);
         }
         if (mProcsToTrack != null) {
             recordMemoryUsage();
         }
     }

     private void saveMemoryStats() {
         if (mProcsToTrack == null) {
             return;
         }
         try {
             PrintWriter out = new PrintWriter(new BufferedWriter(
                     new FileWriter(mResultsDirectory + "/memory-health.txt")));
             out.println("Foreground");
             for (Map.Entry<String, List<MemHealthRecord>> record : mMemHealthRecords.entrySet()) {
                 List<Long> nativeHeap = MemHealthRecord.getForegroundNativeHeap(record.getValue());
                 List<Long> dalvikHeap = MemHealthRecord.getForegroundDalvikHeap(record.getValue());
                 List<Long> pss = MemHealthRecord.getForegroundPss(record.getValue());

                 // nativeHeap, dalvikHeap, and pss all have the same size, just use one
                 if (nativeHeap.size() == 0) {
                     continue;
                 }

                 out.println(record.getKey());
                 out.printf("Average Native Heap: %d\n", MemHealthRecord.getAverage(nativeHeap));
                 out.printf("Average Dalvik Heap: %d\n", MemHealthRecord.getAverage(dalvikHeap));
                 out.printf("Average PSS: %d\n", MemHealthRecord.getAverage(pss));
                 out.printf("Peak Native Heap: %d\n", MemHealthRecord.getMax(nativeHeap));
                 out.printf("Peak Dalvik Heap: %d\n", MemHealthRecord.getMax(dalvikHeap));
                 out.printf("Peak PSS: %d\n", MemHealthRecord.getMax(pss));
                 out.printf("Count %d\n", nativeHeap.size());
             }
             out.println("Background");
             for (Map.Entry<String, List<MemHealthRecord>> record : mMemHealthRecords.entrySet()) {
                 List<Long> nativeHeap = MemHealthRecord.getBackgroundNativeHeap(record.getValue());
                 List<Long> dalvikHeap = MemHealthRecord.getBackgroundDalvikHeap(record.getValue());
                 List<Long> pss = MemHealthRecord.getBackgroundPss(record.getValue());

                 // nativeHeap, dalvikHeap, and pss all have the same size, just use one
                 if (nativeHeap.size() == 0) {
                     continue;
                 }

                 out.println(record.getKey());
                 out.printf("Average Native Heap: %d\n", MemHealthRecord.getAverage(nativeHeap));
                 out.printf("Average Dalvik Heap: %d\n", MemHealthRecord.getAverage(dalvikHeap));
                 out.printf("Average PSS: %d\n", MemHealthRecord.getAverage(pss));
                 out.printf("Peak Native Heap: %d\n", MemHealthRecord.getMax(nativeHeap));
                 out.printf("Peak Dalvik Heap: %d\n", MemHealthRecord.getMax(dalvikHeap));
                 out.printf("Peak PSS: %d\n", MemHealthRecord.getMax(pss));
                 out.printf("Count %d\n", nativeHeap.size());
             }
             out.close();
         } catch (IOException e) {
             Log.e(TAG, "Error while saving memory stats", e);
         }

         // Temporary hack to write full logs
         try {
             PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
                     mResultsDirectory + "/memory-health-details.txt")));
             for (Map.Entry<String, List<MemHealthRecord>> record : mMemHealthRecords.entrySet()) {
                 out.println(record.getKey());
                 out.printf("time,native_heap,dalvik_heap,pss,context\n");
                 for (MemHealthRecord sample : record.getValue()) {
                     out.printf("%d,%d,%d,%s\n", sample.mTimeMs, sample.mNativeHeap,
                             sample.mDalvikHeap, sample.mContext.toString().toLowerCase());
                 }
             }
             out.close();
         } catch (IOException e) {
             Log.e(TAG, "Error while saving memory stat details", e);
         }
     }

     private void recordMemoryUsage() {
         if (mProcsToTrack == null) {
             return;
         }
         long timeMs = System.currentTimeMillis();
         List<String> foregroundProcs = getForegroundProc();
         for (String proc : mProcsToTrack) {
             recordMemoryUsage(proc, timeMs, foregroundProcs);
         }
     }

     private void recordMemoryUsage(String proc, long timeMs, List<String> foregroundProcs) {
         try {
             String meminfo = getMeminfoOutput(proc);
             int nativeHeap = parseMeminfoLine(meminfo, "Native Heap\\s+\\d+\\s+(\\d+)");
             int dalvikHeap = parseMeminfoLine(meminfo, "Dalvik Heap\\s+\\d+\\s+(\\d+)");
             int pss = parseMeminfoLine(meminfo, "TOTAL\\s+(\\d+)");

             if (nativeHeap < 0 || dalvikHeap < 0 || pss < 0) {
                 return;
             }
             MemHealthRecord.Context context = foregroundProcs.contains(proc) ?
                     MemHealthRecord.Context.FOREGROUND : MemHealthRecord.Context.BACKGROUND;
             if (!mMemHealthRecords.containsKey(proc)) {
                 mMemHealthRecords.put(proc, new ArrayList<MemHealthRecord>());
             }
             mMemHealthRecords.get(proc).add(
                     new MemHealthRecord(timeMs, dalvikHeap, nativeHeap, pss, context));
             recordDumpheap(proc, pss);
         } catch (IOException e) {
             Log.e(TAG, "exception while memory stats", e);
         }
     }

     private int parseMeminfoLine(String meminfo, String pattern)
     {
         Pattern p = Pattern.compile(pattern);
         Matcher m = p.matcher(meminfo);
         if (m.find()) {
             return Integer.parseInt(m.group(1));
         } else {
             return -1;
         }
     }

     private String getMeminfoOutput(String processName) throws IOException {
         return getProcessOutput("dumpsys meminfo " + processName);
     }

     private void recordDumpheap(String proc, long pss) throws IOException {
         if (!mDumpheapEnabled) {
             return;
         }
         Long count = mDumpheapCount.get(proc);
         if (count == null) {
             count = 0L;
         }
         Long lastDumpheap = mLastDumpheap.get(proc);
         if (lastDumpheap == null) {
             lastDumpheap = 0L;
         }
         long currentTime = SystemClock.uptimeMillis();
         if (pss > mDumpheapThreshold && count < mMaxDumpheaps &&
                 currentTime - lastDumpheap > mDumpheapInterval) {
             recordDumpheap(proc);
             mDumpheapCount.put(proc, count + 1);
             mLastDumpheap.put(proc, currentTime);
         }
     }

     private void recordDumpheap(String proc) throws IOException {
         // Turns out getting dumpheap output is non-trivial. The command runs as shell user, and
         // only has access to /data/local/tmp directory to write files to. The test does not have
         // access to the output file by default because of the permissions dumpheap sets. So we need
         // to run dumpheap, change permissions on the output file and copy it to where test harness
         // can pick it up.
         Long count = mDumpheapCount.get(proc);
         if (count == null) {
             count = 0L;
         }
         String filename = String.format("dumpheap-%s-%d", proc, count);
         String tempFilename = "/data/local/tmp/" + filename;
         String finalFilename = mResultsDirectory +"/" + filename;
         String command = String.format("am dumpheap %s %s", proc, tempFilename);
         getProcessOutput(command);
         SystemClock.sleep(3000);
         getProcessOutput(String.format("cp %s %s", tempFilename, finalFilename));
     }

     public String getProcessOutput(String command) throws IOException {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         mDataCollector.saveProcessOutput(command, baos);
         baos.close();
         return baos.toString();
     }

     private List<String> getForegroundProc() {
         List<String> foregroundProcs = new ArrayList<String>();
         try {
             String compactMeminfo = getProcessOutput("dumpsys meminfo -c");
             for (String line : compactMeminfo.split("\\r?\\n")) {
                 if (line.contains("proc,fore")) {
                     String proc = line.split(",")[2];
                     foregroundProcs.add(proc);
                 }
             }
         } catch (IOException e) {
             Log.e(TAG, "Error while getting foreground process", e);
         } finally {
             return foregroundProcs;
         }
     }

     public void setProcessStatusTracker(IProcessStatusTracker processStatusTracker) {
         mProcessStatusTracker = processStatusTracker;
     }

     public IProcessStatusTracker getProcessStatusTracker() {
         return mProcessStatusTracker;
     }

     public void launchIntent(Intent intent) {
         getInstrumentation().getContext().startActivity(intent);
     }

     protected Bundle getParams() {
         return ((InstrumentationTestRunner)getInstrumentation()).getArguments();
     }

     protected UiDevice getUiDevice() {
         return mDevice;
     }

     public void setDataCollector(DataCollector collector) {
         mDataCollector = collector;
     }

     public String getPackageVersion(String packageName) throws NameNotFoundException {
         if (null == packageName || packageName.isEmpty()) {
               throw new RuntimeException("Package name can't be null or empty");
         }
         PackageManager pm = getInstrumentation().getContext().getPackageManager();
         PackageInfo pInfo = pm.getPackageInfo(packageName, 0);
         String version = pInfo.versionName;
         if (null == version || version.isEmpty()) {
               throw new RuntimeException(
                       String.format("Version isn't found for package = %s", packageName));
         }

         return version;
     }

     /**
      * Get registered accounts
      * Ensures there is at least one account registered
      * returns the google account name
      */
     public String getRegisteredEmailAccount() {
         Account[] accounts = AccountManager.get(getInstrumentation().getContext()).getAccounts();
         Assert.assertTrue("Device doesn't have any account registered", accounts.length >= 1);
         for(int i =0; i < accounts.length; ++i) {
             if(accounts[i].type.equals("com.google")) {
                 return accounts[i].name;
             }
         }

         throw new RuntimeException("The device is not registered with a google account");
     }
 }
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.support.test.aupt;

	import java.io.BufferedReader;
	import java.io.BufferedWriter;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import android.accounts.Account;
	import android.accounts.AccountManager;
	import android.content.Context;
	import android.content.Intent;
	import android.content.pm.PackageInfo;
	import android.content.pm.PackageManager;
	import android.content.pm.PackageManager.NameNotFoundException;
	import android.os.Bundle;
	import android.os.Environment;
	import android.os.SystemClock;
	import android.support.test.uiautomator.By;
	import android.support.test.uiautomator.UiDevice;
	import android.support.test.uiautomator.UiWatcher;
	import android.test.InstrumentationTestCase;
	import android.test.InstrumentationTestRunner;
	import android.util.Log;

	import junit.framework.Assert;

	/**
	* Base class for AuptTests.
	*/
	public class AuptTestCase extends InstrumentationTestCase {
	private static final String SDCARD =
	Environment.getExternalStorageDirectory().getAbsolutePath();
	private static final String RECORD_MEMINFO_PARAM = "record_meminfo";
	private static final long DEFAULT_SHORT_SLEEP = 5 * 1000;
	private static final long DEFAULT_LONG_SLEEP = 30 * 1000;
	protected static final int STEPS_BACK = 10;
	protected static final int RECOVERY_SLEEP = 2000;
	private static final String TAG = AuptTestCase.class.getSimpleName();

	private boolean mRecordMeminfo = false;
	private UiWatchers mWatchers;
	private IProcessStatusTracker mProcessStatusTracker;
	private DataCollector mDataCollector;

	// We want to periodically collect dumpheap output if the process grows to large to proactivelly
	// help with catching memory leaks, but don't want to do it too often so it does not disturb the
	// test. We are going to limit the total number of dumpheap commands per proccess to 5 by
	// default, rate limit it to one per hour be default, and only do it for monitored processes
	// which grow larger than a certain size (200MB by default).
	private boolean mDumpheapEnabled = false;
	private long mDumpheapThreshold;
	private long mDumpheapInterval ;
	private long mMaxDumpheaps;
	private Map<String, Long> mLastDumpheap = new HashMap<String, Long>();
	private Map<String, Long> mDumpheapCount = new HashMap<String, Long>();

	private UiDevice mDevice;

	public static class MemHealthRecord {
	public enum Context { FOREGROUND, BACKGROUND };

	private final long mTimeMs;
	private final long mDalvikHeap;
	private final long mNativeHeap;
	private final long mPss;
	private final Context mContext;

	public MemHealthRecord(long timeMs, long dalvikHeap, long nativeHeap, long pss,
	Context context) {
	mTimeMs = timeMs;
	mDalvikHeap = dalvikHeap;
	mNativeHeap = nativeHeap;
	mPss = pss;
	mContext = context;
	}

	public static List<Long> getForegroundDalvikHeap(Collection<MemHealthRecord> samples) {
	List<Long> ret = new ArrayList<>(samples.size());
	for (MemHealthRecord sample : samples) {
	if (Context.FOREGROUND.equals(sample.mContext)) {
	ret.add(sample.mDalvikHeap);
	}
	}
	return ret;
	}

	public static List<Long> getBackgroundDalvikHeap(Collection<MemHealthRecord> samples) {
	List<Long> ret = new ArrayList<>(samples.size());
	for (MemHealthRecord sample : samples) {
	if (Context.BACKGROUND.equals(sample.mContext)) {
	ret.add(sample.mDalvikHeap);
	}
	}
	return ret;
	}

	public static List<Long> getForegroundNativeHeap(Collection<MemHealthRecord> samples) {
	List<Long> ret = new ArrayList<>(samples.size());
	for (MemHealthRecord sample : samples) {
	if (Context.FOREGROUND.equals(sample.mContext)) {
	ret.add(sample.mNativeHeap);
	}
	}
	return ret;
	}

	public static List<Long> getBackgroundNativeHeap(Collection<MemHealthRecord> samples) {
	List<Long> ret = new ArrayList<>(samples.size());
	for (MemHealthRecord sample : samples) {
	if (Context.BACKGROUND.equals(sample.mContext)) {
	ret.add(sample.mNativeHeap);
	}
	}
	return ret;
	}

	public static List<Long> getForegroundPss(Collection<MemHealthRecord> samples) {
	List<Long> ret = new ArrayList<>(samples.size());
	for (MemHealthRecord sample : samples) {
	if (Context.FOREGROUND.equals(sample.mContext)) {
	ret.add(sample.mPss);
	}
	}
	return ret;
	}

	public static List<Long> getBackgroundPss(Collection<MemHealthRecord> samples) {
	List<Long> ret = new ArrayList<>(samples.size());
	for (MemHealthRecord sample : samples) {
	if (Context.BACKGROUND.equals(sample.mContext)) {
	ret.add(sample.mPss);
	}
	}
	return ret;
	}

	private static Long getMax(Collection<Long> samples) {
	Long max = null;
	for (Long sample : samples) {
	if (max == null \|\| sample > max) {
	max = sample;
	}
	}
	return max;
	}

	private static Long getAverage(Collection<Long> samples) {
	if (samples.size() == 0) {
	return null;
	}

	double sum = 0;
	for (Long sample : samples) {
	sum += sample;
	}
	return (long) (sum / samples.size());
	}
	}

	private Map<String, List<MemHealthRecord>> mMemHealthRecords;
	private String[] mProcsToTrack;
	private String mResultsDirectory;

	public void setMemHealthRecords(Map<String, List<MemHealthRecord>> records) {
	mMemHealthRecords = records;
	}

	@Override
	protected void setUp() throws Exception {
	super.setUp();

	mDevice = UiDevice.getInstance(getInstrumentation());
	mWatchers = new UiWatchers();
	mWatchers.registerAnrAndCrashWatchers(getInstrumentation());
	mDevice.registerWatcher("LockScreenWatcher", new LockScreenWatcher());
	mRecordMeminfo = "true".equals(getParams().getString(RECORD_MEMINFO_PARAM, "false"));

	mDevice.setOrientationNatural();

	mResultsDirectory = SDCARD + "/" + getParams().getString(
	"outputLocation", "aupt_results");

	String processes = getParams().getString("trackMemory", null);
	if (processes != null) {
	mProcsToTrack = processes.split(",");
	} else {
	readProcessesFromFile();
	}

	mDumpheapEnabled = "true".equals(getParams().getString("enableDumpheap"));
	if (mDumpheapEnabled) {
	mDumpheapThreshold = getLongParam("dumpheapThreshold", 200 * 1024 * 1024); // 200MB
	mDumpheapInterval = getLongParam("dumpheapInterval", 60 * 60 * 1000); // one hour
	mMaxDumpheaps = getLongParam("maxDumpheaps", 5);
	}
	}

	private void readProcessesFromFile() {
	File trackFile = new File(SDCARD + "/track_memory.txt");
	if (trackFile.exists()) {
	BufferedReader in = null;
	try {
	in = new BufferedReader(new InputStreamReader(new FileInputStream(trackFile)));
	String processes = in.readLine();
	in.close();

	if (!"".equals(processes)) {
	mProcsToTrack = processes.split(",");
	}
	} catch (FileNotFoundException e) {
	Log.e(TAG, "Error opening track file", e);
	} catch (IOException e) {
	Log.e(TAG, "Error opening track file", e);
	}
	}
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	protected void tearDown() throws Exception {
	mDevice.removeWatcher("LockScreenWatcher");
	mDevice.unfreezeRotation();

	saveMemoryStats();

	super.tearDown();
	}

	private class LockScreenWatcher implements UiWatcher {

	@Override
	public boolean checkForCondition() {
	if (mDevice.hasObject(By.desc("Slide area."))) {
	mDevice.pressMenu();
	return true;
	}
	return false;
	}
	}

	/**
	* Looks up a parameter or returns a default value if parameter is not
	* present.
	* @param key
	* @param defaultValue
	* @return passed in parameter or default value if parameter is not found.
	*/
	public long getLongParam(String key, long defaultValue) throws NumberFormatException {
	if (getParams().containsKey(key)) {
	return Long.parseLong(getParams().getString(key));
	} else {
	return defaultValue;
	}
	}

	/**
	* Returns the timeout for short sleep. Can be set with shortSleep command
	* line option. Default is 5 seconds.
	* @return time in milliseconds
	*/
	public long getShortSleep() {
	return getLongParam("shortSleep", DEFAULT_SHORT_SLEEP);
	}

	/**
	* Returns the timeout for long sleep. Can be set with longSleep command
	* line option. Default is 30 seconds
	* @return time in milliseconds.
	*/
	public long getLongSleep() {
	return getLongParam("longSleep", DEFAULT_LONG_SLEEP);
	}

	/**
	* Press back button repeatedly in order to attempt to bring the app back to home screen.
	* This is intended so that an app can recover if the previous session left an app in a weird
	* state.
	*/
	public void navigateToHome() {
	int iterations = 0;
	String launcherPkg = mDevice.getLauncherPackageName();
	while (!launcherPkg.equals(mDevice.getCurrentPackageName())
	&& iterations < STEPS_BACK) {
	mDevice.pressBack();
	SystemClock.sleep(RECOVERY_SLEEP);
	iterations++;
	}
	}

	/**
	* Writes out condensed memory data about the running processes.
	* @param notes about when the dump was taken.
	*/
	public void dumpMemInfo(String notes) {
	if (mRecordMeminfo) {
	mDevice.waitForIdle();
	mDataCollector.dumpMeminfo(notes);
	}
	if (mProcsToTrack != null) {
	recordMemoryUsage();
	}
	}

	private void saveMemoryStats() {
	if (mProcsToTrack == null) {
	return;
	}
	try {
	PrintWriter out = new PrintWriter(new BufferedWriter(
	new FileWriter(mResultsDirectory + "/memory-health.txt")));
	out.println("Foreground");
	for (Map.Entry<String, List<MemHealthRecord>> record : mMemHealthRecords.entrySet()) {
	List<Long> nativeHeap = MemHealthRecord.getForegroundNativeHeap(record.getValue());
	List<Long> dalvikHeap = MemHealthRecord.getForegroundDalvikHeap(record.getValue());
	List<Long> pss = MemHealthRecord.getForegroundPss(record.getValue());

	// nativeHeap, dalvikHeap, and pss all have the same size, just use one
	if (nativeHeap.size() == 0) {
	continue;
	}

	out.println(record.getKey());
	out.printf("Average Native Heap: %d\n", MemHealthRecord.getAverage(nativeHeap));
	out.printf("Average Dalvik Heap: %d\n", MemHealthRecord.getAverage(dalvikHeap));
	out.printf("Average PSS: %d\n", MemHealthRecord.getAverage(pss));
	out.printf("Peak Native Heap: %d\n", MemHealthRecord.getMax(nativeHeap));
	out.printf("Peak Dalvik Heap: %d\n", MemHealthRecord.getMax(dalvikHeap));
	out.printf("Peak PSS: %d\n", MemHealthRecord.getMax(pss));
	out.printf("Count %d\n", nativeHeap.size());
	}
	out.println("Background");
	for (Map.Entry<String, List<MemHealthRecord>> record : mMemHealthRecords.entrySet()) {
	List<Long> nativeHeap = MemHealthRecord.getBackgroundNativeHeap(record.getValue());
	List<Long> dalvikHeap = MemHealthRecord.getBackgroundDalvikHeap(record.getValue());
	List<Long> pss = MemHealthRecord.getBackgroundPss(record.getValue());

	// nativeHeap, dalvikHeap, and pss all have the same size, just use one
	if (nativeHeap.size() == 0) {
	continue;
	}

	out.println(record.getKey());
	out.printf("Average Native Heap: %d\n", MemHealthRecord.getAverage(nativeHeap));
	out.printf("Average Dalvik Heap: %d\n", MemHealthRecord.getAverage(dalvikHeap));
	out.printf("Average PSS: %d\n", MemHealthRecord.getAverage(pss));
	out.printf("Peak Native Heap: %d\n", MemHealthRecord.getMax(nativeHeap));
	out.printf("Peak Dalvik Heap: %d\n", MemHealthRecord.getMax(dalvikHeap));
	out.printf("Peak PSS: %d\n", MemHealthRecord.getMax(pss));
	out.printf("Count %d\n", nativeHeap.size());
	}
	out.close();
	} catch (IOException e) {
	Log.e(TAG, "Error while saving memory stats", e);
	}

	// Temporary hack to write full logs
	try {
	PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(
	mResultsDirectory + "/memory-health-details.txt")));
	for (Map.Entry<String, List<MemHealthRecord>> record : mMemHealthRecords.entrySet()) {
	out.println(record.getKey());
	out.printf("time,native_heap,dalvik_heap,pss,context\n");
	for (MemHealthRecord sample : record.getValue()) {
	out.printf("%d,%d,%d,%s\n", sample.mTimeMs, sample.mNativeHeap,
	sample.mDalvikHeap, sample.mContext.toString().toLowerCase());
	}
	}
	out.close();
	} catch (IOException e) {
	Log.e(TAG, "Error while saving memory stat details", e);
	}
	}

	private void recordMemoryUsage() {
	if (mProcsToTrack == null) {
	return;
	}
	long timeMs = System.currentTimeMillis();
	List<String> foregroundProcs = getForegroundProc();
	for (String proc : mProcsToTrack) {
	recordMemoryUsage(proc, timeMs, foregroundProcs);
	}
	}

	private void recordMemoryUsage(String proc, long timeMs, List<String> foregroundProcs) {
	try {
	String meminfo = getMeminfoOutput(proc);
	int nativeHeap = parseMeminfoLine(meminfo, "Native Heap\\s+\\d+\\s+(\\d+)");
	int dalvikHeap = parseMeminfoLine(meminfo, "Dalvik Heap\\s+\\d+\\s+(\\d+)");
	int pss = parseMeminfoLine(meminfo, "TOTAL\\s+(\\d+)");

	if (nativeHeap < 0 \|\| dalvikHeap < 0 \|\| pss < 0) {
	return;
	}
	MemHealthRecord.Context context = foregroundProcs.contains(proc) ?
	MemHealthRecord.Context.FOREGROUND : MemHealthRecord.Context.BACKGROUND;
	if (!mMemHealthRecords.containsKey(proc)) {
	mMemHealthRecords.put(proc, new ArrayList<MemHealthRecord>());
	}
	mMemHealthRecords.get(proc).add(
	new MemHealthRecord(timeMs, dalvikHeap, nativeHeap, pss, context));
	recordDumpheap(proc, pss);
	} catch (IOException e) {
	Log.e(TAG, "exception while memory stats", e);
	}
	}

	private int parseMeminfoLine(String meminfo, String pattern)
	{
	Pattern p = Pattern.compile(pattern);
	Matcher m = p.matcher(meminfo);
	if (m.find()) {
	return Integer.parseInt(m.group(1));
	} else {
	return -1;
	}
	}

	private String getMeminfoOutput(String processName) throws IOException {
	return getProcessOutput("dumpsys meminfo " + processName);
	}

	private void recordDumpheap(String proc, long pss) throws IOException {
	if (!mDumpheapEnabled) {
	return;
	}
	Long count = mDumpheapCount.get(proc);
	if (count == null) {
	count = 0L;
	}
	Long lastDumpheap = mLastDumpheap.get(proc);
	if (lastDumpheap == null) {
	lastDumpheap = 0L;
	}
	long currentTime = SystemClock.uptimeMillis();
	if (pss > mDumpheapThreshold && count < mMaxDumpheaps &&
	currentTime - lastDumpheap > mDumpheapInterval) {
	recordDumpheap(proc);
	mDumpheapCount.put(proc, count + 1);
	mLastDumpheap.put(proc, currentTime);
	}
	}

	private void recordDumpheap(String proc) throws IOException {
	// Turns out getting dumpheap output is non-trivial. The command runs as shell user, and
	// only has access to /data/local/tmp directory to write files to. The test does not have
	// access to the output file by default because of the permissions dumpheap sets. So we need
	// to run dumpheap, change permissions on the output file and copy it to where test harness
	// can pick it up.
	Long count = mDumpheapCount.get(proc);
	if (count == null) {
	count = 0L;
	}
	String filename = String.format("dumpheap-%s-%d", proc, count);
	String tempFilename = "/data/local/tmp/" + filename;
	String finalFilename = mResultsDirectory +"/" + filename;
	String command = String.format("am dumpheap %s %s", proc, tempFilename);
	getProcessOutput(command);
	SystemClock.sleep(3000);
	getProcessOutput(String.format("cp %s %s", tempFilename, finalFilename));
	}

	public String getProcessOutput(String command) throws IOException {
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	mDataCollector.saveProcessOutput(command, baos);
	baos.close();
	return baos.toString();
	}

	private List<String> getForegroundProc() {
	List<String> foregroundProcs = new ArrayList<String>();
	try {
	String compactMeminfo = getProcessOutput("dumpsys meminfo -c");
	for (String line : compactMeminfo.split("\\r?\\n")) {
	if (line.contains("proc,fore")) {
	String proc = line.split(",")[2];
	foregroundProcs.add(proc);
	}
	}
	} catch (IOException e) {
	Log.e(TAG, "Error while getting foreground process", e);
	} finally {
	return foregroundProcs;
	}
	}

	public void setProcessStatusTracker(IProcessStatusTracker processStatusTracker) {
	mProcessStatusTracker = processStatusTracker;
	}

	public IProcessStatusTracker getProcessStatusTracker() {
	return mProcessStatusTracker;
	}

	public void launchIntent(Intent intent) {
	getInstrumentation().getContext().startActivity(intent);
	}

	protected Bundle getParams() {
	return ((InstrumentationTestRunner)getInstrumentation()).getArguments();
	}

	protected UiDevice getUiDevice() {
	return mDevice;
	}

	public void setDataCollector(DataCollector collector) {
	mDataCollector = collector;
	}

	public String getPackageVersion(String packageName) throws NameNotFoundException {
	if (null == packageName \|\| packageName.isEmpty()) {
	throw new RuntimeException("Package name can't be null or empty");
	}
	PackageManager pm = getInstrumentation().getContext().getPackageManager();
	PackageInfo pInfo = pm.getPackageInfo(packageName, 0);
	String version = pInfo.versionName;
	if (null == version \|\| version.isEmpty()) {
	throw new RuntimeException(
	String.format("Version isn't found for package = %s", packageName));
	}

	return version;
	}

	/**
	* Get registered accounts
	* Ensures there is at least one account registered
	* returns the google account name
	*/
	public String getRegisteredEmailAccount() {
	Account[] accounts = AccountManager.get(getInstrumentation().getContext()).getAccounts();
	Assert.assertTrue("Device doesn't have any account registered", accounts.length >= 1);
	for(int i =0; i < accounts.length; ++i) {
	if(accounts[i].type.equals("com.google")) {
	return accounts[i].name;
	}
	}

	throw new RuntimeException("The device is not registered with a google account");
	}
	}