diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..7a4a3ea
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
\ No newline at end of file
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..4016bab
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,87 @@
+# Copyright 2020 Google LLC
+#
+# 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.
+
+.PHONY: help start
+
+SHELL := /bin/bash
+SRC_DIR ?= .
+DST_DIR ?= .
+PROTOC_DIR ?= .
+PROTO_SRC_FILE ?= stress_test.proto
+
+ifeq ($(OS),Windows_NT)
+	detected_OS := Windows
+	USER_NAME ?=
+else
+    detected_OS := $(shell uname)
+	USER_NAME ?= $(shell whoami)
+	ENV_PATH ?= $(shell pwd)
+endif
+
+.DEFAULT: help
+help:
+	@echo "make start"
+	@echo "       prepare development environment, use only once"
+	@echo "make proto-compile"
+	@echo "       compile protubuf"
+	@echo "make clean"
+	@echo "       delete test result and cache directories"
+
+start:
+ifeq ($(detected_OS),Windows)
+	@echo "please install python3 and pytyon3-pip manually"
+	py -m pip install --upgrade pip
+	py -m pip install --user virtualenv
+	python -m venv .\env
+endif
+ifeq ($(detected_OS),Darwin)
+	/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+	sudo chown -R $(USER_NAME) /usr/local/bin /usr/local/etc /usr/local/sbin /usr/local/share
+	chmod u+w /usr/local/bin /usr/local/etc /usr/local/sbin /usr/local/share
+	brew install python3 protobuf sox
+	python3 -m pip install --user virtualenv
+	python3 -m venv env
+endif
+ifeq ($(detected_OS),Linux)
+	sudo apt-get install python3 sox
+	sudo apt install python3-pip
+	python3 -m pip install --user --upgrade pip
+	python3 -m pip install --user virtualenv
+	sudo apt-get install python3-venv
+	python3 -m venv env
+	sudo apt install protobuf-compiler
+endif
+
+proto-compile: ${PROTO_SRC_FILE}
+ifeq ($(detected_OS),Windows)
+ifndef PROTOC_DIR
+	@echo "Error! Please download protoc.exe from https://github.com/google/protobuf/releases/ and set PROTOC_DIR accordingly"
+else
+	$(PROTOC_DIR)/protoc.exe -I=${SRC_DIR} --python_out=${DST_DIR} ${SRC_DIR}/${PROTO_SRC_FILE}
+endif
+else
+	protoc -I=${SRC_DIR} --python_out=${DST_DIR} ${SRC_DIR}/${PROTO_SRC_FILE}
+endif
+
+clean:
+ifeq ($(detected_OS),Windows)
+	@for /d %%x in (dsp_*) do rd /s /q "%%x"
+	@for /d %%x in (enroll_*) do rd /s /q "%%x"
+	@for /d %%x in (__pycache*) do rd /s /q "%%x"
+else
+	@rm -rf __pycache__
+	@rm -rf dsp_*
+	@rm -rf enroll*
+endif
+	@echo "cleanning completed"
diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..7259ddc
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1,5 @@
+# Default maintainers and code reviewers: 
+jschung@google.com
+wonil@google.com
+kwangun@google.com
+mokani@google.com
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c4031cd
--- /dev/null
+++ b/README.md
@@ -0,0 +1,52 @@
+# OpenHST : Open sourced Hotword Stress Test tool
+
+Hotword stress test tool is a python script to measure the Google Hotword
+performance on Android devices with simple test set up. The goal of OpenHST is
+making Google Hotword Stress Test tool as an open source project so that Android
+Partners can easily adapt on their development.
+
+## Overview
+
+![Hotsord Stress Test concept diagram](docs/image/HST_concept_diagram.png)
+
+## Prerequsite
+
+Before setting up your HST test environment, please make sure to meet following
+preconditions.
+
+*   DSP hotword capability on test device (android handset)
+*   ADB connection between the test server and android handset
+*   Internet connection on android handset
+*   No screen lock setting on android handset
+*   Python 3.x installed test machine (Linux, Mac, Windows)
+*   Install GNU make(3.81 above) on test machine (Linux, Mac, Windows)
+
+## Test environment setup
+
+Please follow below steps to set up HST on your test machine and make sure that
+no error popped up during the installation.
+
+__Linux & Mac__
+
+1.  make start
+1.  make proto-compile
+1.  source env/bin/activate
+1.  ./start_venv.sh
+
+__Windows__
+
+1.  make start
+1.  make proto-compile
+1.  .\env\Scripts\activate
+1.  .\start_venv.bat
+1.  pip3 install -r requirements.txt
+
+## Documentation
+
+Read our [detailed documentation](docs/OpenHST.pdf) to learn how to run the
+Hotword Stress Test.
+
+## Contacts
+
+Join our [mailing list](https://groups.google.com/g/openhst) for discussions and
+announcements.
diff --git a/docs/OpenHST.pdf b/docs/OpenHST.pdf
new file mode 100644
index 0000000..2b1cb8f
--- /dev/null
+++ b/docs/OpenHST.pdf
Binary files differ
diff --git a/docs/contributing.md b/docs/contributing.md
new file mode 100644
index 0000000..22b241c
--- /dev/null
+++ b/docs/contributing.md
@@ -0,0 +1,29 @@
+# How to Contribute
+
+We'd love to accept your patches and contributions to this project. There are
+just a few small guidelines you need to follow.
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement (CLA). You (or your employer) retain the copyright to your
+contribution; this simply gives us permission to use and redistribute your
+contributions as part of the project. Head over to
+<https://cla.developers.google.com/> to see your current agreements on file or
+to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Code reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult
+[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
+information on using pull requests.
+
+## Community Guidelines
+
+This project follows
+[Google's Open Source Community Guidelines](https://opensource.google/conduct/).
diff --git a/docs/image/HST_concept_diagram.png b/docs/image/HST_concept_diagram.png
new file mode 100644
index 0000000..5b62a38
--- /dev/null
+++ b/docs/image/HST_concept_diagram.png
Binary files differ
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..a963e06
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,5 @@
+google==2.0.3
+protobuf==3.11.3
+protobuf-compiler==1.0.20
+absl-py==0.9.0
+pexpect==4.8.0
diff --git a/resources/device_config.common.ascii_proto b/resources/device_config.common.ascii_proto
new file mode 100644
index 0000000..0d4ae8a
--- /dev/null
+++ b/resources/device_config.common.ascii_proto
@@ -0,0 +1,102 @@
+file_to_watch {
+  source: "LOGCAT"
+  destination: "%(device)s_logcat.txt"
+  repeats_output_on_open: true
+  time_stamp {
+    type: DATE
+    regex: "^(\\d+-\\d+ \\d+:\\d+:\\d+.\\d+)"
+    date_format: "%m-%d %H:%M:%S.%f"
+  }
+}
+
+file_to_watch {
+  source: "/dev/kmsg"
+  destination: "%(device)s_kmsg.txt"
+  repeats_output_on_open: true
+  time_stamp {
+    type: MONOTONIC
+    regex: "^\\d+,\\d+,(\\d+)"
+    monotonic_to_seconds_multiplier: 1e-6
+  }
+}
+
+file_to_move {
+  source: "/sdcard/captured_dsp_audio.wav"
+  destination: "%(device)s/%(iteration)06d_captured_dsp_audio.wav"
+}
+
+event {
+  source: "LOGCAT"
+  name: "software_hotword"
+  regex: "MicroDetectionWorker: #onHotwordDetected"
+}
+
+event {
+  source: "LOGCAT"
+  name: "vis_software_hotword"
+  regex: "GsaVoiceInteractionSrv: onHotwordDetected"
+}
+
+event {
+  source: "LOGCAT"
+  name: "dsp_false_accept"
+  regex: "Software didn't trigger but DSP did"
+}
+
+event {
+  source: "LOGCAT"
+  name: "speaker_id_rejected"
+  regex: ": Speaker Verification failed"
+  regex: "Software based speaker id triggered: false"
+}
+
+event {
+  source: "LOGCAT"
+  name: "logcat_iteration"
+  regex: "STRESS_TEST: Iteration \d+ complete"
+}
+
+event {
+  source: "LOGCAT"
+  name: "assistant_started"
+  regex: "START.*com\.google\.android\.googlequicksearchbox.*opa\.OpaActivity.*"
+}
+
+event {
+  source: "LOGCAT"
+  name: "aohd_hotword_detected"
+  regex: "AlwaysOnHotwordDetector: onDetected"
+}
+
+setup_command: "shell setprop log.tag.AlwaysOnHotwordDetector DEBUG"
+setup_command: "shell setprop log.tag.ClockworkHomeGoogle DEBUG"
+setup_command: "shell setprop log.tag.DSPMicrophoneIS DEBUG"
+setup_command: "shell setprop log.tag.DSPMicrophoneInputStrea DEBUG"
+setup_command: "shell setprop log.tag.GsaVoiceInteractionSrv DEBUG"
+setup_command: "shell setprop log.tag.HotwordAudioProvider DEBUG"
+setup_command: "shell setprop log.tag.HotwordConfig DEBUG"
+setup_command: "shell setprop log.tag.HotwordConfigController DEBUG"
+setup_command: "shell setprop log.tag.HotwordDetector DEBUG"
+setup_command: "shell setprop log.tag.HotwordHelper DEBUG"
+setup_command: "shell setprop log.tag.HotwordRecognitionEngn DEBUG"
+setup_command: "shell setprop log.tag.HotwordRecognitionRnr DEBUG"
+setup_command: "shell setprop log.tag.HotwordSettingsCntrlr DEBUG"
+setup_command: "shell setprop log.tag.HotwordState DEBUG"
+setup_command: "shell setprop log.tag.HotwordWorker DEBUG"
+setup_command: "shell setprop log.tag.HotwordWorkerImpl DEBUG"
+setup_command: "shell setprop log.tag.MicroDetectionState DEBUG"
+setup_command: "shell setprop log.tag.MicroRecognitionEngine DEBUG"
+setup_command: "shell setprop log.tag.SWHotwordRecognizer DEBUG"
+setup_command: "shell setprop log.tag.SoundTrigger DEBUG"
+setup_command: "shell setprop log.tag.SoundTriggerHelper DEBUG"
+setup_command: "shell setprop log.tag.SoundTriggerTest DEBUG"
+setup_command: "shell setprop log.tag.VISHotwordAdapter DEBUG"
+setup_command: "shell setprop log.tag.WearVIS DEBUG"
+setup_command: "shell setprop log.tag.MicroDetectionWorker DEBUG"
+setup_command: "shell setprop log.tag.MicroDetectionWrkImpl DEBUG"
+setup_command: "shell setprop log.tag.MicroDetector DEBUG"
+setup_command: "shell setprop log.tag.MicroRecognitionEngine DEBUG"
+setup_command: "shell setprop log.tag.MicroRecognitionRnrImpl DEBUG"
+setup_command: "logcat -P ''"
+
+tag_to_suppress: "GoogleApiClientConnected"
diff --git a/resources/heyg-us-female.wav b/resources/heyg-us-female.wav
new file mode 100644
index 0000000..e431ed7
--- /dev/null
+++ b/resources/heyg-us-female.wav
Binary files differ
diff --git a/resources/heyg-us-male.wav b/resources/heyg-us-male.wav
new file mode 100644
index 0000000..c190b61
--- /dev/null
+++ b/resources/heyg-us-male.wav
Binary files differ
diff --git a/resources/okg-us-female.wav b/resources/okg-us-female.wav
new file mode 100644
index 0000000..5b3ba0f
--- /dev/null
+++ b/resources/okg-us-female.wav
Binary files differ
diff --git a/resources/okg-us-male.wav b/resources/okg-us-male.wav
new file mode 100644
index 0000000..74c9c1b
--- /dev/null
+++ b/resources/okg-us-male.wav
Binary files differ
diff --git a/resources/stress_test.dsp_monitoring_on_idle.ascii_proto b/resources/stress_test.dsp_monitoring_on_idle.ascii_proto
new file mode 100644
index 0000000..a1d490f
--- /dev/null
+++ b/resources/stress_test.dsp_monitoring_on_idle.ascii_proto
@@ -0,0 +1,29 @@
+description: "Let device in idle and check the DSP wakeup counts"
+             "Stop Testing if DSP detects hotword over 30 times"
+
+step {
+  command: "shell dumpsys battery unplug"
+  delay_after: 1
+}
+step {
+  command: "shell dumpsys deviceidle force-idle"
+  delay_after: 59
+}
+
+expected_result {
+    aohd_hotword_detected : 0
+    assistant_started  : 0
+    dsp_false_accept  : 0
+    speaker_id_rejected : 0
+    logcat_iteration  : 1
+    software_hotword  : 0
+    vis_software_hotword  : 0
+}
+
+event {
+  name: "device_crashed"
+  condition: "aohd_hotword_detected >= 30"
+  action: "BUGREPORT"
+  action: "NOTIFY"
+  action: "REMOVE_DEVICE"
+}
diff --git a/resources/stress_test.dsp_trigger_and_screen_off.ascii_proto b/resources/stress_test.dsp_trigger_and_screen_off.ascii_proto
new file mode 100644
index 0000000..47241fb
--- /dev/null
+++ b/resources/stress_test.dsp_trigger_and_screen_off.ascii_proto
@@ -0,0 +1,43 @@
+description: "Switches between the homescreen and screen off, launching a "
+             "voice search when the DSP should be enabled. The search is "
+             "also just of OK Google."
+
+step {
+  audio_file : "okg-us-female.wav"
+  audio_file_sample_rate : 24000
+  delay_after : 3
+}
+step {
+  command: "shell input keyevent 3"
+  delay_after: 1
+}
+step {
+  command: "shell input keyevent 26"
+  delay_after: 1
+}
+step {
+  command: "shell dumpsys battery unplug"
+  delay_after: 1
+}
+step {
+  command: "shell dumpsys deviceidle force-idle"
+  delay_after: 10
+}
+
+expected_result {
+    aohd_hotword_detected : 1
+    assistant_started  : 1
+    dsp_false_accept  : 0
+    logcat_iteration  : 1
+    software_hotword  : 1
+    speaker_id_rejected  : 0
+    vis_software_hotword  : 1
+}
+
+event {
+  name: "device_crashed"
+  condition: "iterations_since_aohd_hotword_detected >= 30"
+             "or iterations_since_assistant_started >= 30"
+  action: "BUGREPORT"
+  action: "REMOVE_DEVICE"
+}
diff --git a/resources/stress_test.dsp_trigger_on_homescreen.ascii_proto b/resources/stress_test.dsp_trigger_on_homescreen.ascii_proto
new file mode 100644
index 0000000..2fef6be
--- /dev/null
+++ b/resources/stress_test.dsp_trigger_on_homescreen.ascii_proto
@@ -0,0 +1,32 @@
+description: "Stress test DSP hotword on HomeScreen. User must be enrolled for "
+             "DSP hotword"
+
+step {
+  audio_file : "okg-us-female.wav"
+  audio_file_sample_rate : 24000
+  delay_after : 3
+}
+
+step {
+  command: "shell input keyevent 3"
+  delay_after : 3
+}
+
+expected_result {
+    aohd_hotword_detected : 1
+    assistant_started  : 1
+    dsp_false_accept  : 0
+    logcat_iteration  : 1
+    software_hotword  : 1
+    speaker_id_rejected  : 0
+    vis_software_hotword  : 1
+}
+
+event {
+  name: "device_crashed"
+  condition: "iterations_since_aohd_hotword_detected >= 30 "
+             "or iterations_since_assistant_started >= 30"
+  action: "BUGREPORT"
+  action: "NOTIFY"
+  action: "REMOVE_DEVICE"
+}
diff --git a/resources/stress_test.dsp_trigger_sw_rejection.ascii_proto b/resources/stress_test.dsp_trigger_sw_rejection.ascii_proto
new file mode 100644
index 0000000..10a230f
--- /dev/null
+++ b/resources/stress_test.dsp_trigger_sw_rejection.ascii_proto
@@ -0,0 +1,60 @@
+description: "Test that repeats itself"
+
+step {
+  audio_file : "okg-us-female.wav"
+  audio_file_sample_rate : 24000
+  delay_after : 3
+}
+step {
+  command: "shell input keyevent 3"
+  delay_after: 1
+}
+step {
+  command: "shell input keyevent 26"
+  delay_after: 2
+}
+step {
+  command: "shell dumpsys battery unplug"
+  delay_after: 1
+}
+step {
+  command: "shell dumpsys deviceidle force-idle"
+  delay_after: 5
+}
+step {
+  audio_file : "okg-us-male.wav"
+  audio_file_sample_rate : 24000
+  delay_after : 3
+}
+step {
+  command: "shell input keyevent 3"
+  delay_after: 1
+}
+step {
+  command: "shell input keyevent 26"
+  delay_after: 2
+}
+step {
+  command: "shell dumpsys battery unplug"
+  delay_after: 1
+}
+step {
+  command: "shell dumpsys deviceidle force-idle"
+  delay_after: 5
+}
+
+expected_result {
+    aohd_hotword_detected : 2
+    assistant_started  : 1
+    dsp_false_accept  : 0
+    logcat_iteration  : 1
+    software_hotword  : 2
+    speaker_id_rejected  : 1
+    vis_software_hotword  : 2
+}
+
+event {
+  name: "sync_word_not_present"
+  condition: "sync_word_not_present == 1 and iterations_since_sync_word_not_present == 0"
+  action: "NOTIFY"
+}
diff --git a/resources/stress_test.enroll.ascii_proto b/resources/stress_test.enroll.ascii_proto
new file mode 100644
index 0000000..0c7e635
--- /dev/null
+++ b/resources/stress_test.enroll.ascii_proto
@@ -0,0 +1,35 @@
+description: "Simple script that just plays OK Google repeatedly to enroll"
+
+step {
+  audio_file : "okg-us-female.wav"
+  audio_file_sample_rate : 24000
+  delay_after : 2
+}
+
+step {
+  audio_file : "okg-us-female.wav"
+  audio_file_sample_rate : 24000
+  delay_after : 2
+}
+
+step {
+  audio_file : "heyg-us-female.wav"
+  audio_file_sample_rate : 24000
+  delay_after : 2
+}
+
+step {
+  audio_file : "heyg-us-female.wav"
+  audio_file_sample_rate : 24000
+  delay_after : 2
+}
+
+expected_result {
+    aohd_hotword_detected : 0
+    assistant_started  : 0
+    dsp_false_accept  : 0
+    logcat_iteration  : 1
+    software_hotword  : 0
+    speaker_id_rejected  : 0
+    vis_software_hotword  : 0
+}
diff --git a/start_venv.sh b/start_venv.sh
new file mode 100644
index 0000000..cc2af8e
--- /dev/null
+++ b/start_venv.sh
@@ -0,0 +1,19 @@
+# Copyright 2020 Google LLC
+#
+# 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.
+
+#!/bin/bash
+python -m pip install wheel
+python -m pip install requests
+python -m pip install --upgrade requests
+python -m pip install -r requirements.txt
diff --git a/stress_test.proto b/stress_test.proto
new file mode 100644
index 0000000..3ca2e84
--- /dev/null
+++ b/stress_test.proto
@@ -0,0 +1,186 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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.
+ */
+
+syntax = "proto3";
+
+package stress_test;
+
+option optimize_for = CODE_SIZE;
+
+message LoggingEventConfig {
+  // The process name that this event can be found on, or LOGCAT to come from
+  // 'adb logcat'.
+  string source = 1;
+  // The name of the event to trigger.
+  string name = 2;
+  // A list of regexes that can be used to detect the specified event.
+  repeated string regex = 3;
+}
+
+message TimeStampConfig {
+  enum TimeStampType {
+    UNKNOWN = 0;
+    DATE = 1;
+    MONOTONIC = 2;
+  }
+  // If the type is DATE, then we assume it can be parsed by a python datetime.
+  // MONOTONIC sources are from the device's boot time.
+  TimeStampType type = 3;
+  // The regex to extract the string containing the timestamp.
+  string regex = 4;
+  // The format string to pass to the python datetime constructor for the
+  // matched regex.
+  string date_format = 5;
+  // The multiplier used on the parsed monotonic time to convert it to seconds.
+  double monotonic_to_seconds_multiplier = 6;
+}
+
+message FileConfig {
+  // The file that should be cat-ed on device to get information. Will be used
+  // by LoggingEventConfigs.
+  string source = 1;
+  // The filepath to save the output of this file on the local machine. If
+  // blank, will be discarded.
+  string destination = 2;
+  // The information needed to extract timestamps from the config.
+  TimeStampConfig time_stamp = 3;
+  // True if the file spits out a bit of the buffer that it did previously when
+  // reopened (like the logcat does).
+  bool repeats_output_on_open = 4;
+}
+
+message ProcessConfig {
+  // The command to run to produce logging output.
+  string command = 1;
+  // The name of the process to be used in LoggingEventConfigs.
+  string name = 2;
+  // The filepath to save the output of this process on the local machine. If
+  // blank, will be discarded.
+  string destination = 3;
+  // The information needed to extract timestamps from the config.
+  TimeStampConfig time_stamp = 4;
+  // Restart the process if it crashes randomly.
+  bool restart = 5;
+  // True if the file spits out a bit of the buffer that it did previously when
+  // reopened (like the logcat does).
+  bool repeats_output_on_open = 6;
+}
+
+message DeviceConfig {
+  // Commands to run once at the beginning of the test for the device.
+  repeated string setup_command = 1;
+  // Files that should have their contents monitored for events.
+  repeated FileConfig file_to_watch = 2;
+  // Files that should be moved to the local machine after every iteration of
+  // the stress test.
+  repeated FileConfig file_to_move = 3;
+  // All events that can be triggered by this device.
+  repeated LoggingEventConfig event = 5;
+  // Any processes that should be monitored for events.
+  repeated ProcessConfig daemon_process = 6;
+  // Include any other device definitions before processing the contents of this
+  // one. Note that if duplicate entries exist for the repeated elements (based
+  // on the name), only the "latest" in the include chain will be used.
+  repeated string include = 7;
+  // A list of tags that should be squelched from the logcat - useful for super
+  // spammy irrelevant logcat tags.
+  repeated string tag_to_suppress = 8;
+  // Either a TestEventConfig without a condition (but a name) that allows extra
+  // actions to take place when a specific test event occurs, or a standard test
+  // event that will be invoked regardless of which test is running.
+  repeated TestEventConfig test_event = 9;
+}
+
+message TestStep {
+  // Path to raw audio file to play during this test step.
+  string audio_file = 1;
+  // Sample rate of audio file.
+  int32 audio_file_sample_rate = 2;
+  // Number of channels in audio file.
+  int32 audio_file_num_channels = 3;
+  // The sox format of the audio file.
+  string audio_file_format = 4;
+  // Command to run on this test step.
+  string command = 5;
+  // How many seconds to wait before executing the command/playing the sound in
+  // this step.
+  float delay_before = 6;
+  // How many seconds to wait after executing the command/playing the sound in
+  // this step.
+  float delay_after = 7;
+}
+
+message ExpectedResult {
+  int32 aohd_hotword_detected = 1;
+  int32 assistant_started = 2;
+  int32 dsp_false_accept = 3;
+  int32 logcat_iteration = 4;
+  int32 software_hotword = 5;
+  int32 speaker_id_rejected = 6;
+  int32 vis_software_hotword = 7;
+}
+
+message TestEventConfig {
+  // The name of the event. (Used for readability/allowing devices to add custom
+  // actions when an event of a specific name occurs).
+  string name = 1;
+  // An eval condition that should only be true when the actions in this event
+  // should be executed.
+  string condition = 2;
+  // List of actions to take when the condition is satisfied. BUGREPORT, NOTIFY,
+  // REMOVE_DEVICE and ABORT are all special values that take a bugreport, send
+  // an email, remove the device from the test or stops stress testing
+  // respectively.
+  repeated string action = 3;
+}
+
+message StressTestConfig {
+  // Description of what the test does.
+  string description = 1;
+  // List of steps to take in sequence repeatedly to do the stress test.
+  repeated TestStep step = 2;
+  // Events that trigger special actions on the device when the condition is
+  // satisfied.
+  repeated TestEventConfig event = 3;
+  // Commands that should be run at the beginning of the test to setup the
+  // device.
+  repeated string setup_command = 4;
+  // Definition of Expected test result
+  repeated ExpectedResult expected_result = 5;
+}
+
+message EventLogDetails {
+  int32 iteration = 1;
+  string name = 2;
+}
+
+message EventLog {
+  repeated EventLogDetails event = 1;
+}
+
+message DeviceIdentifier {
+  string device_type = 1;
+  string serial_number = 2;
+}
+
+message StressTestInfo {
+  // Metadata info describing the devices involved in the stress test, and a bit
+  // about what test was actually run.
+  string test_name = 1;
+  string test_description = 2;
+  string uuid = 3;
+  repeated DeviceIdentifier device = 4;
+}
diff --git a/stress_test.py b/stress_test.py
new file mode 100644
index 0000000..1e9bfad
--- /dev/null
+++ b/stress_test.py
@@ -0,0 +1,1049 @@
+# Copyright 2020 Google LLC
+#
+# 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.
+
+"""Stress test utility for repeating actions repeatedly on android devices.
+
+Configures multiple devices to simultaneously run through the same set of
+actions over and over, while keeping logs from various sources. Primarily
+designed for playing audio to the devices and scanning their log output for
+events, while running other adb commands in between.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import datetime
+from email import encoders
+from email.mime import text
+import email.mime.base as base
+import email.mime.multipart as multipart
+import logging
+import mimetypes
+import os
+import platform
+import re
+import shlex
+import signal
+import smtplib
+import socket
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import uuid
+import wave
+from absl import app
+from absl import flags
+import pexpect
+import queue
+import stress_test_common
+import stress_test_pb2
+from google.protobuf import text_format
+
+_SUMMARY_LINES = "-" * 73
+
+if sys.platform.startswith("win"):
+  pexpect = None
+
+_SUMMARY_COLUMNS = (
+    "|        Event Type       |      Event Count     | Consecutive no event |")
+_SUMMARY_COL_FORMATT = "|%-25.25s|% 22d|% 22d|"
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string("notification_address", "",
+                    "Email address where to send notification events. Will "
+                    "default to $USER@google.com if not provided. No emails "
+                    "will be sent if suppress_notification_emails is True.")
+flags.DEFINE_bool("suppress_notification_emails", False,
+                  "Prevents emails from being sent as notifications if True.")
+flags.DEFINE_string("test_name", None,
+                    "Name of stress test to run. For example, if you set this "
+                    "to 'dsp_trigger_sw_rejection', the stress test in "
+                    "'stress_test.dsp_trigger_sw_rejection.ascii_proto' will "
+                    "be loaded and executed.")
+# flags.mark_flag_as_required("test_name")
+flags.DEFINE_string("output_root", "./",
+                    "Path where directory should be generated containing all "
+                    "logs from devices and moved files.")
+flags.DEFINE_integer("num_iterations", None,
+                     "If set to a positive number, the number of iterations of "
+                     "the stress test to run. Otherwise, the test runs "
+                     "forever.")
+flags.DEFINE_list("devices", [],
+                  "Serial numbers of devices that should be included in the "
+                  "stress test. If empty, all devices will be used.")
+flags.DEFINE_integer("print_summary_every_n", 10,
+                     "Prints the summary to the log file every n iterations.")
+
+flags.DEFINE_string("email_sender_address", "",
+                    "Account to use for sending notification emails.")
+flags.DEFINE_string("email_sender_password", "",
+                    "Password to use for notification email account.")
+flags.DEFINE_string("email_smtp_server", "smtp.gmail.com",
+                    "SMTP server to use for sending notification emails.")
+flags.DEFINE_integer("email_smtp_port", 465,
+                     "Port to use for the notification SMTP server.")
+flags.DEFINE_integer("device_settle_time", 5,
+                     "Time to wait for devices to settle.")
+flags.DEFINE_bool("use_sox", platform.system() != "Windows",
+                  "Use sox for playback, otherwise, attempt to use platform "
+                  "specific features.")
+flags.DEFINE_bool("attach_bugreport", True,
+                  "Attach bugreport to email if test failed.")
+flags.DEFINE_bool("delete_data_dir", False,
+                  "If true, code will delete all the files generated by this "
+                  "test at the end.")
+
+if platform.system().startswith("CYGWIN"):
+  FLAGS.device_settle_time = 30
+
+
+def QueueWorker(worker_queue):
+  while True:
+    work = worker_queue.get()
+    try:
+      work()
+    except:  # pylint:disable=bare-except
+      logging.exception("Exception in worker queue - task remains uncompleted.")
+    worker_queue.task_done()
+
+
+def SendNotificationEmail(subject, body, bugreport=None):
+  """Sends an email with the specified subject and body.
+
+     Also attach bugreport if bugreport location is provided as argument
+
+  Args:
+    subject: Subject of the email.
+    body: Body of the email.
+    bugreport: If provided, it will be attach to the email.
+  """
+  if FLAGS.suppress_notification_emails:
+    logging.info("Email with subject '%s' has been suppressed", subject)
+    return
+  try:
+    # Assemble the message to send.
+    recpient_address = FLAGS.notification_address
+    message = multipart.MIMEMultipart("alternative")
+    message["From"] = "Stress Test on %s" % socket.gethostname()
+    message["To"] = recpient_address
+    message["Subject"] = subject
+    message.attach(text.MIMEText(body, "plain"))
+    message.attach(text.MIMEText("<pre>%s</pre>" % body, "html"))
+
+    if FLAGS.attach_bugreport and bugreport:
+      # buildozer: disable=unused-variable
+      ctype, _ = mimetypes.guess_type(bugreport)
+      maintype, subtype = ctype.split("/", 1)
+      with open(bugreport, "rb") as fp:
+        att = base.MIMEBase(maintype, subtype)
+        att.set_payload(fp.read())
+        encoders.encode_base64(att)
+        att.add_header("Content-Disposition", "attachment", filename=bugreport)
+        message.attach(att)
+
+    # Send the message from our special account.
+    server = smtplib.SMTP_SSL(FLAGS.email_smtp_server, FLAGS.email_smtp_port)
+    server.login(FLAGS.email_sender_address, FLAGS.email_sender_password)
+    server.sendmail(FLAGS.email_sender_address, recpient_address,
+                    message.as_string())
+    server.quit()
+    logging.info("Email with subject '%s' has been sent", subject)
+  except:  # pylint:disable=bare-except
+    logging.exception("Failed to send notification email")
+
+
+class ProcessLogger(threading.Thread):
+
+  class EventScanner(object):
+
+    def __init__(self, name, process_name, regexes):
+      """Struct to store the data about an event.
+
+      Args:
+        name: Name of event.
+        process_name: Name of the process that is being logged.
+        regexes: An iteratable of regex strings that indicate an event has
+            happened.
+      """
+
+      self.name = name
+      self.process_name = process_name
+      self.searches = [re.compile(regex).search for regex in regexes]
+      self.count = 0
+
+    def ScanForEvent(self, line, lock=None):
+      """Checks the line for matches. If found, updates the internal counter."""
+
+      for search in self.searches:
+        if search(line.decode("utf-8")):
+          # Grab the lock (if provided), update the counter, and release it.
+          if lock: lock.acquire()
+          self.count += 1
+          if lock: lock.release()
+          logging.info("Event '%s' detected on %s", self.name,
+                       self.process_name)
+
+  def __init__(self, name, command, output, events,
+               restart_process, repeats_output_when_opened):
+    """Threaded class that monitors processes for events, and logs output.
+
+    Args:
+      name: The name of the process being logged.
+      command: A list of arguments to be passed to the subprocess to execute.
+      output: Name of output file to write process stdout to. If blank or None,
+          will not be generated.
+      events: An iterable of LoggingEventConfigs to look for in the output.
+      restart_process: Restart the process if it terminates by itself. This
+          should typically be true, but false for processes that only should be
+          run once and have their output logged.
+      repeats_output_when_opened: Set to true if the process will repeat the
+          output of a previous call when it is restarted. This will prevent
+          duplicate lines from being logged.
+    """
+    super(ProcessLogger, self).__init__()
+    self.name = name
+    self.command = command
+    self.restart_process = restart_process
+    self.repeats_output_when_opened = repeats_output_when_opened
+    self.process = None
+    self.lock = threading.Lock()
+    self.looking = False
+
+    # Compile the list of regexes that we're supposed to be looking for.
+    self.events = []
+    for event in events:
+      self.events.append(ProcessLogger.EventScanner(event.name, self.name,
+                                                    event.regex))
+
+    if output:
+      stress_test_common.MakeDirsIfNeeded(os.path.dirname(output))
+      self.output_fp = open(output, "w")
+      logging.info("Logging device info to %s", output)
+    else:
+      self.output_fp = None
+
+  def GetEventCountsSinceLastCall(self):
+    """Returns the counts of all events since this method was last called."""
+    event_map = {}
+    self.lock.acquire()
+    for event in self.events:
+      event_map[event.name] = event.count
+      event.count = 0
+    self.lock.release()
+    return event_map
+
+  def run(self):
+    last_line = None
+    should_log = True
+    first_run = True
+    self.lock.acquire()
+    last_run_time = 0
+    while self.restart_process:
+      self.lock.release()
+      if not first_run:
+        logging.info("Restarting process %s", "".join(str(self.command)))
+        time_since_last_run = datetime.datetime.now() - last_run_time
+        if time_since_last_run.total_seconds() < 1.0:
+          needed_delay = 1.0 - time_since_last_run.total_seconds()
+          logging.info("Delaying for %.2f seconds", needed_delay)
+          time.sleep(needed_delay)
+      else:
+        first_run = False
+
+      try:
+        if pexpect:
+          self.process = pexpect.spawn(" ".join(self.command), timeout=None)
+          output_source = self.process
+        else:
+          self.process = subprocess.Popen(self.command, stdout=subprocess.PIPE)
+          output_source = self.process.stdout
+        last_run_time = datetime.datetime.now()
+        for line in output_source:
+          # If the process we're logging likes to repeat its output, we need to
+          # look for the last line we saw before we start doing anything with
+          # these lines anymore.
+          if self.repeats_output_when_opened:
+            if not should_log:
+              if last_line == line:
+                should_log = True
+              continue
+
+          if self.output_fp:
+            self.output_fp.write(line.decode("utf-8").rstrip())
+            self.output_fp.write("\n")
+
+          # Loop through all events we're watching for, to see if they occur on
+          # this line. If they do, update the fact that we've seen this event.
+          for event in self.events:
+            if self.looking:
+              event.ScanForEvent(line, lock=self.lock)
+          last_line = line
+      except:  # pylint:disable=bare-except
+        logging.exception("Exception encountered running process")
+      finally:
+        if pexpect:
+          self.process.terminate()
+        else:
+          self.process.send_signal(signal.SIGTERM)
+        should_log = False
+      self.lock.acquire()
+    self.lock.release()
+    if pexpect:
+      if self.process.exitstatus is not None:
+        logging.info("Process finished - exit code %d", self.process.exitstatus)
+      else:
+        logging.info("Process finished - signal code %d",
+                     self.process.signalstatus)
+    else:
+      if self.process.returncode is not None:
+        logging.info("Process finished - return code %d",
+                     self.process.returncode)
+      else:
+        logging.info("Process finished - no return code")
+
+  def StopLogging(self):
+    if self.process:
+      self.lock.acquire()
+      self.restart_process = False
+      self.lock.release()
+
+      if pexpect:
+        self.process.kill(signal.SIGHUP)
+        self.process.kill(signal.SIGINT)
+      else:
+        self.process.send_signal(signal.SIGTERM)
+
+
+class Device(object):
+
+  SECONDS_TO_SLEEP_DURING_ROOT = 0.5
+
+  def __init__(self, serial_number, output_root, test_events, expected_result):
+    """Responsible for monitoring a specific device, and pulling files from it.
+
+    The actual work of the constructor will be handled asynchronously, you must
+    call WaitForTasks() before using the device.
+
+    Args:
+      serial_number: The device serial number.
+      output_root: The directory where to output log files/anything pulled from
+          the device.
+      test_events: The events (with conditions) that come from the StressTest
+          that should be evaluated at every iteration, along with a list of
+          actions to take when one of these events occur. For example, if there
+          have not been any detected hotword triggers, a bugreport can be
+          generated.
+      expected_result: Expected event count to pass the test.
+    """
+    self.serial_number = serial_number
+    self.output_root = output_root
+    self.cmd_string_replacements = {}
+    self.iteration = 0
+    self.cmd_string_replacements["iteration"] = 0
+    self.cmd_string_replacements["serial_number"] = serial_number
+    self.cmd_string_replacements["output_root"] = output_root
+    self.name = None
+    self.process_loggers = []
+    self.event_log = stress_test_pb2.EventLog()
+    self.cnt_per_iteration = expected_result
+
+    # Prepare the work queue, and offload the rest of the init into it.
+    self.work_queue = queue.Queue()
+    self.worker = threading.Thread(target=QueueWorker, args=[self.work_queue])
+    self.worker.daemon = True
+    self.worker.name = self.name
+    self.worker.start()
+    self.abort_requested = False
+    self.remove_device = False
+    self.test_events = test_events
+
+    self.work_queue.put(self.__init_async__)
+
+  def __init_async__(self):
+    # Get the device type, and append it to the serial number.
+    self.device_type = self.Command(["shell", "getprop",
+                                     "ro.product.name"]).strip().decode("utf-8")
+    self.name = "%s_%s" % (self.device_type, self.serial_number)
+    self.worker.name = self.name
+    self.cmd_string_replacements["device"] = self.name
+    logging.info("Setting up device %s", self.name)
+
+    config = stress_test_common.LoadDeviceConfig(self.device_type,
+                                                 self.serial_number)
+
+    # Get the device ready.
+    self.Root()
+
+    # Run any setup commands.
+    for cmd in config.setup_command:
+      result = self.Command(
+          shlex.split(cmd % self.cmd_string_replacements)).strip()
+      if result:
+        for line in result.splitlines():
+          logging.info(line)
+
+    self.files_to_move = config.file_to_move
+
+    self.event_names = set([event.name for event in config.event])
+    self.event_counter = {name: 0 for name in self.event_names}
+    self.iterations_since_event = {name: 0 for name in self.event_names}
+
+    for file_to_watch in config.file_to_watch:
+      # Are there any events that match up with this file?
+      events = [x for x in config.event if x.source == file_to_watch.source]
+
+      if file_to_watch.source == "LOGCAT":
+        command = [
+            "adb", "-s", self.serial_number, "logcat", "-v", "usec", ""
+        ]
+        command.extend(["%s:S" % tag for tag in config.tag_to_suppress])
+        name = "logcat_" + self.serial_number
+      else:
+        command = [
+            "adb", "-s", self.serial_number, "shell",
+            "while : ; do cat %s 2>&1; done" % file_to_watch.source
+        ]
+        name = "%s_%s" % (os.path.basename(
+            file_to_watch.source), self.serial_number)
+
+      process_logger = ProcessLogger(
+          name, command, os.path.join(
+              self.output_root,
+              file_to_watch.destination % self.cmd_string_replacements),
+          events, True, file_to_watch.repeats_output_on_open)
+      self.process_loggers.append(process_logger)
+      process_logger.start()
+
+    # Add any of the background processes.
+    for daemon_process in config.daemon_process:
+      # Are there any events that match up with this file?
+      events = [x for x in config.event if x.source == daemon_process.name]
+      command = shlex.split(
+          daemon_process.command % self.cmd_string_replacements)
+      if daemon_process.destination:
+        output = os.path.join(
+            self.output_root,
+            daemon_process.destination % self.cmd_string_replacements)
+      else:
+        output = None
+      name = "%s_%s" % (daemon_process.name, self.serial_number)
+      process_logger = ProcessLogger(name, command, output, events,
+                                     daemon_process.restart,
+                                     daemon_process.repeats_output_on_open)
+      self.process_loggers.append(process_logger)
+      process_logger.start()
+
+    # Build up the list of events we can actually process.
+    self.__UpdateEventCounters(number_of_iterations=0)
+    test_events = self.test_events
+    self.test_events = []
+    for event in test_events:
+      try:
+        eval(event.condition,  # pylint:disable=eval-used
+             {"__builtins__": None}, self.__ValuesInEval())
+        self.test_events.append(event)
+      except Exception as err:  # pylint:disable=broad-except
+        logging.error("Test event %s is not compatible with %s", event.name,
+                      self.name)
+        logging.error(str(err))
+    # Make sure that device specific events don't have conditions.
+    self.device_events = []
+    for event in config.test_event:
+      if not event.name:
+        logging.error("Device %s test event is missing a name", self.name)
+        continue
+      if event.condition:
+        self.test_events.append(event)
+      else:
+        self.device_events.append(event)
+
+  def StartLookingForEvents(self):
+    """Starts all child ProcessLoggers to start looking for events."""
+    for process_logger in self.process_loggers:
+      process_logger.looking = True
+
+  def __ValuesInEval(self):
+    values_in_eval = {key: value for key, value
+                      in list(self.event_counter.items())}
+    for key, value in list(self.iterations_since_event.items()):
+      values_in_eval["iterations_since_%s" % key] = value
+    return values_in_eval
+
+  def __GetExpectedEventCount(self, event):
+    if event == "logcat_iteration":
+      return -1
+    try:
+      event_cnt = getattr(self.cnt_per_iteration, event)
+    except AttributeError:
+      event_cnt = -1
+      logging.exception("%s is not an attribute of expected_result", event)
+    return event_cnt
+
+  def __UpdateEventCounters(self, number_of_iterations=1):
+    # Update the event counters
+    visited_events = set()
+    error_log = []
+    for process_logger in self.process_loggers:
+      events = process_logger.GetEventCountsSinceLastCall()
+      for event, count in list(events.items()):
+        # Print log when there is any missed event
+        expected_count = self.__GetExpectedEventCount(event)
+
+        if expected_count > 0:
+          if count > expected_count * number_of_iterations:
+            logging.info(
+                "[STRESS_TEST] In iteration %d, got duplicated %s : %d",
+                self.iteration, self.name, count)
+            logging.info("[STRESS_TEST] Will count only : %d",
+                         expected_count * number_of_iterations)
+            count = expected_count * number_of_iterations
+
+        if count:
+          self.event_counter[event] += count
+          visited_events.add(event)
+
+        if expected_count >= 0:
+          if expected_count * number_of_iterations != count:
+            error_log.append(
+                _SUMMARY_COL_FORMATT %
+                (event, count, expected_count * number_of_iterations))
+
+    # Go clear all the events that weren't consecutive.
+    for event in self.iterations_since_event:
+      if event in visited_events:
+        self.iterations_since_event[event] = 0
+      else:
+        self.iterations_since_event[event] += number_of_iterations
+
+    if error_log:
+      logging.info(_SUMMARY_LINES)
+      logging.info(" iteration %d : Something wrong in %s.",
+                   self.iteration, self.name)
+      logging.info(_SUMMARY_LINES)
+      logging.info(_SUMMARY_COLUMNS)
+      logging.info(_SUMMARY_LINES)
+      for line in error_log:
+        logging.info(line)
+      logging.info(_SUMMARY_LINES)
+
+  def ProcessEvents(self):
+    """Updates the event_counter and iterations_since_event maps."""
+    self.work_queue.put(self.__ProcessEventsAsync)
+
+  def __ProcessEventsAsync(self):
+    # Move any files to the local machine that should be moved.
+    if self.files_to_move:
+      for file_to_move in self.files_to_move:
+        try:
+          self.Command(["pull", file_to_move.source, file_to_move.destination])
+        except:  # pylint:disable=bare-except
+          logging.exception("Failed to pull %s", file_to_move.source)
+
+    self.__UpdateEventCounters()
+
+    for event in self.test_events:
+      if eval(event.condition,  # pylint:disable=eval-used
+              {"__builtins__": None}, self.__ValuesInEval()):
+        logging.info("Condition has been met for event '%s'", event.name)
+        # Write the updated event log.
+        event_log_details = self.event_log.event.add()
+        event_log_details.iteration = self.iteration
+        event_log_details.name = event.name
+        with open(os.path.join(self.output_root,
+                               "%s_event_log.ascii_proto" % self.name),
+                  "w") as fp:
+          text_format.PrintMessage(self.event_log, fp)
+
+        # Do whatever other actions that are part of the event.
+        self.__ProcessEventActionQueue(event)
+
+        # Run any device specific actions for this event.
+        for device_event in self.device_events:
+          if device_event.name == event.name:
+            self.__ProcessEventActionQueue(device_event)
+
+    # Set up the next iteration.
+    self.iteration += 1
+    self.cmd_string_replacements["iteration"] = self.iteration
+
+  def __ProcessEventActionQueue(self, event):
+    bugreport = None
+    for action in event.action:
+      if action == "BUGREPORT":
+        bugreport = self.TakeBugReport()
+      elif action.startswith("DUMPSYS "):
+        self.CaptureDumpsys(action[action.find(" ") + 1:])
+      elif action == "NOTIFY":
+        SendNotificationEmail(
+            "%s had event '%s' occur" % (self.name, event.name),
+            "\n".join(["Current Summary:"] + self.GetSummaryLines()), bugreport)
+      elif action == "REMOVE_DEVICE":
+        logging.info("Removing %s from the test", self.serial_number)
+        self.remove_device = True
+      elif action == "ABORT":
+        logging.info("Abort requested")
+        self.abort_requested = True
+      else:
+        action %= self.cmd_string_replacements
+        logging.info("Running command %s on %s", action, self.name)
+        result = self.Command(shlex.split(action)).strip()
+        if result:
+          for line in result.splitlines():
+            logging.info(line)
+
+  def Root(self):
+    self.Command(["root"])
+    time.sleep(Device.SECONDS_TO_SLEEP_DURING_ROOT)
+    self.Command(["wait-for-device"])
+    time.sleep(Device.SECONDS_TO_SLEEP_DURING_ROOT)
+
+  def Stop(self):
+    """Stops all file loggers attached to this device."""
+    for process_logger in self.process_loggers:
+      process_logger.StopLogging()
+    self.process_loggers = []
+
+  def Join(self):
+    for process_logger in self.process_loggers:
+      process_logger.join()
+    self.WaitForTasks()
+
+  def AsyncCommand(self, command, log_output=False):
+    self.work_queue.put(
+        lambda: self.__AsyncCommand(command, log_output=log_output))
+
+  def __AsyncCommand(self, command, log_output=False):
+    result = self.Command(command).strip()
+    if result and log_output:
+      for line in result.splitlines():
+        logging.info(line.decode("utf-8"))
+
+  def Command(self, command):
+    """Runs the provided command on this device."""
+    if command[0] in {"bugreport", "root", "wait-for-device", "shell",
+                      "logcat"}:
+      return subprocess.check_output(
+          ["adb", "-s", self.serial_number] + command)
+    elif command[0] == "DUMPSYS":
+      self.CaptureDumpsys(command[1])
+      return ""
+    elif command[0] == "pull":
+      try:
+        files = subprocess.check_output(
+            ["adb", "-s", self.serial_number, "shell", "ls", command[1]]
+        ).strip().splitlines()
+      except subprocess.CalledProcessError:
+        return ""
+      if len(files) == 1 and "No such file or directory" in files[0]:
+        return ""
+      for source_file in files:
+        destination = os.path.join(self.output_root,
+                                   command[2] % self.cmd_string_replacements)
+        stress_test_common.MakeDirsIfNeeded(os.path.dirname(destination))
+        logging.info("Moving %s from %s to %s", source_file, self.name,
+                     destination)
+        subprocess.check_output(["adb", "-s", self.serial_number, "pull",
+                                 source_file, destination])
+        if FLAGS.delete_data_dir:
+          subprocess.check_output([
+              "adb", "-s", self.serial_number, "shell", "rm", "-rf", source_file
+          ])
+        return ""
+    else:
+      return subprocess.check_output(command)
+
+  def TakeBugReport(self):
+    logging.info("Capturing bugreport on %s", self.name)
+    bugreport = os.path.join(self.output_root,
+                             "%s_bugreport_iteration_%06d.zip" %
+                             (self.name, self.iteration))
+    sdk = int(self.Command(
+        ["shell", "getprop", "ro.build.version.sdk"]).strip())
+    if sdk >= 24:  # SDK 24 = Android N
+      with open(bugreport, "w") as bugreport_fp:
+        bugreport_fp.write(self.Command(["bugreport", bugreport]))
+    else:
+      bugreport_txt = os.path.join(self.output_root,
+                                   "%s_bugreport_iteration_%06d.txt" %
+                                   (self.name, self.iteration))
+      with open(bugreport_txt, "w") as bugreport_fp:
+        bugreport_fp.write(self.Command(["bugreport"]))
+      self.Command(["zip", bugreport, bugreport_txt])
+
+    self.Command(["pull", "/data/anr/traces.txt",
+                  "%s_traces_iteration_%06d.txt" % (self.name, self.iteration)])
+    self.Command(["pull", "/data/anr/traces.txt.bugreport",
+                  "%s_traces_iteration_%06d.txt.bugreport" % (self.name,
+                                                              self.iteration)])
+    return bugreport
+
+  def CaptureDumpsys(self, dumpsys_unit):
+    logging.info("Taking dumpsys %s on %s", dumpsys_unit, self.name)
+    stress_test_common.MakeDirsIfNeeded(os.path.join(self.output_root,
+                                                     self.name))
+    with open(os.path.join(self.output_root, self.name,
+                           "%s_%06d.txt" % (dumpsys_unit, self.iteration)),
+              "w") as dumpsys_fp:
+      dumpsys_fp.write(self.Command(["shell", "dumpsys", dumpsys_unit]))
+
+  def WaitForTasks(self):
+    self.work_queue.join()
+
+  def GetSummaryLines(self):
+    lines = [
+        "Device {}".format(self.name),
+        _SUMMARY_LINES, _SUMMARY_COLUMNS, _SUMMARY_LINES
+    ]
+    for event, count in sorted(self.event_counter.items()):
+      lines.append(_SUMMARY_COL_FORMATT % (
+          event, count, self.iterations_since_event[event]))
+    lines.append(_SUMMARY_LINES)
+    return lines
+
+
+def RunAsyncCommand(devices, command):
+  """Helper function for running async commands on many devices."""
+  for device in devices:
+    device.AsyncCommand(command)
+  for device in devices:
+    device.WaitForTasks()
+
+
+class StressTest(object):
+  """Manages dispatching commands to devices/playing audio and events."""
+
+  def __init__(self, output_root, test_name):
+    self.output_root = output_root
+    self.devices = []
+    self.test_name = test_name
+    config = stress_test_pb2.StressTestConfig()
+    config_contents = stress_test_common.GetResourceContents(
+        os.path.join(stress_test_common.RESOURCE_DIR,
+                     "stress_test.%s.ascii_proto" % test_name))
+    text_format.Merge(config_contents, config)
+    self.events = config.event
+    self.setup_commands = config.setup_command
+    self.steps = config.step
+    self.audio_tempfiles = {}
+    self.uuid = str(uuid.uuid4())
+    self.expected_result = None
+    self.iteration = 0
+    if config.expected_result:
+      self.expected_result = config.expected_result[0]
+
+    # Place all the audio files into temp files.
+    for step in self.steps:
+      if step.audio_file and step.audio_file not in self.audio_tempfiles:
+        # We can't delete the temp file on windows, since it gets nuked too
+        # early.
+        audio_tempfile = tempfile.NamedTemporaryFile(
+            delete=(platform.system() != "Windows"),
+            dir="." if platform.system().startswith("CYGWIN") else None
+        )
+        if platform.system().startswith("CYGWIN"):
+          audio_tempfile.name = os.path.basename(audio_tempfile.name)
+        self.audio_tempfiles[step.audio_file] = audio_tempfile
+        if FLAGS.use_sox:
+          # Write out the raw PCM samples as a wave file.
+          audio_tempfile.write(
+              stress_test_common.GetResourceContents(step.audio_file))
+        else:
+          # Make a temporary wave file for playout if we can't use sox.
+          wavefile = wave.open(audio_tempfile, "wb")
+          if step.audio_file_sample_rate <= 0:
+            step.audio_file_sample_rate = 16000
+          wavefile.setframerate(step.audio_file_sample_rate)
+          if step.audio_file_num_channels <= 0:
+            step.audio_file_num_channels = 1
+          wavefile.setnchannels(step.audio_file_num_channels)
+          if not step.audio_file_format:
+            wavefile.setsampwidth(2)
+          elif step.audio_file_format == "s8":
+            wavefile.setsampwidth(1)
+          elif step.audio_file_format == "s16":
+            wavefile.setsampwidth(2)
+          elif step.audio_file_format == "s32":
+            wavefile.setsampwidth(4)
+          else:
+            raise RuntimeError(
+                "Unsupported wave file format for %s" % step.audio_file)
+          wavefile.writeframes(stress_test_common.GetResourceContents(
+              step.audio_file))
+          wavefile.close()
+        audio_tempfile.flush()
+
+        if platform.system() == "Windows":
+          audio_tempfile.close()
+
+    # Create all the devices that are attached to this machine.
+    for serial_number in self.GetActiveSerialNumbers():
+      self.devices.append(
+          Device(serial_number, output_root, self.events, self.expected_result))
+    if not self.devices:
+      raise app.UsageError("No devices connected")
+
+    self.devices.sort(key=lambda x: x.name)
+
+    # Make sure every device is done with their work for setup.
+    for device in self.devices:
+      device.WaitForTasks()
+
+    # Write out the info meta-data proto. Useful for doing analysis of the logs
+    # after the stress test has completed.
+    stress_test_info = stress_test_pb2.StressTestInfo()
+    stress_test_info.test_name = self.test_name
+    stress_test_info.test_description = config.description
+    stress_test_info.uuid = self.uuid
+    for device in self.devices:
+      device_pb = stress_test_info.device.add()
+      device_pb.device_type = device.device_type
+      device_pb.serial_number = device.serial_number
+
+    text_format.PrintMessage(stress_test_info, open(os.path.join(
+        self.output_root, "stress_test_info.ascii_proto"), "w"))
+
+  def GetActiveSerialNumbers(self):
+    serial_numbers = []
+    for line in sorted(
+        subprocess.check_output(["adb", "devices"]).splitlines()):
+      if line.endswith(b"device"):
+        serial_number = line.split()[0].strip()
+        if FLAGS.devices and serial_number not in FLAGS.devices:
+          continue
+        serial_numbers.append(serial_number.decode("utf-8"))
+    return serial_numbers
+
+  def Start(self):
+    logging.info("Waiting for devices to settle")
+    time.sleep(5)
+    # Make a copy of the device list, as we'll be modifying this actual list.
+    devices = list(self.devices)
+    dropped_devices = []
+
+    # If we have any setup commands, run them.
+    for command in self.setup_commands:
+      logging.info("Running command %s", command)
+      # Can't use the async command helper function since we need to get at
+      # the device cmd_string_replacements.
+      for device in devices:
+        device.AsyncCommand(
+            shlex.split(command % device.cmd_string_replacements),
+            log_output=True)
+      for device in devices:
+        device.WaitForTasks()
+
+    for device in devices:
+      device.StartLookingForEvents()
+      device.AsyncCommand(["shell", "log", "-t", "STRESS_TEST",
+                           "Starting {%s} TZ=$(getprop persist.sys.timezone) "
+                           "YEAR=$(date +%%Y)" % self.uuid], True)
+    self.iteration = 0
+    while True:
+      logging.info("Starting iteration %d", self.iteration)
+      # Perform all the actions specified in the test.
+      RunAsyncCommand(devices, [
+          "shell", "log", "-t", "STRESS_TEST",
+          "Performing iteration %d $(head -n 3 "
+          "/proc/timer_list | tail -n 1)" % self.iteration
+      ])
+
+      for step in self.steps:
+        if step.delay_before:
+          logging.info("Waiting for %.2f seconds", step.delay_before)
+          time.sleep(step.delay_before)
+
+        if step.audio_file:
+          logging.info("Playing %s", step.audio_file)
+          RunAsyncCommand(devices, ["shell", "log", "-t", "STRESS_TEST",
+                                    "Playing %s" % step.audio_file])
+
+          if FLAGS.use_sox:
+            subprocess.check_call(["sox", "-q",
+                                   self.audio_tempfiles[step.audio_file].name,
+                                   "-d"])
+          elif platform.system() == "Windows":
+            import winsound  # pylint:disable=g-import-not-at-top
+            winsound.PlaySound(self.audio_tempfiles[step.audio_file].name,
+                               winsound.SND_FILENAME | winsound.SND_NODEFAULT)
+          else:
+            raise app.RuntimeError("Unsupported platform for audio playback")
+
+        if step.command:
+          logging.info("Running command %s", step.command)
+          # Can't use the async command helper function since we need to get at
+          # the device cmd_string_replacements.
+          for device in devices:
+            device.AsyncCommand(
+                shlex.split(step.command % device.cmd_string_replacements),
+                log_output=True)
+          for device in devices:
+            device.WaitForTasks()
+
+        if step.delay_after:
+          logging.info("Waiting for %.2f seconds", step.delay_after)
+          time.sleep(step.delay_after)
+
+      RunAsyncCommand(devices, [
+          "shell", "log", "-t", "STRESS_TEST",
+          "Iteration %d complete $(head -n 3 "
+          "/proc/timer_list | tail -n 1)" % self.iteration
+      ])
+      self.iteration += 1
+
+      # TODO(somebody): Sometimes the logcat seems to get stuck and buffers for
+      # a bit. This throws off the event counts, so we should probably add some
+      # synchronization rules before we trigger any events.
+
+      # Go through each device, update the event counter, and see if we need to
+      # trigger any events.
+      devices_to_remove = []
+      abort_requested = False
+      active_devices = self.GetActiveSerialNumbers()
+      for device in devices:
+        if device.serial_number in active_devices:
+          device.ProcessEvents()
+        else:
+          logging.error("Dropped device %s", device.name)
+          SendNotificationEmail(
+              "Dropped device %s" % device.name,
+              "Device %s is not longer present in the system" % device.name)
+          dropped_devices.append(device)
+          devices_to_remove.append(device)
+
+      # Check to see if any of the dropped devices have come back. If yes, grab
+      # a bug report.
+      for device in dropped_devices:
+        if device.serial_number in active_devices:
+          logging.info("Device %s reappeared", device.name)
+          device.Root()
+          device.TakeBugReport()
+
+      dropped_devices = [d for d in dropped_devices
+                         if d.serial_number not in active_devices]
+
+      for device in devices:
+        device.WaitForTasks()
+        if device.remove_device:
+          devices_to_remove.append(device)
+        if device.abort_requested:
+          abort_requested = True
+
+      # Remove devices from our list of things to monitor if they've been marked
+      # for deletion.
+      if devices_to_remove:
+        for device in devices_to_remove:
+          device.Stop()
+        devices = [d for d in devices if d not in devices_to_remove]
+
+      # Print out the iteration summary.
+      if self.iteration % FLAGS.print_summary_every_n == 0:
+        for line in self.GetSummaryLines():
+          logging.info(line)
+
+      # See if we need to break out of the outer loop.
+      if abort_requested or not devices:
+        break
+      if FLAGS.num_iterations:
+        if self.iteration >= FLAGS.num_iterations:
+          logging.info("Completed full iteration : %d", self.iteration)
+          break
+    SendNotificationEmail(
+        "Stress test %s completed" % (FLAGS.test_name),
+        "\n".join(["Summary:"] + self.GetSummaryLines()))
+
+  def Stop(self):
+    logging.debug("Stopping devices")
+    for device in self.devices:
+      device.Stop()
+    for device in self.devices:
+      device.Join()
+
+  def GetSummaryLines(self):
+    lines = [
+        _SUMMARY_LINES,
+        "Conducted %d iterations out of %d" %
+        (self.iteration, FLAGS.num_iterations),
+        _SUMMARY_LINES
+    ]
+    for device in self.devices:
+      lines.extend(device.GetSummaryLines())
+    lines.append(_SUMMARY_LINES)
+    return lines
+
+
+def main(unused_argv):
+  # Check to make sure that there are no other instances of ADB running - if
+  # there are, print a warning and wait a bit for them to see it and decide if
+  # they want to keep running, knowing that logs may be invalid.
+  try:
+    if "adb" in subprocess.check_output(["ps", "-ale"]).decode("utf-8"):
+      print("It looks like there are other instances of adb running. If these "
+            "other instances are also cating log files, you will not be "
+            "capturing everything in this stress test (so logs will be "
+            "invalid).")
+      print("Continuing in 3...", end=" ")
+      sys.stdout.flush()
+      for i in [2, 1, 0]:
+        time.sleep(1)
+        if i:
+          print("%d..." % i, end=" ")
+        else:
+          print("")
+        sys.stdout.flush()
+  except OSError:
+    print("Unexpected error:", sys.exc_info()[0])
+    if sys.platform.startswith("win"):
+      pass
+    else:
+      raise
+
+  # Make the base output directory.
+  output_root = os.path.join(FLAGS.output_root, "%s_%s" % (
+      FLAGS.test_name, datetime.datetime.now().strftime("%Y%m%d_%H%M%S")))
+  # output_root = os.path.join(FLAGS.output_root, FLAGS.test_name)
+  stress_test_common.MakeDirsIfNeeded(output_root)
+
+  # Set up logging.
+  formatter = logging.Formatter(
+      "%(levelname)-1.1s %(asctime)s [%(threadName)-16.16s] %(message)s")
+  root_logger = logging.getLogger()
+  root_logger.setLevel(logging.INFO)
+  root_logger.setLevel(logging.DEBUG)
+
+  file_handler = logging.FileHandler(os.path.join(output_root,
+                                                  "stress_test.log"))
+  file_handler.setFormatter(formatter)
+  root_logger.addHandler(file_handler)
+
+  console_handler = logging.StreamHandler()
+  console_handler.setFormatter(formatter)
+  root_logger.addHandler(console_handler)
+
+  stress_test = StressTest(output_root, FLAGS.test_name)
+  try:
+    stress_test.Start()
+  finally:
+    logging.info("Stopping device logging threads")
+    stress_test.Stop()
+    for line in stress_test.GetSummaryLines():
+      logging.info(line)
+    if FLAGS.delete_data_dir:
+      print("Deleting Data Dir")
+      subprocess.check_output(["rm", "-r", "-f", output_root])
+
+
+if __name__ == "__main__":
+  app.run(main)
diff --git a/stress_test_common.py b/stress_test_common.py
new file mode 100644
index 0000000..6bc7baa
--- /dev/null
+++ b/stress_test_common.py
@@ -0,0 +1,104 @@
+# Copyright 2020 Google LLC
+#
+# 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.
+
+"""Common functions for the stress tester."""
+
+import logging
+import os
+
+from absl import flags
+import stress_test_pb2
+from google.protobuf import text_format
+
+FLAGS = flags.FLAGS
+
+flags.DEFINE_string("resource_path", None,
+                    "Optional override path where to grab resources from. By "
+                    "default, resources are grabbed from "
+                    "stress_test_common.RESOURCE_DIR, specifying this flag "
+                    "will instead result in first looking in this path before "
+                    "the module defined resource directory.")
+
+RESOURCE_DIR = "resources/"
+
+
+def MakeDirsIfNeeded(path):
+  """Helper function to create all the directories on a path."""
+  if not os.path.isdir(path):
+    os.makedirs(path)
+
+
+def GetResourceContents(resource_name):
+  """Gets a string containing the named resource."""
+  # Look in the resource override folder first (just go with the basename to
+  # find the file, rather than the full path).
+  if FLAGS.resource_path:
+    path = os.path.join(FLAGS.resource_path, os.path.basename(resource_name))
+    if os.path.exists(path):
+      return open(path, "rb").read()
+
+  # If the full path exists, grab that, otherwise fall back to the basename.
+  if os.path.exists(resource_name):
+    return open(resource_name, "rb").read()
+  return open(os.path.join(RESOURCE_DIR, os.path.basename(resource_name)),
+              "rb").read()
+
+
+def LoadDeviceConfig(device_type, serial_number):
+  """Assembles a DeviceConfig proto following all includes, or the default."""
+
+  config = stress_test_pb2.DeviceConfig()
+  text_format.Merge(GetResourceContents(
+      os.path.join(RESOURCE_DIR, "device_config.common.ascii_proto")), config)
+  def RecursiveIncludeToConfig(resource_prefix, print_error):
+    """Load configurations recursively."""
+    try:
+      new_config = stress_test_pb2.DeviceConfig()
+      text_format.Merge(GetResourceContents(
+          os.path.join(RESOURCE_DIR,
+                       "device_config.%s.ascii_proto" % resource_prefix)),
+                        new_config)
+      for include_name in new_config.include:
+        # If we've managed to import this level properly, then we should print
+        # out any errors if we hit them on the included files.
+        RecursiveIncludeToConfig(include_name, print_error=True)
+      config.MergeFrom(new_config)
+    except IOError as err:
+      if print_error:
+        logging.error(str(err))
+
+  RecursiveIncludeToConfig(device_type, print_error=True)
+  RecursiveIncludeToConfig(serial_number, print_error=False)
+
+  def TakeOnlyLatestFromRepeatedField(message, field, key):
+    """Take only the latest version."""
+    old_list = list(getattr(message, field))
+    message.ClearField(field)
+    new_list = []
+    for i in range(len(old_list) - 1, -1, -1):
+      element = old_list[i]
+      if not any([getattr(x, key) == getattr(element, key)
+                  for x in old_list[i + 1:]]):
+        new_list.append(element)
+    getattr(message, field).extend(reversed(new_list))
+
+  # We actually need to do a bit of post-processing on the proto - we only want
+  # to take the latest version for each (that way people can override stuff if
+  # they want)
+  TakeOnlyLatestFromRepeatedField(config, "file_to_watch", "source")
+  TakeOnlyLatestFromRepeatedField(config, "file_to_move", "source")
+  TakeOnlyLatestFromRepeatedField(config, "event", "name")
+  TakeOnlyLatestFromRepeatedField(config, "daemon_process", "name")
+
+  return config