diff --git a/Cargo.lock b/Cargo.lock
index 2e97599..f2c0f1d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -32,6 +32,19 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
+[[package]]
+name = "ansi-to-tui"
+version = "7.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67555e1f1ece39d737e28c8a017721287753af3f93225e4a445b29ccb0f5912c"
+dependencies = [
+ "nom",
+ "ratatui",
+ "simdutf8",
+ "smallvec",
+ "thiserror",
+]
+
 [[package]]
 name = "anstream"
 version = "0.6.18"
@@ -253,6 +266,7 @@ checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
 dependencies = [
  "bitflags",
  "crossterm_winapi",
+ "futures-core",
  "mio",
  "parking_lot",
  "rustix",
@@ -332,13 +346,16 @@ dependencies = [
 name = "debug-tui"
 version = "0.1.0"
 dependencies = [
+ "ansi-to-tui",
  "anyhow",
  "base64",
  "better-panic",
  "cc",
  "clap",
  "crossterm",
+ "futures",
  "log",
+ "ordered_hash_map",
  "pretty_assertions",
  "ratatui",
  "serde",
@@ -423,6 +440,95 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
 [[package]]
 name = "fxhash"
 version = "0.2.1"
@@ -566,6 +672,12 @@ version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
 [[package]]
 name = "miniz_oxide"
 version = "0.8.5"
@@ -593,6 +705,16 @@ version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
 [[package]]
 name = "object"
 version = "0.36.7"
@@ -608,6 +730,15 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "ordered_hash_map"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6c699f8a30f345785be969deed7eee4c73a5de58c7faf61d6a3251ef798ff61"
+dependencies = [
+ "hashbrown",
+]
+
 [[package]]
 name = "parking_lot"
 version = "0.12.3"
@@ -695,6 +826,12 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
 [[package]]
 name = "precomputed-hash"
 version = "0.1.1"
@@ -985,6 +1122,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
 [[package]]
 name = "simple-logging"
 version = "2.0.2"
@@ -1002,6 +1145,12 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
+[[package]]
+name = "slab"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
+
 [[package]]
 name = "slotmap"
 version = "1.0.7"
@@ -1095,6 +1244,26 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
+]
+
 [[package]]
 name = "thread-id"
 version = "3.3.0"
diff --git a/Cargo.toml b/Cargo.toml
index 1cc77f8..89b68f4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,12 +6,15 @@ edition = "2021"
 [build-dependencies]
 cc="*"
 [dependencies]
+ansi-to-tui = "7.0.0"
 anyhow = "1.0.97"
 base64 = "0.22.1"
 better-panic = "0.3.0"
 clap = { version = "4.5.35", features = ["derive"] }
-crossterm = "0.28.1"
+crossterm = { version = "0.28.1", features = ["event-stream"] }
+futures = "0.3.31"
 log = "0.4.27"
+ordered_hash_map = "0.5.0"
 pretty_assertions = "1.4.1"
 ratatui = "0.29.0"
 serde = { version = "1.0.219", features = ["derive"] }
diff --git a/debug.loh b/debug.loh
new file mode 100644
index 0000000..e68b31e
--- /dev/null
+++ b/debug.loh
@@ -0,0 +1,29 @@
+[00:00:00.000] (7ffa3507f440) INFO   Handling event Startup
+[00:00:00.000] (7ffa2edf66c0) TRACE  registering event source with poller: token=Token(140711450119680), interests=READABLE | WRITABLE
+[00:00:00.648] (7ffa34dff6c0) TRACE  registering event source with poller: token=Token(140712523862528), interests=READABLE | WRITABLE
+[00:00:00.648] (7ffa3507f440) INFO   Handling event ClientConnected(PollEvented { io: Some(TcpStream { addr: 127.0.0.1:9003, peer: 127.0.0.1:47680, fd: 14 }) })
+[00:00:00.648] (7ffa3507f440) DEBUG  [dbgp] << <?xml version="1.0" encoding="iso-8859-1"?>
+<init xmlns="urn:debugger_protocol_v1" xmlns:xdebug="https://xdebug.org/dbgp/xdebug" fileuri="file:///home/daniel/www/dantleech/debug-tui/php/test.php" language="PHP" xdebug:language_version="8.4.3" protocol_version="1.0" appid="2532590" xdebug:ctrl_socket="xdebug-ctrl.2532590"><engine version="3.4.1"><![CDATA[Xdebug]]></engine><author><![CDATA[Derick Rethans]]></author><url><![CDATA[https://xdebug.org]]></url><copyright><![CDATA[Copyright (c) 2002-2025 by Derick Rethans]]></copyright></init>
+[00:00:00.648] (7ffa3507f440) INFO   setting feature max_depth to "4"
+[00:00:00.648] (7ffa3507f440) DEBUG  [dbgp] >> feature_set -i 0 -n max_depth -v 4
+[00:00:00.648] (7ffa3507f440) DEBUG  [dbgp] << <?xml version="1.0" encoding="iso-8859-1"?>
+<response xmlns="urn:debugger_protocol_v1" xmlns:xdebug="https://xdebug.org/dbgp/xdebug" command="feature_set" transaction_id="0" feature="max_depth" success="1"></response>
+[00:00:00.648] (7ffa3507f440) INFO   setting feature extended_properties to "1"
+[00:00:00.648] (7ffa3507f440) DEBUG  [dbgp] >> feature_set -i 1 -n extended_properties -v 1
+[00:00:00.648] (7ffa3507f440) DEBUG  [dbgp] << <?xml version="1.0" encoding="iso-8859-1"?>
+<response xmlns="urn:debugger_protocol_v1" xmlns:xdebug="https://xdebug.org/dbgp/xdebug" command="feature_set" transaction_id="1" feature="extended_properties" success="1"></response>
+[00:00:00.649] (7ffa3507f440) DEBUG  [dbgp] >> source -i 2 -f file:///home/daniel/www/dantleech/debug-tui/php/test.php
+[00:00:00.652] (7ffa3507f440) DEBUG  [dbgp] << <?xml version="1.0" encoding="iso-8859-1"?>
+<response xmlns="urn:debugger_protocol_v1" xmlns:xdebug="https://xdebug.org/dbgp/xdebug" command="source" transaction_id="2" encoding="base64"><![CDATA[PD9waHAKCiRhcnJheSA9IFsKICAgICdpbnQnID0+IDEyMywKICAgICdmbG9hdCcgPT4gMTIzLjQsCiAgICAnc3RyaW5nJyA9PiAic3RyaW5nIiwKICAgICdib29sJyA9PiB0cnVlLAogICAgJ21vcmUnID0+IFsKICAgICAgICAnaW50JyA9PiAxMjMsCiAgICAgICAgJ2Zsb2F0JyA9PiAxMjMuNCwKICAgICAgICAnc3RyaW5nJyA9PiAic3RyaW5nIiwKICAgICAgICAnYm9vbCcgPT4gdHJ1ZSwKICAgIF0sCl07CiRhID0gMjsKJGZvbyA9ICRhOwokZm9vID0gJGFycmF5OwoKJGJhciA9ICRmb287CgoKKG5ldyBGb28odHJ1ZSwgImZvbyIpKS0+bWV0aG9kMygpOwpjYWxsX2Z1bmN0aW9uKCJoZWxsbyIpOwoKCgpmdW5jdGlvbiBjYWxsX2Z1bmN0aW9uKHN0cmluZyAkaGVsbG8pIHsKICAgICR2YXIgPSAxMjM7CiAgICAkb2JqID0gbmV3IEZvbyhmYWxzZSwgJ2dvb2QgZGF5Jyk7CiAgICBhbm90aGVyX2Z1bmN0aW9uKCRoZWxsbyk7CiAgICBhbm90aGVyX2Z1bmN0aW9uKCRoZWxsbyk7CiAgICBhbm90aGVyX2Z1bmN0aW9uKCRoZWxsbyk7Cn0KCmZ1bmN0aW9uIGFub3RoZXJfZnVuY3Rpb24oc3RyaW5nICRnb29kYnllKSB7CiAgICBlY2hvICRnb29kYnllOwoKCiAgICBmb3JlYWNoIChbJ29uZScsICd0d28nLCAndGhyZWUnLCAnZm91ciddIGFzICRudW1iZXIpIHsKICAgICAgICBpZiAoJG51bWJlciA9PT0gJ29uZScpIHsKICAgICAgICAgICAgZWNobyAibnVtYmVyIjsKICAgICAgICB9CiAgICAgICAgZWNobyAkbnVtYmVyOwogICAgfQp9CgpjbGFzcyBGb28gewogICAgcHVibGljIGZ1bmN0aW9uIF9fY29uc3RydWN0KHB1YmxpYyBib29sICR0cnVlLCBwdWJsaWMgc3RyaW5nICRiYXIpIHt9CiAgICBwdWJsaWMgZnVuY3Rpb24gbWV0aG9kMSgpIHsKICAgIH0KICAgIHB1YmxpYyBmdW5jdGlvbiBtZXRob2QyKCkgewogICAgfQogICAgcHVibGljIGZ1bmN0aW9uIG1ldGhvZDMoKSB7CiAgICB9Cn0KCg==]]></response>
+[00:00:06.466] (7ffa3507f440) INFO   Handling event Input(KeyEvent { code: Char('r'), modifiers: KeyModifiers(0x0), kind: Press, state: KeyEventState(0x0) })
+[00:00:06.478] (7ffa3507f440) INFO   Handling event Run
+[00:00:06.478] (7ffa34dff6c0) INFO   Running iteration 0/1
+[00:00:06.478] (7ffa34dff6c0) DEBUG  [dbgp] >> run -i 3 
+[00:00:06.478] (7ffa2eff76c0) DEBUG  [dbgp] << <?xml version="1.0" encoding="iso-8859-1"?>
+<response xmlns="urn:debugger_protocol_v1" xmlns:xdebug="https://xdebug.org/dbgp/xdebug" command="run" transaction_id="3" status="stopping" reason="ok"></response>
+[00:00:06.481] (7ffa3507f440) INFO   Handling event UpdateStatus(Stopping)
+[00:00:06.484] (7ffa3507f440) INFO   Handling event Disconnect
+[00:00:06.484] (7ffa3507f440) TRACE  deregistering event source from poller
+[00:00:06.487] (7ffa3507f440) INFO   Handling event ChangeSessionViewMode(History)
+[00:00:09.778] (7ffa3507f440) INFO   Handling event Quit
+[00:00:09.779] (7ffa347fc6c0) TRACE  deregistering event source from poller
diff --git a/demo/demo.tape b/demo/demo.tape
new file mode 100644
index 0000000..9713a85
--- /dev/null
+++ b/demo/demo.tape
@@ -0,0 +1,108 @@
+# VHS documentation
+#
+# Output:
+#   Output <path>.gif               Create a GIF output at the given <path>
+#   Output <path>.mp4               Create an MP4 output at the given <path>
+#   Output <path>.webm              Create a WebM output at the given <path>
+#
+# Require:
+#   Require <string>                Ensure a program is on the $PATH to proceed
+#
+# Settings:
+#   Set FontSize <number>           Set the font size of the terminal
+#   Set FontFamily <string>         Set the font family of the terminal
+#   Set Height <number>             Set the height of the terminal
+#   Set Width <number>              Set the width of the terminal
+#   Set LetterSpacing <float>       Set the font letter spacing (tracking)
+#   Set LineHeight <float>          Set the font line height
+#   Set LoopOffset <float>%         Set the starting frame offset for the GIF loop
+#   Set Theme <json|string>         Set the theme of the terminal
+#   Set Padding <number>            Set the padding of the terminal
+#   Set Framerate <number>          Set the framerate of the recording
+#   Set PlaybackSpeed <float>       Set the playback speed of the recording
+#   Set MarginFill <file|#000000>   Set the file or color the margin will be filled with.
+#   Set Margin <number>             Set the size of the margin. Has no effect if MarginFill isn't set.
+#   Set BorderRadius <number>       Set terminal border radius, in pixels.
+#   Set WindowBar <string>          Set window bar type. (one of: Rings, RingsRight, Colorful, ColorfulRight)
+#   Set WindowBarSize <number>      Set window bar size, in pixels. Default is 40.
+#   Set TypingSpeed <time>          Set the typing speed of the terminal. Default is 50ms.
+#
+# Sleep:
+#   Sleep <time>                    Sleep for a set amount of <time> in seconds
+#
+# Type:
+#   Type[@<time>] "<characters>"    Type <characters> into the terminal with a
+#                                   <time> delay between each character
+#
+# Keys:
+#   Backspace[@<time>] [number]     Press the Backspace key
+#   Down[@<time>] [number]          Press the Down key
+#   Enter[@<time>] [number]         Press the Enter key
+#   Space[@<time>] [number]         Press the Space key
+#   Tab[@<time>] [number]           Press the Tab key
+#   Left[@<time>] [number]          Press the Left Arrow key
+#   Right[@<time>] [number]         Press the Right Arrow key
+#   Up[@<time>] [number]            Press the Up Arrow key
+#   Down[@<time>] [number]          Press the Down Arrow key
+#   PageUp[@<time>] [number]        Press the Page Up key
+#   PageDown[@<time>] [number]      Press the Page Down key
+#   Ctrl+<key>                      Press the Control key + <key> (e.g. Ctrl+C)
+#
+# Display:
+#   Hide                            Hide the subsequent commands from the output
+#   Show                            Show the subsequent commands in the output
+
+Output example/demo/demo.gif
+
+Require echo
+
+Set Shell "zsh"
+Set FontSize 12
+Set Width 800
+Set Height 500
+Set Padding 10
+Set Margin 10
+Set MarginFill "#505E8E"
+Set BorderRadius 10
+Set Framerate 10
+
+Type@10ms "./target/debug/debug-tui php/test.php" Enter
+Sleep 0.25s
+Type@10ms "n"
+Sleep 0.25s
+Type@10ms "n"
+Sleep 0.25s
+Type@10ms "n"
+Sleep 0.25s
+Type@10ms "p" "p"
+Sleep 0.25s
+Type@10ms "n" "n" "n" "n"
+Tab@10ms
+Sleep 0.25s
+Tab@10ms
+Sleep 0.5s
+Type@10ms "j" "j" "j"
+Sleep 0.5s
+Type@10ms "k" "k" "k"
+Sleep 0.5s
+Type@100ms "e" "$array"
+Sleep 0.5s
+Enter
+Sleep 0.5s
+Tab@10ms
+Tab@10ms
+Tab@10ms
+Sleep 0.5s
+Enter
+Sleep 1s
+Enter
+Type@10ms "n10"
+Sleep 1s
+Type@10ms "n10"
+Sleep 1s
+Tab@10ms
+Tab@10ms
+Tab@10ms
+Tab@10ms
+Type@10ms "j" "j" "j"
+Sleep 1
diff --git a/example/demo/demo.gif b/example/demo/demo.gif
new file mode 100644
index 0000000..4236260
Binary files /dev/null and b/example/demo/demo.gif differ
diff --git a/php/large.php b/php/large.php
new file mode 100644
index 0000000..2492cc1
--- /dev/null
+++ b/php/large.php
@@ -0,0 +1,2536 @@
+<?php
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PHPUnit\Framework;
+
+use DeepCopy\DeepCopy;
+use PHPUnit\Framework\Constraint\Exception as ExceptionConstraint;
+use PHPUnit\Framework\Constraint\ExceptionCode;
+use PHPUnit\Framework\Constraint\ExceptionMessage;
+use PHPUnit\Framework\Constraint\ExceptionMessageRegularExpression;
+use PHPUnit\Framework\MockObject\Generator as MockGenerator;
+use PHPUnit\Framework\MockObject\Matcher\AnyInvokedCount as AnyInvokedCountMatcher;
+use PHPUnit\Framework\MockObject\Matcher\InvokedAtIndex as InvokedAtIndexMatcher;
+use PHPUnit\Framework\MockObject\Matcher\InvokedAtLeastCount as InvokedAtLeastCountMatcher;
+use PHPUnit\Framework\MockObject\Matcher\InvokedAtLeastOnce as InvokedAtLeastOnceMatcher;
+use PHPUnit\Framework\MockObject\Matcher\InvokedAtMostCount as InvokedAtMostCountMatcher;
+use PHPUnit\Framework\MockObject\Matcher\InvokedCount as InvokedCountMatcher;
+use PHPUnit\Framework\MockObject\MockBuilder;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\MockObject\Stub\ConsecutiveCalls as ConsecutiveCallsStub;
+use PHPUnit\Framework\MockObject\Stub\Exception as ExceptionStub;
+use PHPUnit\Framework\MockObject\Stub\ReturnArgument as ReturnArgumentStub;
+use PHPUnit\Framework\MockObject\Stub\ReturnCallback as ReturnCallbackStub;
+use PHPUnit\Framework\MockObject\Stub\ReturnSelf as ReturnSelfStub;
+use PHPUnit\Framework\MockObject\Stub\ReturnStub;
+use PHPUnit\Framework\MockObject\Stub\ReturnValueMap as ReturnValueMapStub;
+use PHPUnit\Runner\BaseTestRunner;
+use PHPUnit\Runner\PhptTestCase;
+use PHPUnit\Util\GlobalState;
+use PHPUnit\Util\InvalidArgumentHelper;
+use PHPUnit\Util\PHP\AbstractPhpProcess;
+use Prophecy;
+use Prophecy\Exception\Prediction\PredictionException;
+use Prophecy\Prophet;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionObject;
+use SebastianBergmann\Comparator\Comparator;
+use SebastianBergmann\Comparator\Factory as ComparatorFactory;
+use SebastianBergmann\Diff\Differ;
+use SebastianBergmann\Exporter\Exporter;
+use SebastianBergmann\GlobalState\Blacklist;
+use SebastianBergmann\GlobalState\Restorer;
+use SebastianBergmann\GlobalState\Snapshot;
+use SebastianBergmann\ObjectEnumerator\Enumerator;
+use Text_Template;
+use Throwable;
+
+/**
+ * A TestCase defines the fixture to run multiple tests.
+ *
+ * To define a TestCase
+ *
+ *   1) Implement a subclass of PHPUnit\Framework\TestCase.
+ *   2) Define instance variables that store the state of the fixture.
+ *   3) Initialize the fixture state by overriding setUp().
+ *   4) Clean-up after a test by overriding tearDown().
+ *
+ * Each test runs in its own fixture so there can be no side effects
+ * among test runs.
+ *
+ * Here is an example:
+ *
+ * <code>
+ * <?php
+ * class MathTest extends PHPUnit\Framework\TestCase
+ * {
+ *     public $value1;
+ *     public $value2;
+ *
+ *     protected function setUp()
+ *     {
+ *         $this->value1 = 2;
+ *         $this->value2 = 3;
+ *     }
+ * }
+ * ?>
+ * </code>
+ *
+ * For each test implement a method which interacts with the fixture.
+ * Verify the expected results with assertions specified by calling
+ * assert with a boolean.
+ *
+ * <code>
+ * <?php
+ * public function testPass()
+ * {
+ *     $this->assertTrue($this->value1 + $this->value2 == 5);
+ * }
+ * ?>
+ * </code>
+ */
+abstract class TestCase extends Assert implements Test, SelfDescribing
+{
+    /**
+     * Enable or disable the backup and restoration of the $GLOBALS array.
+     * Overwrite this attribute in a child class of TestCase.
+     * Setting this attribute in setUp() has no effect!
+     *
+     * @var bool
+     */
+    protected $backupGlobals;
+
+    /**
+     * @var array
+     */
+    protected $backupGlobalsBlacklist = [];
+
+    /**
+     * Enable or disable the backup and restoration of static attributes.
+     * Overwrite this attribute in a child class of TestCase.
+     * Setting this attribute in setUp() has no effect!
+     *
+     * @var bool
+     */
+    protected $backupStaticAttributes;
+
+    /**
+     * @var array
+     */
+    protected $backupStaticAttributesBlacklist = [];
+
+    /**
+     * Whether or not this test is to be run in a separate PHP process.
+     *
+     * @var bool
+     */
+    protected $runTestInSeparateProcess;
+
+    /**
+     * Whether or not this class is to be run in a separate PHP process.
+     *
+     * @var bool
+     */
+    private $runClassInSeparateProcess;
+
+    /**
+     * Whether or not this test should preserve the global state when
+     * running in a separate PHP process.
+     *
+     * @var bool
+     */
+    protected $preserveGlobalState = true;
+
+    /**
+     * Whether or not this test is running in a separate PHP process.
+     *
+     * @var bool
+     */
+    private $inIsolation = false;
+
+    /**
+     * @var array
+     */
+    private $data;
+
+    /**
+     * @var string
+     */
+    private $dataName;
+
+    /**
+     * @var bool
+     */
+    private $useErrorHandler;
+
+    /**
+     * The name of the expected Exception.
+     *
+     * @var null|string
+     */
+    private $expectedException;
+
+    /**
+     * The message of the expected Exception.
+     *
+     * @var string
+     */
+    private $expectedExceptionMessage;
+
+    /**
+     * The regex pattern to validate the expected Exception message.
+     *
+     * @var string
+     */
+    private $expectedExceptionMessageRegExp;
+
+    /**
+     * The code of the expected Exception.
+     *
+     * @var null|int|string
+     */
+    private $expectedExceptionCode;
+
+    /**
+     * The name of the test case.
+     *
+     * @var string
+     */
+    private $name;
+
+    /**
+     * @var string[]
+     */
+    private $dependencies = [];
+
+    /**
+     * @var array
+     */
+    private $dependencyInput = [];
+
+    /**
+     * @var array
+     */
+    private $iniSettings = [];
+
+    /**
+     * @var array
+     */
+    private $locale = [];
+
+    /**
+     * @var array
+     */
+    private $mockObjects = [];
+
+    /**
+     * @var MockGenerator
+     */
+    private $mockObjectGenerator;
+
+    /**
+     * @var int
+     */
+    private $status;
+
+    /**
+     * @var string
+     */
+    private $statusMessage = '';
+
+    /**
+     * @var int
+     */
+    private $numAssertions = 0;
+
+    /**
+     * @var TestResult
+     */
+    private $result;
+
+    /**
+     * @var mixed
+     */
+    private $testResult;
+
+    /**
+     * @var string
+     */
+    private $output = '';
+
+    /**
+     * @var string
+     */
+    private $outputExpectedRegex;
+
+    /**
+     * @var string
+     */
+    private $outputExpectedString;
+
+    /**
+     * @var mixed
+     */
+    private $outputCallback = false;
+
+    /**
+     * @var bool
+     */
+    private $outputBufferingActive = false;
+
+    /**
+     * @var int
+     */
+    private $outputBufferingLevel;
+
+    /**
+     * @var Snapshot
+     */
+    private $snapshot;
+
+    /**
+     * @var Prophecy\Prophet
+     */
+    private $prophet;
+
+    /**
+     * @var bool
+     */
+    private $beStrictAboutChangesToGlobalState = false;
+
+    /**
+     * @var bool
+     */
+    private $registerMockObjectsFromTestArgumentsRecursively = false;
+
+    /**
+     * @var string[]
+     */
+    private $warnings = [];
+
+    /**
+     * @var array
+     */
+    private $groups = [];
+
+    /**
+     * @var bool
+     */
+    private $doesNotPerformAssertions = false;
+
+    /**
+     * @var Comparator[]
+     */
+    private $customComparators = [];
+
+    /**
+     * Constructs a test case with the given name.
+     *
+     * @param string $name
+     * @param array  $data
+     * @param string $dataName
+     */
+    public function __construct($name = null, array $data = [], $dataName = '')
+    {
+        if ($name !== null) {
+            $this->setName($name);
+        }
+
+        $this->data     = $data;
+        $this->dataName = $dataName;
+    }
+
+    /**
+     * Returns a string representation of the test case.
+     *
+     * @return string
+     */
+    public function toString()
+    {
+        $class = new ReflectionClass($this);
+
+        $buffer = \sprintf(
+            '%s::%s',
+            $class->name,
+            $this->getName(false)
+        );
+
+        return $buffer . $this->getDataSetAsString();
+    }
+
+    /**
+     * Counts the number of test cases executed by run(TestResult result).
+     *
+     * @return int
+     */
+    public function count()
+    {
+        return 1;
+    }
+
+    public function getGroups()
+    {
+        return $this->groups;
+    }
+
+    /**
+     * @param array $groups
+     */
+    public function setGroups(array $groups)
+    {
+        $this->groups = $groups;
+    }
+
+    /**
+     * Returns the annotations for this test.
+     *
+     * @return array
+     */
+    public function getAnnotations()
+    {
+        return \PHPUnit\Util\Test::parseTestMethodAnnotations(
+            \get_class($this),
+            $this->name
+        );
+    }
+
+    /**
+     * Gets the name of a TestCase.
+     *
+     * @param bool $withDataSet
+     *
+     * @return string
+     */
+    public function getName($withDataSet = true)
+    {
+        if ($withDataSet) {
+            return $this->name . $this->getDataSetAsString(false);
+        }
+
+        return $this->name;
+    }
+
+    /**
+     * Returns the size of the test.
+     *
+     * @return int
+     */
+    public function getSize()
+    {
+        return \PHPUnit\Util\Test::getSize(
+            \get_class($this),
+            $this->getName(false)
+        );
+    }
+
+    /**
+     * @return bool
+     */
+    public function hasSize()
+    {
+        return $this->getSize() !== \PHPUnit\Util\Test::UNKNOWN;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isSmall()
+    {
+        return $this->getSize() === \PHPUnit\Util\Test::SMALL;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isMedium()
+    {
+        return $this->getSize() === \PHPUnit\Util\Test::MEDIUM;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isLarge()
+    {
+        return $this->getSize() === \PHPUnit\Util\Test::LARGE;
+    }
+
+    /**
+     * @return string
+     */
+    public function getActualOutput()
+    {
+        if (!$this->outputBufferingActive) {
+            return $this->output;
+        }
+
+        return \ob_get_contents();
+    }
+
+    /**
+     * @return bool
+     */
+    public function hasOutput()
+    {
+        if (\strlen($this->output) === 0) {
+            return false;
+        }
+
+        if ($this->hasExpectationOnOutput()) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @return bool
+     */
+    public function doesNotPerformAssertions()
+    {
+        return $this->doesNotPerformAssertions;
+    }
+
+    /**
+     * @param string $expectedRegex
+     *
+     * @throws Exception
+     */
+    public function expectOutputRegex($expectedRegex)
+    {
+        if ($this->outputExpectedString !== null) {
+            throw new Exception;
+        }
+
+        if (\is_string($expectedRegex) || null === $expectedRegex) {
+            $this->outputExpectedRegex = $expectedRegex;
+        }
+    }
+
+    /**
+     * @param string $expectedString
+     */
+    public function expectOutputString($expectedString)
+    {
+        if ($this->outputExpectedRegex !== null) {
+            throw new Exception;
+        }
+
+        if (\is_string($expectedString) || null === $expectedString) {
+            $this->outputExpectedString = $expectedString;
+        }
+    }
+
+    /**
+     * @return bool
+     */
+    public function hasExpectationOnOutput()
+    {
+        return \is_string($this->outputExpectedString) || \is_string($this->outputExpectedRegex);
+    }
+
+    /**
+     * @return null|string
+     */
+    public function getExpectedException()
+    {
+        return $this->expectedException;
+    }
+
+    /**
+     * @return null|int|string
+     */
+    public function getExpectedExceptionCode()
+    {
+        return $this->expectedExceptionCode;
+    }
+
+    /**
+     * @return string
+     */
+    public function getExpectedExceptionMessage()
+    {
+        return $this->expectedExceptionMessage;
+    }
+
+    /**
+     * @return string
+     */
+    public function getExpectedExceptionMessageRegExp()
+    {
+        return $this->expectedExceptionMessageRegExp;
+    }
+
+    /**
+     * @param string $exception
+     */
+    public function expectException($exception)
+    {
+        if (!\is_string($exception)) {
+            throw InvalidArgumentHelper::factory(1, 'string');
+        }
+
+        $this->expectedException = $exception;
+    }
+
+    /**
+     * @param int|string $code
+     *
+     * @throws Exception
+     */
+    public function expectExceptionCode($code)
+    {
+        if (!\is_int($code) && !\is_string($code)) {
+            throw InvalidArgumentHelper::factory(1, 'integer or string');
+        }
+
+        $this->expectedExceptionCode = $code;
+    }
+
+    /**
+     * @param string $message
+     *
+     * @throws Exception
+     */
+    public function expectExceptionMessage($message)
+    {
+        if (!\is_string($message)) {
+            throw InvalidArgumentHelper::factory(1, 'string');
+        }
+
+        $this->expectedExceptionMessage = $message;
+    }
+
+    /**
+     * @param string $messageRegExp
+     *
+     * @throws Exception
+     */
+    public function expectExceptionMessageRegExp($messageRegExp)
+    {
+        if (!\is_string($messageRegExp)) {
+            throw InvalidArgumentHelper::factory(1, 'string');
+        }
+
+        $this->expectedExceptionMessageRegExp = $messageRegExp;
+    }
+
+    /**
+     * Sets up an expectation for an exception to be raised by the code under test.
+     * Information for expected exception class, expected exception message, and
+     * expected exception code are retrieved from a given Exception object.
+     */
+    public function expectExceptionObject(\Exception $exception)
+    {
+        $this->expectException(\get_class($exception));
+        $this->expectExceptionMessage($exception->getMessage());
+        $this->expectExceptionCode($exception->getCode());
+    }
+
+    /**
+     * @param bool $flag
+     */
+    public function setRegisterMockObjectsFromTestArgumentsRecursively($flag)
+    {
+        if (!\is_bool($flag)) {
+            throw InvalidArgumentHelper::factory(1, 'boolean');
+        }
+
+        $this->registerMockObjectsFromTestArgumentsRecursively = $flag;
+    }
+
+    protected function setExpectedExceptionFromAnnotation()
+    {
+        try {
+            $expectedException = \PHPUnit\Util\Test::getExpectedException(
+                \get_class($this),
+                $this->name
+            );
+
+            if ($expectedException !== false) {
+                $this->expectException($expectedException['class']);
+
+                if ($expectedException['code'] !== null) {
+                    $this->expectExceptionCode($expectedException['code']);
+                }
+
+                if ($expectedException['message'] !== '') {
+                    $this->expectExceptionMessage($expectedException['message']);
+                } elseif ($expectedException['message_regex'] !== '') {
+                    $this->expectExceptionMessageRegExp($expectedException['message_regex']);
+                }
+            }
+        } catch (ReflectionException $e) {
+        }
+    }
+
+    /**
+     * @param bool $useErrorHandler
+     */
+    public function setUseErrorHandler($useErrorHandler)
+    {
+        $this->useErrorHandler = $useErrorHandler;
+    }
+
+    protected function setUseErrorHandlerFromAnnotation()
+    {
+        try {
+            $useErrorHandler = \PHPUnit\Util\Test::getErrorHandlerSettings(
+                \get_class($this),
+                $this->name
+            );
+
+            if ($useErrorHandler !== null) {
+                $this->setUseErrorHandler($useErrorHandler);
+            }
+        } catch (ReflectionException $e) {
+        }
+    }
+
+    protected function checkRequirements()
+    {
+        if (!$this->name || !\method_exists($this, $this->name)) {
+            return;
+        }
+
+        $missingRequirements = \PHPUnit\Util\Test::getMissingRequirements(
+            \get_class($this),
+            $this->name
+        );
+
+        if (!empty($missingRequirements)) {
+            $this->markTestSkipped(\implode(PHP_EOL, $missingRequirements));
+        }
+    }
+
+    /**
+     * Returns the status of this test.
+     *
+     * @return int
+     */
+    public function getStatus()
+    {
+        return $this->status;
+    }
+
+    public function markAsRisky()
+    {
+        $this->status = BaseTestRunner::STATUS_RISKY;
+    }
+
+    /**
+     * Returns the status message of this test.
+     *
+     * @return string
+     */
+    public function getStatusMessage()
+    {
+        return $this->statusMessage;
+    }
+
+    /**
+     * Returns whether or not this test has failed.
+     *
+     * @return bool
+     */
+    public function hasFailed()
+    {
+        $status = $this->getStatus();
+
+        return $status == BaseTestRunner::STATUS_FAILURE ||
+            $status == BaseTestRunner::STATUS_ERROR;
+    }
+
+    /**
+     * Runs the test case and collects the results in a TestResult object.
+     * If no TestResult object is passed a new one will be created.
+     *
+     * @param TestResult $result
+     *
+     * @return TestResult
+     *
+     * @throws Exception
+     */
+    public function run(TestResult $result = null)
+    {
+        if ($result === null) {
+            $result = $this->createResult();
+        }
+
+        if (!$this instanceof WarningTestCase) {
+            $this->setTestResultObject($result);
+            $this->setUseErrorHandlerFromAnnotation();
+        }
+
+        if ($this->useErrorHandler !== null) {
+            $oldErrorHandlerSetting = $result->getConvertErrorsToExceptions();
+            $result->convertErrorsToExceptions($this->useErrorHandler);
+        }
+
+        if (!$this instanceof WarningTestCase &&
+            !$this instanceof SkippedTestCase &&
+            !$this->handleDependencies()) {
+            return $result;
+        }
+
+        $runEntireClass =  $this->runClassInSeparateProcess && !$this->runTestInSeparateProcess;
+
+        if (($this->runTestInSeparateProcess === true || $this->runClassInSeparateProcess === true) &&
+            $this->inIsolation !== true &&
+            !$this instanceof PhptTestCase) {
+            $class = new ReflectionClass($this);
+
+            if ($runEntireClass) {
+                $template = new Text_Template(
+                    __DIR__ . '/../Util/PHP/Template/TestCaseClass.tpl'
+                );
+            } else {
+                $template = new Text_Template(
+                    __DIR__ . '/../Util/PHP/Template/TestCaseMethod.tpl'
+                );
+            }
+
+            if ($this->preserveGlobalState) {
+                $constants     = GlobalState::getConstantsAsString();
+                $globals       = GlobalState::getGlobalsAsString();
+                $includedFiles = GlobalState::getIncludedFilesAsString();
+                $iniSettings   = GlobalState::getIniSettingsAsString();
+            } else {
+                $constants = '';
+                if (!empty($GLOBALS['__PHPUNIT_BOOTSTRAP'])) {
+                    $globals = '$GLOBALS[\'__PHPUNIT_BOOTSTRAP\'] = ' . \var_export($GLOBALS['__PHPUNIT_BOOTSTRAP'], true) . ";\n";
+                } else {
+                    $globals = '';
+                }
+                $includedFiles = '';
+                $iniSettings   = '';
+            }
+
+            $coverage                                   = $result->getCollectCodeCoverageInformation() ? 'true' : 'false';
+            $isStrictAboutTestsThatDoNotTestAnything    = $result->isStrictAboutTestsThatDoNotTestAnything() ? 'true' : 'false';
+            $isStrictAboutOutputDuringTests             = $result->isStrictAboutOutputDuringTests() ? 'true' : 'false';
+            $enforcesTimeLimit                          = $result->enforcesTimeLimit() ? 'true' : 'false';
+            $isStrictAboutTodoAnnotatedTests            = $result->isStrictAboutTodoAnnotatedTests() ? 'true' : 'false';
+            $isStrictAboutResourceUsageDuringSmallTests = $result->isStrictAboutResourceUsageDuringSmallTests() ? 'true' : 'false';
+
+            if (\defined('PHPUNIT_COMPOSER_INSTALL')) {
+                $composerAutoload = \var_export(PHPUNIT_COMPOSER_INSTALL, true);
+            } else {
+                $composerAutoload = '\'\'';
+            }
+
+            if (\defined('__PHPUNIT_PHAR__')) {
+                $phar = \var_export(__PHPUNIT_PHAR__, true);
+            } else {
+                $phar = '\'\'';
+            }
+
+            if ($result->getCodeCoverage()) {
+                $codeCoverageFilter = $result->getCodeCoverage()->filter();
+            } else {
+                $codeCoverageFilter = null;
+            }
+
+            $data               = \var_export(\serialize($this->data), true);
+            $dataName           = \var_export($this->dataName, true);
+            $dependencyInput    = \var_export(\serialize($this->dependencyInput), true);
+            $includePath        = \var_export(\get_include_path(), true);
+            $codeCoverageFilter = \var_export(\serialize($codeCoverageFilter), true);
+            // must do these fixes because TestCaseMethod.tpl has unserialize('{data}') in it, and we can't break BC
+            // the lines above used to use addcslashes() rather than var_export(), which breaks null byte escape sequences
+            $data               = "'." . $data . ".'";
+            $dataName           = "'.(" . $dataName . ").'";
+            $dependencyInput    = "'." . $dependencyInput . ".'";
+            $includePath        = "'." . $includePath . ".'";
+            $codeCoverageFilter = "'." . $codeCoverageFilter . ".'";
+
+            $configurationFilePath = $GLOBALS['__PHPUNIT_CONFIGURATION_FILE'] ?? '';
+
+            $var = [
+                'composerAutoload'                           => $composerAutoload,
+                'phar'                                       => $phar,
+                'filename'                                   => $class->getFileName(),
+                'className'                                  => $class->getName(),
+                'collectCodeCoverageInformation'             => $coverage,
+                'data'                                       => $data,
+                'dataName'                                   => $dataName,
+                'dependencyInput'                            => $dependencyInput,
+                'constants'                                  => $constants,
+                'globals'                                    => $globals,
+                'include_path'                               => $includePath,
+                'included_files'                             => $includedFiles,
+                'iniSettings'                                => $iniSettings,
+                'isStrictAboutTestsThatDoNotTestAnything'    => $isStrictAboutTestsThatDoNotTestAnything,
+                'isStrictAboutOutputDuringTests'             => $isStrictAboutOutputDuringTests,
+                'enforcesTimeLimit'                          => $enforcesTimeLimit,
+                'isStrictAboutTodoAnnotatedTests'            => $isStrictAboutTodoAnnotatedTests,
+                'isStrictAboutResourceUsageDuringSmallTests' => $isStrictAboutResourceUsageDuringSmallTests,
+                'codeCoverageFilter'                         => $codeCoverageFilter,
+                'configurationFilePath'                      => $configurationFilePath,
+                'name'                                       => $this->getName(false),
+            ];
+
+            if (!$runEntireClass) {
+                $var['methodName'] = $this->name;
+            }
+
+            $template->setVar(
+                $var
+            );
+
+            $this->prepareTemplate($template);
+
+            $php = AbstractPhpProcess::factory();
+            $php->runTestJob($template->render(), $this, $result);
+        } else {
+            $result->run($this);
+        }
+
+        if (isset($oldErrorHandlerSetting)) {
+            $result->convertErrorsToExceptions($oldErrorHandlerSetting);
+        }
+
+        $this->result = null;
+
+        return $result;
+    }
+
+    /**
+     * Runs the bare test sequence.
+     */
+    public function runBare()
+    {
+        $this->numAssertions = 0;
+
+        $this->snapshotGlobalState();
+        $this->startOutputBuffering();
+        \clearstatcache();
+        $currentWorkingDirectory = \getcwd();
+
+        $hookMethods = \PHPUnit\Util\Test::getHookMethods(\get_class($this));
+
+        try {
+            $hasMetRequirements = false;
+            $this->checkRequirements();
+            $hasMetRequirements = true;
+
+            if ($this->inIsolation) {
+                foreach ($hookMethods['beforeClass'] as $method) {
+                    $this->$method();
+                }
+            }
+
+            $this->setExpectedExceptionFromAnnotation();
+            $this->setDoesNotPerformAssertionsFromAnnotation();
+
+            foreach ($hookMethods['before'] as $method) {
+                $this->$method();
+            }
+
+            $this->assertPreConditions();
+            $this->testResult = $this->runTest();
+            $this->verifyMockObjects();
+            $this->assertPostConditions();
+
+            if (!empty($this->warnings)) {
+                throw new Warning(
+                    \implode(
+                        "\n",
+                        \array_unique($this->warnings)
+                    )
+                );
+            }
+
+            $this->status = BaseTestRunner::STATUS_PASSED;
+        } catch (IncompleteTest $e) {
+            $this->status        = BaseTestRunner::STATUS_INCOMPLETE;
+            $this->statusMessage = $e->getMessage();
+        } catch (SkippedTest $e) {
+            $this->status        = BaseTestRunner::STATUS_SKIPPED;
+            $this->statusMessage = $e->getMessage();
+        } catch (Warning $e) {
+            $this->status        = BaseTestRunner::STATUS_WARNING;
+            $this->statusMessage = $e->getMessage();
+        } catch (AssertionFailedError $e) {
+            $this->status        = BaseTestRunner::STATUS_FAILURE;
+            $this->statusMessage = $e->getMessage();
+        } catch (PredictionException $e) {
+            $this->status        = BaseTestRunner::STATUS_FAILURE;
+            $this->statusMessage = $e->getMessage();
+        } catch (Throwable $_e) {
+            $e = $_e;
+        }
+
+        // Clean up the mock objects.
+        $this->mockObjects = [];
+        $this->prophet     = null;
+
+        // Tear down the fixture. An exception raised in tearDown() will be
+        // caught and passed on when no exception was raised before.
+        try {
+            if ($hasMetRequirements) {
+                foreach ($hookMethods['after'] as $method) {
+                    $this->$method();
+                }
+
+                if ($this->inIsolation) {
+                    foreach ($hookMethods['afterClass'] as $method) {
+                        $this->$method();
+                    }
+                }
+            }
+        } catch (Throwable $_e) {
+            if (!isset($e)) {
+                $e = $_e;
+            }
+        }
+
+        try {
+            $this->stopOutputBuffering();
+        } catch (RiskyTestError $_e) {
+            if (!isset($e)) {
+                $e = $_e;
+            }
+        }
+
+        if (isset($_e)) {
+            $this->status        = BaseTestRunner::STATUS_ERROR;
+            $this->statusMessage = $_e->getMessage();
+        }
+
+        \clearstatcache();
+
+        if ($currentWorkingDirectory != \getcwd()) {
+            \chdir($currentWorkingDirectory);
+        }
+
+        $this->restoreGlobalState();
+        $this->unregisterCustomComparators();
+        $this->cleanupIniSettings();
+        $this->cleanupLocaleSettings();
+
+        // Perform assertion on output.
+        if (!isset($e)) {
+            try {
+                if ($this->outputExpectedRegex !== null) {
+                    $this->assertRegExp($this->outputExpectedRegex, $this->output);
+                } elseif ($this->outputExpectedString !== null) {
+                    $this->assertEquals($this->outputExpectedString, $this->output);
+                }
+            } catch (Throwable $_e) {
+                $e = $_e;
+            }
+        }
+
+        // Workaround for missing "finally".
+        if (isset($e)) {
+            if ($e instanceof PredictionException) {
+                $e = new AssertionFailedError($e->getMessage());
+            }
+
+            $this->onNotSuccessfulTest($e);
+        }
+    }
+
+    /**
+     * Override to run the test and assert its state.
+     *
+     * @return mixed
+     *
+     * @throws Exception|Exception
+     * @throws Exception
+     */
+    protected function runTest()
+    {
+        if ($this->name === null) {
+            throw new Exception(
+                'PHPUnit\Framework\TestCase::$name must not be null.'
+            );
+        }
+
+        try {
+            $class  = new ReflectionClass($this);
+            $method = $class->getMethod($this->name);
+        } catch (ReflectionException $e) {
+            $this->fail($e->getMessage());
+        }
+
+        $testArguments = \array_merge($this->data, $this->dependencyInput);
+
+        $this->registerMockObjectsFromTestArguments($testArguments);
+
+        try {
+            $testResult = $method->invokeArgs($this, $testArguments);
+        } catch (Throwable $t) {
+            $exception = $t;
+        }
+
+        if (isset($exception)) {
+            if ($this->checkExceptionExpectations($exception)) {
+                if ($this->expectedException !== null) {
+                    $this->assertThat(
+                        $exception,
+                        new ExceptionConstraint(
+                            $this->expectedException
+                        )
+                    );
+                }
+
+                if ($this->expectedExceptionMessage !== null) {
+                    $this->assertThat(
+                        $exception,
+                        new ExceptionMessage(
+                            $this->expectedExceptionMessage
+                        )
+                    );
+                }
+
+                if ($this->expectedExceptionMessageRegExp !== null) {
+                    $this->assertThat(
+                        $exception,
+                        new ExceptionMessageRegularExpression(
+                            $this->expectedExceptionMessageRegExp
+                        )
+                    );
+                }
+
+                if ($this->expectedExceptionCode !== null) {
+                    $this->assertThat(
+                        $exception,
+                        new ExceptionCode(
+                            $this->expectedExceptionCode
+                        )
+                    );
+                }
+
+                return;
+            }
+
+            throw $exception;
+        }
+
+        if ($this->expectedException !== null) {
+            $this->assertThat(
+                null,
+                new ExceptionConstraint(
+                    $this->expectedException
+                )
+            );
+        } elseif ($this->expectedExceptionMessage !== null) {
+            $this->numAssertions++;
+
+            throw new AssertionFailedError(
+                \sprintf(
+                    'Failed asserting that exception with message "%s" is thrown',
+                    $this->expectedExceptionMessage
+                )
+            );
+        } elseif ($this->expectedExceptionMessageRegExp !== null) {
+            $this->numAssertions++;
+
+            throw new AssertionFailedError(
+                \sprintf(
+                    'Failed asserting that exception with message matching "%s" is thrown',
+                    $this->expectedExceptionMessageRegExp
+                )
+            );
+        } elseif ($this->expectedExceptionCode !== null) {
+            $this->numAssertions++;
+
+            throw new AssertionFailedError(
+                \sprintf(
+                    'Failed asserting that exception with code "%s" is thrown',
+                    $this->expectedExceptionCode
+                )
+            );
+        }
+
+        return $testResult;
+    }
+
+    /**
+     * Verifies the mock object expectations.
+     */
+    protected function verifyMockObjects()
+    {
+        foreach ($this->mockObjects as $mockObject) {
+            if ($mockObject->__phpunit_hasMatchers()) {
+                $this->numAssertions++;
+            }
+
+            $mockObject->__phpunit_verify(
+                $this->shouldInvocationMockerBeReset($mockObject)
+            );
+        }
+        xdebug_break();
+
+        if ($this->prophet !== null) {
+            try {
+                $this->prophet->checkPredictions();
+            } catch (Throwable $t) {
+                /* Intentionally left empty */
+            }
+
+            foreach ($this->prophet->getProphecies() as $objectProphecy) {
+                foreach ($objectProphecy->getMethodProphecies() as $methodProphecies) {
+                    foreach ($methodProphecies as $methodProphecy) {
+                        $this->numAssertions += \count($methodProphecy->getCheckedPredictions());
+                    }
+                }
+            }
+
+            if (isset($t)) {
+                throw $t;
+            }
+        }
+    }
+
+    /**
+     * Sets the name of a TestCase.
+     *
+     * @param  string
+     */
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+
+    /**
+     * Sets the dependencies of a TestCase.
+     *
+     * @param string[] $dependencies
+     */
+    public function setDependencies(array $dependencies)
+    {
+        $this->dependencies = $dependencies;
+    }
+
+    /**
+     * Returns true if the tests has dependencies
+     *
+     * @return bool
+     */
+    public function hasDependencies()
+    {
+        return \count($this->dependencies) > 0;
+    }
+
+    /**
+     * Sets
+     *
+     * @param array $dependencyInput
+     */
+    public function setDependencyInput(array $dependencyInput)
+    {
+        $this->dependencyInput = $dependencyInput;
+    }
+
+    /**
+     * @param bool $beStrictAboutChangesToGlobalState
+     */
+    public function setBeStrictAboutChangesToGlobalState($beStrictAboutChangesToGlobalState)
+    {
+        $this->beStrictAboutChangesToGlobalState = $beStrictAboutChangesToGlobalState;
+    }
+
+    /**
+     * Calling this method in setUp() has no effect!
+     *
+     * @param bool $backupGlobals
+     */
+    public function setBackupGlobals($backupGlobals)
+    {
+        if (null === $this->backupGlobals && \is_bool($backupGlobals)) {
+            $this->backupGlobals = $backupGlobals;
+        }
+    }
+
+    /**
+     * Calling this method in setUp() has no effect!
+     *
+     * @param bool $backupStaticAttributes
+     */
+    public function setBackupStaticAttributes($backupStaticAttributes)
+    {
+        if (null === $this->backupStaticAttributes &&
+            \is_bool($backupStaticAttributes)) {
+            $this->backupStaticAttributes = $backupStaticAttributes;
+        }
+    }
+
+    /**
+     * @param bool $runTestInSeparateProcess
+     *
+     * @throws Exception
+     */
+    public function setRunTestInSeparateProcess($runTestInSeparateProcess)
+    {
+        if (\is_bool($runTestInSeparateProcess)) {
+            if ($this->runTestInSeparateProcess === null) {
+                $this->runTestInSeparateProcess = $runTestInSeparateProcess;
+            }
+        } else {
+            throw InvalidArgumentHelper::factory(1, 'boolean');
+        }
+    }
+
+    /**
+     * @param bool $runClassInSeparateProcess
+     *
+     * @throws Exception
+     */
+    public function setRunClassInSeparateProcess($runClassInSeparateProcess)
+    {
+        if (\is_bool($runClassInSeparateProcess)) {
+            if ($this->runClassInSeparateProcess === null) {
+                $this->runClassInSeparateProcess = $runClassInSeparateProcess;
+            }
+        } else {
+            throw InvalidArgumentHelper::factory(1, 'boolean');
+        }
+    }
+
+    /**
+     * @param bool $preserveGlobalState
+     *
+     * @throws Exception
+     */
+    public function setPreserveGlobalState($preserveGlobalState)
+    {
+        if (\is_bool($preserveGlobalState)) {
+            $this->preserveGlobalState = $preserveGlobalState;
+        } else {
+            throw InvalidArgumentHelper::factory(1, 'boolean');
+        }
+    }
+
+    /**
+     * @param bool $inIsolation
+     *
+     * @throws Exception
+     */
+    public function setInIsolation($inIsolation)
+    {
+        if (\is_bool($inIsolation)) {
+            $this->inIsolation = $inIsolation;
+        } else {
+            throw InvalidArgumentHelper::factory(1, 'boolean');
+        }
+    }
+
+    /**
+     * @return bool
+     */
+    public function isInIsolation()
+    {
+        return $this->inIsolation;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getResult()
+    {
+        return $this->testResult;
+    }
+
+    /**
+     * @param mixed $result
+     */
+    public function setResult($result)
+    {
+        $this->testResult = $result;
+    }
+
+    /**
+     * @param callable $callback
+     *
+     * @throws Exception
+     */
+    public function setOutputCallback($callback)
+    {
+        if (!\is_callable($callback)) {
+            throw InvalidArgumentHelper::factory(1, 'callback');
+        }
+
+        $this->outputCallback = $callback;
+    }
+
+    /**
+     * @return TestResult
+     */
+    public function getTestResultObject()
+    {
+        return $this->result;
+    }
+
+    /**
+     * @param TestResult $result
+     */
+    public function setTestResultObject(TestResult $result)
+    {
+        $this->result = $result;
+    }
+
+    /**
+     * @param MockObject $mockObject
+     */
+    public function registerMockObject(MockObject $mockObject)
+    {
+        $this->mockObjects[] = $mockObject;
+    }
+
+    /**
+     * This method is a wrapper for the ini_set() function that automatically
+     * resets the modified php.ini setting to its original value after the
+     * test is run.
+     *
+     * @param string $varName
+     * @param string $newValue
+     *
+     * @throws Exception
+     */
+    protected function iniSet($varName, $newValue)
+    {
+        if (!\is_string($varName)) {
+            throw InvalidArgumentHelper::factory(1, 'string');
+        }
+
+        $currentValue = \ini_set($varName, $newValue);
+
+        if ($currentValue !== false) {
+            $this->iniSettings[$varName] = $currentValue;
+        } else {
+            throw new Exception(
+                \sprintf(
+                    'INI setting "%s" could not be set to "%s".',
+                    $varName,
+                    $newValue
+                )
+            );
+        }
+    }
+
+    /**
+     * This method is a wrapper for the setlocale() function that automatically
+     * resets the locale to its original value after the test is run.
+     *
+     * @param int    $category
+     * @param string $locale
+     *
+     * @throws Exception
+     */
+    protected function setLocale()
+    {
+        $args = \func_get_args();
+
+        if (\count($args) < 2) {
+            throw new Exception;
+        }
+
+        list($category, $locale) = $args;
+
+        $categories = [
+            LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME
+        ];
+
+        if (\defined('LC_MESSAGES')) {
+            $categories[] = LC_MESSAGES;
+        }
+
+        if (!\in_array($category, $categories)) {
+            throw new Exception;
+        }
+
+        if (!\is_array($locale) && !\is_string($locale)) {
+            throw new Exception;
+        }
+
+        $this->locale[$category] = \setlocale($category, 0);
+
+        $result = \call_user_func_array('setlocale', $args);
+
+        if ($result === false) {
+            throw new Exception(
+                'The locale functionality is not implemented on your platform, ' .
+                'the specified locale does not exist or the category name is ' .
+                'invalid.'
+            );
+        }
+    }
+
+    /**
+     * Returns a builder object to create mock objects using a fluent interface.
+     *
+     * @param string|string[] $className
+     *
+     * @return MockBuilder
+     */
+    public function getMockBuilder($className)
+    {
+        return new MockBuilder($this, $className);
+    }
+
+    /**
+     * Returns a test double for the specified class.
+     *
+     * @param string $originalClassName
+     *
+     * @return MockObject
+     *
+     * @throws Exception
+     */
+    protected function createMock($originalClassName)
+    {
+        return $this->getMockBuilder($originalClassName)
+                    ->disableOriginalConstructor()
+                    ->disableOriginalClone()
+                    ->disableArgumentCloning()
+                    ->disallowMockingUnknownTypes()
+                    ->getMock();
+    }
+
+    /**
+     * Returns a configured test double for the specified class.
+     *
+     * @param string $originalClassName
+     * @param array  $configuration
+     *
+     * @return MockObject
+     *
+     * @throws Exception
+     */
+    protected function createConfiguredMock($originalClassName, array $configuration)
+    {
+        $o = $this->createMock($originalClassName);
+
+        foreach ($configuration as $method => $return) {
+            $o->method($method)->willReturn($return);
+        }
+
+        return $o;
+    }
+
+    /**
+     * Returns a partial test double for the specified class.
+     *
+     * @param string   $originalClassName
+     * @param string[] $methods
+     *
+     * @return MockObject
+     *
+     * @throws Exception
+     */
+    protected function createPartialMock($originalClassName, array $methods)
+    {
+        return $this->getMockBuilder($originalClassName)
+                    ->disableOriginalConstructor()
+                    ->disableOriginalClone()
+                    ->disableArgumentCloning()
+                    ->disallowMockingUnknownTypes()
+                    ->setMethods(empty($methods) ? null : $methods)
+                    ->getMock();
+    }
+
+    /**
+     * Returns a test proxy for the specified class.
+     *
+     * @param string $originalClassName
+     * @param array  $constructorArguments
+     *
+     * @return MockObject
+     *
+     * @throws Exception
+     */
+    protected function createTestProxy($originalClassName, array $constructorArguments = [])
+    {
+        return $this->getMockBuilder($originalClassName)
+                    ->setConstructorArgs($constructorArguments)
+                    ->enableProxyingToOriginalMethods()
+                    ->getMock();
+    }
+
+    /**
+     * Mocks the specified class and returns the name of the mocked class.
+     *
+     * @param string $originalClassName
+     * @param array  $methods
+     * @param array  $arguments
+     * @param string $mockClassName
+     * @param bool   $callOriginalConstructor
+     * @param bool   $callOriginalClone
+     * @param bool   $callAutoload
+     * @param bool   $cloneArguments
+     *
+     * @return string
+     *
+     * @throws Exception
+     */
+    protected function getMockClass($originalClassName, $methods = [], array $arguments = [], $mockClassName = '', $callOriginalConstructor = false, $callOriginalClone = true, $callAutoload = true, $cloneArguments = false)
+    {
+        $mock = $this->getMockObjectGenerator()->getMock(
+            $originalClassName,
+            $methods,
+            $arguments,
+            $mockClassName,
+            $callOriginalConstructor,
+            $callOriginalClone,
+            $callAutoload,
+            $cloneArguments
+        );
+
+        return \get_class($mock);
+    }
+
+    /**
+     * Returns a mock object for the specified abstract class with all abstract
+     * methods of the class mocked. Concrete methods are not mocked by default.
+     * To mock concrete methods, use the 7th parameter ($mockedMethods).
+     *
+     * @param string $originalClassName
+     * @param array  $arguments
+     * @param string $mockClassName
+     * @param bool   $callOriginalConstructor
+     * @param bool   $callOriginalClone
+     * @param bool   $callAutoload
+     * @param array  $mockedMethods
+     * @param bool   $cloneArguments
+     *
+     * @return MockObject
+     *
+     * @throws Exception
+     */
+    protected function getMockForAbstractClass($originalClassName, array $arguments = [], $mockClassName = '', $callOriginalConstructor = true, $callOriginalClone = true, $callAutoload = true, $mockedMethods = [], $cloneArguments = false)
+    {
+        $mockObject = $this->getMockObjectGenerator()->getMockForAbstractClass(
+            $originalClassName,
+            $arguments,
+            $mockClassName,
+            $callOriginalConstructor,
+            $callOriginalClone,
+            $callAutoload,
+            $mockedMethods,
+            $cloneArguments
+        );
+
+        $this->registerMockObject($mockObject);
+
+        return $mockObject;
+    }
+
+    /**
+     * Returns a mock object based on the given WSDL file.
+     *
+     * @param string $wsdlFile
+     * @param string $originalClassName
+     * @param string $mockClassName
+     * @param array  $methods
+     * @param bool   $callOriginalConstructor
+     * @param array  $options                 An array of options passed to SOAPClient::_construct
+     *
+     * @return MockObject
+     */
+    protected function getMockFromWsdl($wsdlFile, $originalClassName = '', $mockClassName = '', array $methods = [], $callOriginalConstructor = true, array $options = [])
+    {
+        if ($originalClassName === '') {
+            $fileName          = \pathinfo(\basename(\parse_url($wsdlFile)['path']), PATHINFO_FILENAME);
+            $originalClassName = \preg_replace('/[^a-zA-Z0-9_]/', '', $fileName);
+        }
+
+        if (!\class_exists($originalClassName)) {
+            eval(
+                $this->getMockObjectGenerator()->generateClassFromWsdl(
+                    $wsdlFile,
+                    $originalClassName,
+                    $methods,
+                    $options
+                )
+            );
+        }
+
+        $mockObject = $this->getMockObjectGenerator()->getMock(
+            $originalClassName,
+            $methods,
+            ['', $options],
+            $mockClassName,
+            $callOriginalConstructor,
+            false,
+            false
+        );
+
+        $this->registerMockObject($mockObject);
+
+        return $mockObject;
+    }
+
+    /**
+     * Returns a mock object for the specified trait with all abstract methods
+     * of the trait mocked. Concrete methods to mock can be specified with the
+     * `$mockedMethods` parameter.
+     *
+     * @param string $traitName
+     * @param array  $arguments
+     * @param string $mockClassName
+     * @param bool   $callOriginalConstructor
+     * @param bool   $callOriginalClone
+     * @param bool   $callAutoload
+     * @param array  $mockedMethods
+     * @param bool   $cloneArguments
+     *
+     * @return MockObject
+     *
+     * @throws Exception
+     */
+    protected function getMockForTrait($traitName, array $arguments = [], $mockClassName = '', $callOriginalConstructor = true, $callOriginalClone = true, $callAutoload = true, $mockedMethods = [], $cloneArguments = false)
+    {
+        $mockObject = $this->getMockObjectGenerator()->getMockForTrait(
+            $traitName,
+            $arguments,
+            $mockClassName,
+            $callOriginalConstructor,
+            $callOriginalClone,
+            $callAutoload,
+            $mockedMethods,
+            $cloneArguments
+        );
+
+        $this->registerMockObject($mockObject);
+
+        return $mockObject;
+    }
+
+    /**
+     * Returns an object for the specified trait.
+     *
+     * @param string $traitName
+     * @param array  $arguments
+     * @param string $traitClassName
+     * @param bool   $callOriginalConstructor
+     * @param bool   $callOriginalClone
+     * @param bool   $callAutoload
+     *
+     * @return object
+     *
+     * @throws Exception
+     */
+    protected function getObjectForTrait($traitName, array $arguments = [], $traitClassName = '', $callOriginalConstructor = true, $callOriginalClone = true, $callAutoload = true)
+    {
+        return $this->getMockObjectGenerator()->getObjectForTrait(
+            $traitName,
+            $arguments,
+            $traitClassName,
+            $callOriginalConstructor,
+            $callOriginalClone,
+            $callAutoload
+        );
+    }
+
+    /**
+     * @param string|null $classOrInterface
+     *
+     * @return \Prophecy\Prophecy\ObjectProphecy
+     *
+     * @throws \LogicException
+     */
+    protected function prophesize($classOrInterface = null)
+    {
+        return $this->getProphet()->prophesize($classOrInterface);
+    }
+
+    /**
+     * Adds a value to the assertion counter.
+     *
+     * @param int $count
+     */
+    public function addToAssertionCount($count)
+    {
+        $this->numAssertions += $count;
+    }
+
+    /**
+     * Returns the number of assertions performed by this test.
+     *
+     * @return int
+     */
+    public function getNumAssertions()
+    {
+        return $this->numAssertions;
+    }
+
+    /**
+     * Returns a matcher that matches when the method is executed
+     * zero or more times.
+     *
+     * @return AnyInvokedCountMatcher
+     */
+    public static function any()
+    {
+        return new AnyInvokedCountMatcher;
+    }
+
+    /**
+     * Returns a matcher that matches when the method is never executed.
+     *
+     * @return InvokedCountMatcher
+     */
+    public static function never()
+    {
+        return new InvokedCountMatcher(0);
+    }
+
+    /**
+     * Returns a matcher that matches when the method is executed
+     * at least N times.
+     *
+     * @param int $requiredInvocations
+     *
+     * @return InvokedAtLeastCountMatcher
+     */
+    public static function atLeast($requiredInvocations)
+    {
+        return new InvokedAtLeastCountMatcher(
+            $requiredInvocations
+        );
+    }
+
+    /**
+     * Returns a matcher that matches when the method is executed at least once.
+     *
+     * @return InvokedAtLeastOnceMatcher
+     */
+    public static function atLeastOnce()
+    {
+        return new InvokedAtLeastOnceMatcher;
+    }
+
+    /**
+     * Returns a matcher that matches when the method is executed exactly once.
+     *
+     * @return InvokedCountMatcher
+     */
+    public static function once()
+    {
+        return new InvokedCountMatcher(1);
+    }
+
+    /**
+     * Returns a matcher that matches when the method is executed
+     * exactly $count times.
+     *
+     * @param int $count
+     *
+     * @return InvokedCountMatcher
+     */
+    public static function exactly($count)
+    {
+        return new InvokedCountMatcher($count);
+    }
+
+    /**
+     * Returns a matcher that matches when the method is executed
+     * at most N times.
+     *
+     * @param int $allowedInvocations
+     *
+     * @return InvokedAtMostCountMatcher
+     */
+    public static function atMost($allowedInvocations)
+    {
+        return new InvokedAtMostCountMatcher($allowedInvocations);
+    }
+
+    /**
+     * Returns a matcher that matches when the method is executed
+     * at the given index.
+     *
+     * @param int $index
+     *
+     * @return InvokedAtIndexMatcher
+     */
+    public static function at($index)
+    {
+        return new InvokedAtIndexMatcher($index);
+    }
+
+    /**
+     * @param mixed $value
+     *
+     * @return ReturnStub
+     */
+    public static function returnValue($value)
+    {
+        return new ReturnStub($value);
+    }
+
+    /**
+     * @param array $valueMap
+     *
+     * @return ReturnValueMapStub
+     */
+    public static function returnValueMap(array $valueMap)
+    {
+        return new ReturnValueMapStub($valueMap);
+    }
+
+    /**
+     * @param int $argumentIndex
+     *
+     * @return ReturnArgumentStub
+     */
+    public static function returnArgument($argumentIndex)
+    {
+        return new ReturnArgumentStub($argumentIndex);
+    }
+
+    /**
+     * @param mixed $callback
+     *
+     * @return ReturnCallbackStub
+     */
+    public static function returnCallback($callback)
+    {
+        return new ReturnCallbackStub($callback);
+    }
+
+    /**
+     * Returns the current object.
+     *
+     * This method is useful when mocking a fluent interface.
+     *
+     * @return ReturnSelfStub
+     */
+    public static function returnSelf()
+    {
+        return new ReturnSelfStub;
+    }
+
+    /**
+     * @param Throwable $exception
+     *
+     * @return ExceptionStub
+     */
+    public static function throwException(Throwable $exception)
+    {
+        return new ExceptionStub($exception);
+    }
+
+    /**
+     * @param mixed $value , ...
+     *
+     * @return ConsecutiveCallsStub
+     */
+    public static function onConsecutiveCalls()
+    {
+        $args = \func_get_args();
+
+        return new ConsecutiveCallsStub($args);
+    }
+
+    /**
+     * @return bool
+     */
+    public function usesDataProvider()
+    {
+        return !empty($this->data);
+    }
+
+    /**
+     * @return string
+     */
+    public function dataDescription()
+    {
+        return \is_string($this->dataName) ? $this->dataName : '';
+    }
+
+    /**
+     * @return int|string
+     */
+    public function dataName()
+    {
+        return $this->dataName;
+    }
+
+    public function registerComparator(Comparator $comparator)
+    {
+        ComparatorFactory::getInstance()->register($comparator);
+
+        $this->customComparators[] = $comparator;
+    }
+
+    /**
+     * Gets the data set description of a TestCase.
+     *
+     * @param bool $includeData
+     *
+     * @return string
+     */
+    public function getDataSetAsString($includeData = true)
+    {
+        $buffer = '';
+
+        if (!empty($this->data)) {
+            if (\is_int($this->dataName)) {
+                $buffer .= \sprintf(' with data set #%d', $this->dataName);
+            } else {
+                $buffer .= \sprintf(' with data set "%s"', $this->dataName);
+            }
+
+            $exporter = new Exporter;
+
+            if ($includeData) {
+                $buffer .= \sprintf(' (%s)', $exporter->shortenedRecursiveExport($this->data));
+            }
+        }
+
+        return $buffer;
+    }
+
+    /**
+     * Gets the data set of a TestCase.
+     *
+     * @return array
+     */
+    protected function getProvidedData()
+    {
+        return $this->data;
+    }
+
+    /**
+     * Creates a default TestResult object.
+     *
+     * @return TestResult
+     */
+    protected function createResult()
+    {
+        return new TestResult;
+    }
+
+    protected function handleDependencies()
+    {
+        if (!empty($this->dependencies) && !$this->inIsolation) {
+            $className  = \get_class($this);
+            $passed     = $this->result->passed();
+            $passedKeys = \array_keys($passed);
+            $numKeys    = \count($passedKeys);
+
+            for ($i = 0; $i < $numKeys; $i++) {
+                $pos = \strpos($passedKeys[$i], ' with data set');
+
+                if ($pos !== false) {
+                    $passedKeys[$i] = \substr($passedKeys[$i], 0, $pos);
+                }
+            }
+
+            $passedKeys = \array_flip(\array_unique($passedKeys));
+
+            foreach ($this->dependencies as $dependency) {
+                $deepClone    = false;
+                $shallowClone = false;
+
+                if (\strpos($dependency, 'clone ') === 0) {
+                    $deepClone  = true;
+                    $dependency = \substr($dependency, \strlen('clone '));
+                } elseif (\strpos($dependency, '!clone ') === 0) {
+                    $deepClone  = false;
+                    $dependency = \substr($dependency, \strlen('!clone '));
+                }
+
+                if (\strpos($dependency, 'shallowClone ') === 0) {
+                    $shallowClone = true;
+                    $dependency   = \substr($dependency, \strlen('shallowClone '));
+                } elseif (\strpos($dependency, '!shallowClone ') === 0) {
+                    $shallowClone = false;
+                    $dependency   = \substr($dependency, \strlen('!shallowClone '));
+                }
+
+                if (\strpos($dependency, '::') === false) {
+                    $dependency = $className . '::' . $dependency;
+                }
+
+                if (!isset($passedKeys[$dependency])) {
+                    $this->result->startTest($this);
+                    $this->result->addError(
+                        $this,
+                        new SkippedTestError(
+                            \sprintf(
+                                'This test depends on "%s" to pass.',
+                                $dependency
+                            )
+                        ),
+                        0
+                    );
+                    $this->result->endTest($this, 0);
+
+                    return false;
+                }
+
+                if (isset($passed[$dependency])) {
+                    if ($passed[$dependency]['size'] != \PHPUnit\Util\Test::UNKNOWN &&
+                        $this->getSize() != \PHPUnit\Util\Test::UNKNOWN &&
+                        $passed[$dependency]['size'] > $this->getSize()) {
+                        $this->result->addError(
+                            $this,
+                            new SkippedTestError(
+                                'This test depends on a test that is larger than itself.'
+                            ),
+                            0
+                        );
+
+                        return false;
+                    }
+
+                    if ($deepClone) {
+                        $deepCopy = new DeepCopy;
+                        $deepCopy->skipUncloneable(false);
+
+                        $this->dependencyInput[$dependency] = $deepCopy->copy($passed[$dependency]['result']);
+                    } elseif ($shallowClone) {
+                        $this->dependencyInput[$dependency] = clone $passed[$dependency]['result'];
+                    } else {
+                        $this->dependencyInput[$dependency] = $passed[$dependency]['result'];
+                    }
+                } else {
+                    $this->dependencyInput[$dependency] = null;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * This method is called before the first test of this test class is run.
+     */
+    public static function setUpBeforeClass()
+    {
+    }
+
+    /**
+     * Sets up the fixture, for example, open a network connection.
+     * This method is called before a test is executed.
+     */
+    protected function setUp()
+    {
+    }
+
+    /**
+     * Performs assertions shared by all tests of a test case.
+     *
+     * This method is called before the execution of a test starts
+     * and after setUp() is called.
+     */
+    protected function assertPreConditions()
+    {
+    }
+
+    /**
+     * Performs assertions shared by all tests of a test case.
+     *
+     * This method is called after the execution of a test ends
+     * and before tearDown() is called.
+     */
+    protected function assertPostConditions()
+    {
+    }
+
+    /**
+     * Tears down the fixture, for example, close a network connection.
+     * This method is called after a test is executed.
+     */
+    protected function tearDown()
+    {
+    }
+
+    /**
+     * This method is called after the last test of this test class is run.
+     */
+    public static function tearDownAfterClass()
+    {
+    }
+
+    /**
+     * This method is called when a test method did not execute successfully.
+     *
+     * @param Throwable $t
+     *
+     * @throws Throwable
+     */
+    protected function onNotSuccessfulTest(Throwable $t)
+    {
+        throw $t;
+    }
+
+    /**
+     * Performs custom preparations on the process isolation template.
+     *
+     * @param Text_Template $template
+     */
+    protected function prepareTemplate(Text_Template $template)
+    {
+    }
+
+    /**
+     * Get the mock object generator, creating it if it doesn't exist.
+     *
+     * @return MockGenerator
+     */
+    private function getMockObjectGenerator()
+    {
+        if (null === $this->mockObjectGenerator) {
+            $this->mockObjectGenerator = new MockGenerator;
+        }
+
+        return $this->mockObjectGenerator;
+    }
+
+    private function startOutputBuffering()
+    {
+        \ob_start();
+
+        $this->outputBufferingActive = true;
+        $this->outputBufferingLevel  = \ob_get_level();
+    }
+
+    private function stopOutputBuffering()
+    {
+        if (\ob_get_level() != $this->outputBufferingLevel) {
+            while (\ob_get_level() >= $this->outputBufferingLevel) {
+                \ob_end_clean();
+            }
+
+            throw new RiskyTestError(
+                'Test code or tested code did not (only) close its own output buffers'
+            );
+        }
+
+        $output = \ob_get_contents();
+
+        if ($this->outputCallback === false) {
+            $this->output = $output;
+        } else {
+            $this->output = \call_user_func_array(
+                $this->outputCallback,
+                [$output]
+            );
+        }
+
+        \ob_end_clean();
+
+        $this->outputBufferingActive = false;
+        $this->outputBufferingLevel  = \ob_get_level();
+    }
+
+    private function snapshotGlobalState()
+    {
+        if ($this->runTestInSeparateProcess ||
+            $this->inIsolation ||
+            (!$this->backupGlobals === true && !$this->backupStaticAttributes)) {
+            return;
+        }
+
+        $this->snapshot = $this->createGlobalStateSnapshot($this->backupGlobals === true);
+    }
+
+    private function restoreGlobalState()
+    {
+        if (!$this->snapshot instanceof Snapshot) {
+            return;
+        }
+
+        if ($this->beStrictAboutChangesToGlobalState) {
+            try {
+                $this->compareGlobalStateSnapshots(
+                    $this->snapshot,
+                    $this->createGlobalStateSnapshot($this->backupGlobals === true)
+                );
+            } catch (RiskyTestError $rte) {
+                // Intentionally left empty
+            }
+        }
+
+        $restorer = new Restorer;
+
+        if ($this->backupGlobals === true) {
+            $restorer->restoreGlobalVariables($this->snapshot);
+        }
+
+        if ($this->backupStaticAttributes) {
+            $restorer->restoreStaticAttributes($this->snapshot);
+        }
+
+        $this->snapshot = null;
+
+        if (isset($rte)) {
+            throw $rte;
+        }
+    }
+
+    /**
+     * @param bool $backupGlobals
+     *
+     * @return Snapshot
+     */
+    private function createGlobalStateSnapshot($backupGlobals)
+    {
+        $blacklist = new Blacklist;
+
+        foreach ($this->backupGlobalsBlacklist as $globalVariable) {
+            $blacklist->addGlobalVariable($globalVariable);
+        }
+
+        if (!\defined('PHPUNIT_TESTSUITE')) {
+            $blacklist->addClassNamePrefix('PHPUnit');
+            $blacklist->addClassNamePrefix('File_Iterator');
+            $blacklist->addClassNamePrefix('SebastianBergmann\CodeCoverage');
+            $blacklist->addClassNamePrefix('PHP_Invoker');
+            $blacklist->addClassNamePrefix('PHP_Timer');
+            $blacklist->addClassNamePrefix('PHP_Token');
+            $blacklist->addClassNamePrefix('Symfony');
+            $blacklist->addClassNamePrefix('Text_Template');
+            $blacklist->addClassNamePrefix('Doctrine\Instantiator');
+            $blacklist->addClassNamePrefix('Prophecy');
+
+            foreach ($this->backupStaticAttributesBlacklist as $class => $attributes) {
+                foreach ($attributes as $attribute) {
+                    $blacklist->addStaticAttribute($class, $attribute);
+                }
+            }
+        }
+
+        return new Snapshot(
+            $blacklist,
+            $backupGlobals,
+            (bool) $this->backupStaticAttributes,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false
+        );
+    }
+
+    /**
+     * @param Snapshot $before
+     * @param Snapshot $after
+     *
+     * @throws RiskyTestError
+     */
+    private function compareGlobalStateSnapshots(Snapshot $before, Snapshot $after)
+    {
+        $backupGlobals = $this->backupGlobals === null || $this->backupGlobals === true;
+
+        if ($backupGlobals) {
+            $this->compareGlobalStateSnapshotPart(
+                $before->globalVariables(),
+                $after->globalVariables(),
+                "--- Global variables before the test\n+++ Global variables after the test\n"
+            );
+
+            $this->compareGlobalStateSnapshotPart(
+                $before->superGlobalVariables(),
+                $after->superGlobalVariables(),
+                "--- Super-global variables before the test\n+++ Super-global variables after the test\n"
+            );
+        }
+
+        if ($this->backupStaticAttributes) {
+            $this->compareGlobalStateSnapshotPart(
+                $before->staticAttributes(),
+                $after->staticAttributes(),
+                "--- Static attributes before the test\n+++ Static attributes after the test\n"
+            );
+        }
+    }
+
+    /**
+     * @param array  $before
+     * @param array  $after
+     * @param string $header
+     *
+     * @throws RiskyTestError
+     */
+    private function compareGlobalStateSnapshotPart(array $before, array $after, $header)
+    {
+        if ($before != $after) {
+            $differ   = new Differ($header);
+            $exporter = new Exporter;
+
+            $diff = $differ->diff(
+                $exporter->export($before),
+                $exporter->export($after)
+            );
+
+            throw new RiskyTestError(
+                $diff
+            );
+        }
+    }
+
+    /**
+     * @return Prophecy\Prophet
+     */
+    private function getProphet()
+    {
+        if ($this->prophet === null) {
+            $this->prophet = new Prophet;
+        }
+
+        return $this->prophet;
+    }
+
+    /**
+     * @param MockObject $mock
+     *
+     * @return bool
+     */
+    private function shouldInvocationMockerBeReset(MockObject $mock)
+    {
+        $enumerator = new Enumerator;
+
+        foreach ($enumerator->enumerate($this->dependencyInput) as $object) {
+            if ($mock === $object) {
+                return false;
+            }
+        }
+
+        if (!\is_array($this->testResult) && !\is_object($this->testResult)) {
+            return true;
+        }
+
+        foreach ($enumerator->enumerate($this->testResult) as $object) {
+            if ($mock === $object) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param array $testArguments
+     * @param array $visited
+     */
+    private function registerMockObjectsFromTestArguments(array $testArguments, array &$visited = [])
+    {
+        if ($this->registerMockObjectsFromTestArgumentsRecursively) {
+            $enumerator = new Enumerator;
+
+            foreach ($enumerator->enumerate($testArguments) as $object) {
+                if ($object instanceof MockObject) {
+                    $this->registerMockObject($object);
+                }
+            }
+        } else {
+            foreach ($testArguments as $testArgument) {
+                if ($testArgument instanceof MockObject) {
+                    if ($this->isCloneable($testArgument)) {
+                        $testArgument = clone $testArgument;
+                    }
+
+                    $this->registerMockObject($testArgument);
+                } elseif (\is_array($testArgument) && !\in_array($testArgument, $visited, true)) {
+                    $visited[] = $testArgument;
+
+                    $this->registerMockObjectsFromTestArguments(
+                        $testArgument,
+                        $visited
+                    );
+                }
+            }
+        }
+    }
+
+    private function setDoesNotPerformAssertionsFromAnnotation()
+    {
+        $annotations = $this->getAnnotations();
+
+        if (isset($annotations['method']['doesNotPerformAssertions'])) {
+            $this->doesNotPerformAssertions = true;
+        }
+    }
+
+    /**
+     * @param MockObject $testArgument
+     *
+     * @return bool
+     */
+    private function isCloneable(MockObject $testArgument)
+    {
+        $reflector = new ReflectionObject($testArgument);
+
+        if (!$reflector->isCloneable()) {
+            return false;
+        }
+
+        if ($reflector->hasMethod('__clone') &&
+            $reflector->getMethod('__clone')->isPublic()) {
+            return true;
+        }
+
+        return false;
+    }
+
+    private function unregisterCustomComparators()
+    {
+        $factory = ComparatorFactory::getInstance();
+
+        foreach ($this->customComparators as $comparator) {
+            $factory->unregister($comparator);
+        }
+
+        $this->customComparators = [];
+    }
+
+    private function cleanupIniSettings()
+    {
+        foreach ($this->iniSettings as $varName => $oldValue) {
+            \ini_set($varName, $oldValue);
+        }
+
+        $this->iniSettings = [];
+    }
+
+    private function cleanupLocaleSettings()
+    {
+        foreach ($this->locale as $category => $locale) {
+            \setlocale($category, $locale);
+        }
+
+        $this->locale = [];
+    }
+
+    private function checkExceptionExpectations(Throwable $throwable): bool
+    {
+        $result = false;
+
+        if ($this->expectedException !== null || $this->expectedExceptionCode !== null || $this->expectedExceptionMessage !== null || $this->expectedExceptionMessageRegExp !== null) {
+            $result = true;
+        }
+
+        if ($throwable instanceof Exception) {
+            $result = false;
+        }
+
+        if (\is_string($this->expectedException)) {
+            $reflector = new ReflectionClass($this->expectedException);
+
+            if ($this->expectedException === 'PHPUnit\Framework\Exception' ||
+                $this->expectedException === '\PHPUnit\Framework\Exception' ||
+                $reflector->isSubclassOf('PHPUnit\Framework\Exception')) {
+                $result = true;
+            }
+        }
+
+        return $result;
+    }
+}
diff --git a/php/test.php b/php/test.php
index 467b777..7e6e9f4 100644
--- a/php/test.php
+++ b/php/test.php
@@ -21,8 +21,11 @@
 
 (new Foo(true, "foo"))->method3();
 call_function("hello");
-
-
+for ($i = 0; $i < 100; $i++) {
+    fwrite(STDOUT, $i . ": Hello World!".PHP_EOL);
+    fwrite(STDERR, $i . ': Goodbye Cruiel World!'.PHP_EOL);
+}
+echo "Bar";
 
 function call_function(string $hello) {
     $var = 123;
diff --git a/src/app.rs b/src/app.rs
index fd88ad7..39603cb 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,6 +1,7 @@
 use crate::analyzer::Analyser;
 use crate::analyzer::Analysis;
 use crate::analyzer::VariableRef;
+use crate::channel::Channels;
 use crate::config::Config;
 use crate::dbgp::client::ContextGetResponse;
 use crate::dbgp::client::ContinuationResponse;
@@ -10,8 +11,11 @@ use crate::dbgp::client::EvalResponse;
 use crate::dbgp::client::Property;
 use crate::event::input::AppEvent;
 use crate::notification::Notification;
+use crate::php_process;
+use crate::php_process::ProcessEvent;
 use crate::theme::Scheme;
 use crate::theme::Theme;
+use crate::view::eval::draw_properties;
 use crate::view::eval::EvalDialog;
 use crate::view::help::HelpView;
 use crate::view::layout::LayoutView;
@@ -34,6 +38,7 @@ use ratatui::widgets::Block;
 use ratatui::widgets::Padding;
 use ratatui::widgets::Paragraph;
 use ratatui::Terminal;
+use tokio::sync::mpsc;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::io;
@@ -128,6 +133,7 @@ impl HistoryEntry {
         match entry {
             Some(e) => e.source.clone(),
             None => SourceContext::default(),
+
         }
     }
 
@@ -234,6 +240,7 @@ pub struct App {
     quit: bool,
     sender: Sender<AppEvent>,
 
+    pub channels: Channels,
     pub listening_status: ListenStatus,
     pub notification: Notification,
     pub config: Config,
@@ -262,11 +269,14 @@ pub struct App {
     pub analyzed_files: AnalyzedFiles,
 
     pub stack_max_context_fetch: u16,
+    php_tx: Sender<ProcessEvent>,
 }
 
 impl App {
     pub fn new(config: Config, receiver: Receiver<AppEvent>, sender: Sender<AppEvent>) -> App {
         let client = Arc::new(Mutex::new(DbgpClient::new(None)));
+        let (php_tx, php_rx) = mpsc::channel::<ProcessEvent>(1024);
+        php_process::process_manager_start(php_rx, sender.clone());
         App {
             tick: 0,
             listening_status: ListenStatus::Listening,
@@ -275,11 +285,13 @@ impl App {
             notification: Notification::none(),
             receiver,
             sender: sender.clone(),
+            php_tx,
             quit: false,
             history: History::default(),
             document_variables: DocumentVariables::default(),
             client: Arc::clone(&client),
             workspace: Workspace::new(Arc::clone(&client)),
+            channels: Channels::new(),
 
             counter: 0,
             context_depth: 4,
@@ -306,7 +318,7 @@ impl App {
     ) -> Result<()> {
         let sender = self.sender.clone();
         let config = self.config.clone();
-
+        
         // spawn connection listener co-routine
         task::spawn(async move {
             let listener = match TcpListener::bind(config.listen.clone()).await {
@@ -323,6 +335,8 @@ impl App {
                 }
             };
 
+            sender.send(AppEvent::Listening).await.unwrap();
+
             loop {
                 match listener.accept().await {
                     Ok(s) => match sender.send(AppEvent::ClientConnected(s.0)).await {
@@ -355,9 +369,11 @@ impl App {
                 return Ok(());
             }
 
+            self.channels.unload(self.history.offset).await;
+
             terminal.autoresize()?;
             terminal.draw(|frame| {
-                LayoutView::draw(self, frame, frame.area());
+                LayoutView::draw(self, frame, frame.area(), frame.area());
             })?;
         }
     }
@@ -376,6 +392,11 @@ impl App {
         match event {
             AppEvent::Tick => (),
             AppEvent::Quit => self.quit = true,
+            AppEvent::Listening => {
+                if let Some(script) = &self.config.cmd {
+                    self.php_tx.send(ProcessEvent::Start(script.to_vec())).await?;
+                }
+            },
             AppEvent::ChangeView(view) => {
                 self.view_current = view;
             }
@@ -426,6 +447,7 @@ impl App {
                 }
             }
             AppEvent::Listen => {
+                self.channels.reset();
                 self.listening_status = ListenStatus::Listening;
                 self.view_current = SelectedView::Listen;
                 self.session_view.mode = SessionViewMode::Current;
@@ -533,6 +555,10 @@ impl App {
             AppEvent::Disconnect => {
                 let _ = self.client.lock().await.deref_mut().disonnect().await;
                 self.listening_status = ListenStatus::Refusing;
+
+                // capture any remaining stdout/stderr
+                self.channels.savepoint(self.history.offset).await;
+                self.focus_current_channel();
                 self.sender
                     .send(AppEvent::ChangeSessionViewMode(SessionViewMode::History))
                     .await?;
@@ -546,6 +572,26 @@ impl App {
                     self.active_dialog = Some(ActiveDialog::Eval);
                 }
             }
+            AppEvent::NextChannel => {
+                self.session_view.eval_state.channel = (self.session_view.eval_state.channel + 1) % self.channels.count();
+                self.focus_current_channel();
+            },
+            AppEvent::NotifyError(message) => {
+                self.notification = Notification::error(message);
+            },
+            AppEvent::ChannelLog(channel, chunk) => {
+                let buffer = self.channels.get_mut(channel.as_str()).buffer.clone();
+                buffer.lock().await.push_str(&chunk);
+                self.focus_channel(channel);
+            },
+            AppEvent::RestartProcess => {
+                self.sender.send(AppEvent::Disconnect).await?;
+                self.sender.send(AppEvent::Listen).await?;
+                self.php_tx.send(ProcessEvent::Stop).await?;
+                if let Some(cmd) = self.config.clone().cmd {
+                    self.php_tx.send(ProcessEvent::Start(cmd)).await?;
+                };
+            },
             AppEvent::EvalCancel => {
                 self.active_dialog = None;
             }
@@ -563,8 +609,24 @@ impl App {
                         )
                         .await?;
 
-                    self.session_view.eval_state.response = Some(response);
+                    let mut lines: Vec<String> = Vec::new();
+                    match response.error {
+                        Some(e) => {
+                            self.channels.get_mut("eval").writeln(
+                                format!("[{}] {}", e.code, e.message),
+                            ).await;
+                        },
+                        None => {
+                            draw_properties(
+                                response.properties.defined_properties(),
+                                &mut lines,
+                                0
+                            );
+                            self.channels.get_mut("eval").writeln(lines.join("\n")).await;
+                        }
+                    };
                     self.sender.send(AppEvent::Snapshot()).await.unwrap();
+                    self.focus_channel("eval".to_string());
                 }
                 self.active_dialog = None;
             }
@@ -696,23 +758,23 @@ impl App {
 
     /// capture the current status and push it onto the history stack
     pub async fn snapshot(&mut self) -> Result<()> {
-        let stack = { self.client.lock().await.deref_mut().get_stack().await? };
         let mut entry = HistoryEntry::new();
+
+        // for each stack frame fetch the context and analyse the source code
+        let stack = { self.client.lock().await.deref_mut().get_stack().await? };
         for (level, frame) in stack.entries.iter().enumerate() {
             let filename = &frame.filename;
             let line_no = frame.line;
-            let context = {
-                match (level as u16) < self.stack_max_context_fetch {
-                    true => Some(
-                        self.client
-                            .lock()
-                            .await
-                            .deref_mut()
-                            .context_get(level as u16)
-                            .await?,
-                    ),
-                    false => None,
-                }
+            let context = match (level as u16) < self.stack_max_context_fetch {
+                true => Some(
+                    self.client
+                        .lock()
+                        .await
+                        .deref_mut()
+                        .context_get(level as u16)
+                        .await?,
+                ),
+                false => None,
             };
 
             let document = self.workspace.open(filename.to_string()).await;
@@ -731,15 +793,14 @@ impl App {
             };
 
             let analysis = self.analyzed_files.get(&filename.clone());
-
             let stack = StackFrame {
                 level: (level as u16),
                 source,
                 context,
             };
 
+            // populate inline variables with values
             {
-                // populate inline variables with values
                 let mut vars = vec![];
                 if let Some(analysis) = analysis {
                     for (_, var) in analysis.row((line_no as usize).saturating_sub(1)) {
@@ -756,29 +817,9 @@ impl App {
             entry.push(stack);
         }
 
-        // *xdebug* only evalutes expressions on the current stack frame
-        let eval = if !self.session_view.eval_state.input.to_string().is_empty() {
-            let response = self
-                .client
-                .lock()
-                .await
-                .eval(
-                    self.session_view.eval_state.input.to_string(),
-                    self.session_view.stack_depth(),
-                )
-                .await?;
-
-                Some(EvalEntry{
-                    expr: self.session_view.eval_state.input.to_string(),
-                    response
-                })
-        } else {
-            None
-        };
-
-        entry.eval = eval;
         self.session_view.reset();
         self.history.push(entry);
+        self.channels.savepoint(self.history.offset).await;
         self.recenter();
         Ok(())
     }
@@ -811,6 +852,7 @@ impl App {
         self.session_view.mode = SessionViewMode::Current;
         self.analyzed_files = HashMap::new();
         self.workspace.reset();
+        self.channels.reset();
     }
 
     fn recenter(&mut self) {
@@ -819,6 +861,15 @@ impl App {
             self.session_view
                 .scroll_to_line(entry.source(self.session_view.stack_depth()).line_no)
         }
+        self.focus_current_channel();
+    }
+
+    fn focus_current_channel(&mut self) {
+        if let Some(c) = self.channels.channel_by_offset(self.session_view.eval_state.channel) { self.focus_channel(c.name.clone()) }
+    }
+
+    fn focus_channel(&mut self, channel: String) {
+        self.session_view.eval_state.focus(&self.channels, channel);
     }
 }
 
diff --git a/src/channel.rs b/src/channel.rs
new file mode 100644
index 0000000..9357ae9
--- /dev/null
+++ b/src/channel.rs
@@ -0,0 +1,226 @@
+use std::{collections::{hash_map::Entry, HashMap}, sync::Arc};
+use tokio::sync::Mutex;
+
+pub struct Channels {
+    channels: HashMap<String,Channel>,
+    channel_by_offset: Vec<String>,
+}
+
+impl Default for Channels {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Channels {
+    pub fn names(&self) -> Vec<&str>
+    {
+        self.channel_by_offset.iter().map(|s|s.as_str()).collect()
+    }
+
+    pub fn get(&self, name: &str) -> Option<&Channel> {
+        self.channels.get(name)
+    }
+
+    pub fn get_mut(&mut self, name: &str) -> &Channel {
+        self.channels.entry(name.to_string()).or_insert_with(|| {
+            self.channel_by_offset.push(name.to_string());
+            Channel::new(name.to_string())
+        })
+    }
+
+    pub async fn unload(&mut self, savepoint: usize) {
+        for channel in self.channels.iter_mut() {
+            channel.1.unload(savepoint).await
+        }
+    }
+
+    pub fn new() -> Self {
+        Self{
+            channels: HashMap::new(),
+            channel_by_offset: Vec::new(),
+        }
+    }
+
+    pub(crate) fn count(&self) -> usize {
+        self.channels.keys().len()
+    }
+
+    pub(crate) fn channel_by_offset(&self, channel: usize) -> Option<&Channel> {
+        match self.channel_by_offset.get(channel) {
+            Some(name) => self.channels.get(name),
+            None => None,
+        }
+    }
+
+    pub(crate) fn offset_by_name(&self, name: String) -> Option<usize> {
+        self.channel_by_offset.iter().position(|n|*n==name)
+    }
+
+    pub(crate) async fn savepoint(&mut self, savepoint: usize) {
+        for channel in self.channels.values_mut() {
+            channel.savepoint(savepoint).await;
+        }
+    }
+
+    pub(crate) fn reset(&mut self) {
+        self.channels = HashMap::new();
+        self.channel_by_offset = Vec::new();
+    }
+}
+
+pub struct Channel {
+    pub name: String,
+    pub buffer: Arc<Mutex<String>>,
+    pub lines: Vec<String>,
+    pub savepoints: HashMap<usize,usize>,
+}
+
+impl Channel {
+    pub async fn savepoint(&mut self, savepoint: usize) {
+        self.savepoints.insert(savepoint, self.buffer.lock().await.len());
+    }
+
+    // unload the current buffer into a variable that is readable without a mutex lock.
+    // TODO: this happens on each tick and could be more performant
+    pub async fn unload(&mut self, savepoint: usize) {
+        let content  = self.buffer.lock().await.clone();
+
+        self.lines = match self.savepoints.entry(savepoint) {
+            // if there is a savepoint return the content buffer up until that
+            // savepoint
+            Entry::Occupied(occupied_entry) => {
+                let offset = occupied_entry.get();
+                content[0..*offset].lines().map(|s|s.to_string()).collect()
+            }
+            Entry::Vacant(_) => {
+                vec![]
+            }
+        };
+    }
+
+    pub fn new(name: String) -> Self {
+        Self {
+            name,
+            buffer: Arc::new(Mutex::new(String::new())),
+            lines: vec![],
+            savepoints: HashMap::new(),
+        }
+    }
+
+    pub(crate) async fn write(&self, join: String) {
+        self.buffer.lock().await.push_str(join.as_str());
+    }
+
+    pub(crate) async fn writeln(&self, join: String) {
+        self.write(join).await;
+        self.buffer.lock().await.push('\n');
+    }
+
+    pub(crate) fn viewport(&self, height: u16, scroll: u16) -> &[String] {
+        let y1 = scroll.min(self.lines.len() as u16);
+        let y2 = (scroll + height).min(self.lines.len() as u16);
+
+        &self.lines[
+            (y1 as usize)..(y2 as usize)
+        ]
+    }
+}
+
+impl Default for Channel {
+    fn default() -> Self {
+        Self::new("default".to_string())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    pub async fn test_channel_lines() {
+        let mut channel = Channel::new("test".to_string());
+        channel.write("foobar".to_string()).await;
+        channel.write("\nbarfoo\nbaz\none\ntwo".to_string()).await;
+        channel.write("baf\nbaz\n".to_string()).await;
+        
+        assert_eq!(0, channel.lines.len());
+        channel.savepoint(0).await;
+        channel.unload(0).await;
+
+        assert_eq!(6, channel.lines.len());
+    }
+
+    #[tokio::test]
+    pub async fn test_savepoint() {
+        let mut channel = Channel::new("test".to_string());
+        channel.write("foobar\nbar".to_string()).await;
+        channel.savepoint(0).await;
+        channel.write("\nbarfoo\nbaz\none\ntwo".to_string()).await;
+        channel.savepoint(1).await;
+        channel.write("baf\nbaz\n".to_string()).await;
+        
+        assert_eq!(0, channel.lines.len());
+        channel.savepoint(1).await;
+        channel.unload(1).await;
+        assert_eq!(7, channel.lines.len());
+        channel.unload(0).await;
+        assert_eq!(2, channel.lines.len());
+    }
+
+    #[tokio::test]
+    pub async fn test_channel_lines_with_unterminated_previous() {
+        let mut channel = Channel::default();
+        channel.write("foobar".to_string()).await;
+        channel.savepoint(0).await;
+        channel.unload(0).await;
+        assert_eq!(1, channel.lines.len());
+        channel.write("barfoo".to_string()).await;
+        channel.savepoint(0).await;
+        channel.unload(0).await;
+        assert_eq!(1, channel.lines.len());
+        channel.write("barfoo\n".to_string()).await;
+        channel.savepoint(0).await;
+        channel.unload(0).await;
+        assert_eq!(1, channel.lines.len());
+    }
+
+    #[tokio::test]
+    pub async fn test_channel_lines_with_nothing() {
+        let mut channel = Channel::default();
+        channel.unload(100).await;
+        
+        assert_eq!(0, channel.lines.len());
+        channel.write("".to_string()).await;
+        channel.unload(100).await;
+        assert_eq!(0, channel.lines.len());
+    }
+
+    #[test]
+    pub fn test_viewport() {
+        let mut channel = Channel::default();
+        channel.lines.push("one".to_string());
+        channel.lines.push("two".to_string());
+        channel.lines.push("three".to_string());
+        channel.lines.push("four".to_string());
+        channel.lines.push("five".to_string());
+
+        assert_eq!(vec![
+            "one",
+            "two",
+        ], channel.viewport(2, 0));
+
+        assert_eq!(vec![
+            "two",
+            "three",
+        ], channel.viewport(2, 1));
+
+        assert_eq!(vec![
+            "five",
+        ], channel.viewport(2, 4));
+
+        assert_eq!(Vec::<String>::new(), channel.viewport(2, 5));
+        assert_eq!(Vec::<String>::new(), channel.viewport(2, 6));
+
+    }
+}
diff --git a/src/config.rs b/src/config.rs
index aa0f32d..40f5d42 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -3,6 +3,8 @@ use clap::Parser;
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
 struct Args {
+    #[arg(last = true)]
+    pub php_script: Option<Vec<String>>,
     #[arg(short, long)]
     pub listen: Option<String>,
     #[arg(long)]
@@ -14,6 +16,7 @@ pub fn load_config() -> Config {
     Config {
         listen: args.listen.unwrap_or("0.0.0.0:9003".to_string()),
         log_path: args.log,
+        cmd: args.php_script,
     }
 }
 
@@ -21,6 +24,7 @@ pub fn load_config() -> Config {
 pub struct Config {
     pub listen: String,
     pub log_path: Option<String>,
+    pub cmd: Option<Vec<String>>,
 }
 
 impl Default for Config {
@@ -31,7 +35,7 @@ impl Default for Config {
 
 impl Config {
     pub fn new(listen: String) -> Config {
-        Config { listen , log_path: None}
+        Config { listen , log_path: None, cmd: None}
     }
 }
 
diff --git a/src/event/input.rs b/src/event/input.rs
index 5dbe4be..2b6b983 100644
--- a/src/event/input.rs
+++ b/src/event/input.rs
@@ -1,15 +1,16 @@
-use crossterm::event::poll;
 use crossterm::event::Event;
+use crossterm::event::EventStream;
 use crossterm::event::KeyCode;
 use crossterm::event::KeyEvent;
 use crossterm::event::KeyModifiers;
-use crossterm::event::{
-    self,
-};
-use std::thread;
+use futures::FutureExt;
+use futures::StreamExt;
+use log::info;
 use std::time::Duration;
 use tokio::net::TcpStream;
+use tokio::select;
 use tokio::sync::mpsc::Sender;
+use tokio::task;
 
 use crate::app::SelectedView;
 use crate::dbgp::client::ContinuationStatus;
@@ -55,32 +56,54 @@ pub enum AppEvent {
     EvalExecute,
     EvalRefresh,
     EvalStart,
+    Listening,
+    NextChannel,
+    FocusChannel(String),
+    ChannelLog(String, String),
+    RestartProcess,
+    NotifyError(String),
 }
 
 pub type EventSender = Sender<AppEvent>;
 
 pub fn start(event_sender: EventSender) {
-    thread::spawn(move || {
-        event_sender.blocking_send(AppEvent::Startup).unwrap();
+    let sender = event_sender.clone();
+    task::spawn(async move {
+        sender.send(AppEvent::Startup).await.unwrap();
+        let mut reader = EventStream::new();
+        let mut tick_interval = tokio::time::interval(Duration::from_millis(1000));
         loop {
-            if poll(Duration::from_millis(1000)).unwrap() {
-                // handle global keys
-                if let Event::Key(key) = event::read().unwrap() {
-                    let action: Option<AppEvent> = match key.modifiers {
-                        KeyModifiers::CONTROL => match key.code {
-                            KeyCode::Char('c') => Some(AppEvent::Quit),
-                            _ => None,
-                        },
-                        _ => None,
-                    };
+            let tick = tick_interval.tick().fuse();
+            let event = reader.next().fuse();
+
+            select! {
+                _ = tick => {
+                    sender.send(AppEvent::Tick).await.unwrap();
+                },
+                maybe_event = event => {
+                    match maybe_event {
+                        Some(Ok(Event::Key(key))) => {
+                            info!("{:?}", key);
+                            let action: Option<AppEvent> = match key.modifiers {
+                                KeyModifiers::CONTROL => match key.code {
+                                    KeyCode::Char('c') => Some(AppEvent::Quit),
+                                    _ => None,
+                                },
+                                _ => None,
+                            };
 
-                    match action {
-                        Some(a) => event_sender.blocking_send(a).unwrap(),
-                        None => event_sender.blocking_send(AppEvent::Input(key)).unwrap(),
+                            match action {
+                                Some(a) => event_sender.send(a).await.unwrap(),
+                                None => event_sender.send(AppEvent::Input(key)).await.unwrap(),
+                            }
+                        }
+                        Some(Err(e)) => {
+                            event_sender.send(AppEvent::NotifyError(e.to_string())).await.unwrap()
+                        },
+                        _ => {},
                     }
                 }
             }
-            event_sender.blocking_send(AppEvent::Tick).unwrap();
         }
     });
 }
diff --git a/src/main.rs b/src/main.rs
index 1145a6a..a251197 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,6 +7,8 @@ pub mod view;
 pub mod analyzer;
 pub mod theme;
 pub mod workspace;
+pub mod channel;
+pub mod php_process;
 
 use app::App;
 use better_panic::Settings;
diff --git a/src/php_process.rs b/src/php_process.rs
new file mode 100644
index 0000000..15ff645
--- /dev/null
+++ b/src/php_process.rs
@@ -0,0 +1,148 @@
+use std::{process::Stdio, str::from_utf8};
+use tokio::io::AsyncReadExt;
+
+use tokio::process::{ChildStderr, ChildStdout};
+use tokio::select;
+use tokio::sync::mpsc::Receiver;
+use tokio::{io::BufReader, process::Command, sync::mpsc::Sender, task};
+
+use crate::event::input::AppEvent;
+
+#[derive(Debug)]
+pub enum ProcessEvent {
+    Start(Vec<String>),
+    Stop,
+}
+
+pub fn process_manager_start(receiver: Receiver<ProcessEvent>, parent_sender: Sender<AppEvent>) {
+    task::spawn(async move {
+        match process_manager_loop(receiver, parent_sender.clone()).await {
+            Ok(_) => (),
+            Err(e) => {
+                parent_sender
+                    .send(AppEvent::ChannelLog("notice".to_string(), e.to_string()))
+                    .await
+                    .unwrap_or_default();
+            }
+        };
+    });
+}
+
+async fn process_manager_loop(
+    mut receiver: Receiver<ProcessEvent>,
+    parent_sender: Sender<AppEvent>,
+) -> Result<(), anyhow::Error> {
+    loop {
+        let cmd = receiver.recv().await;
+
+        let event = match cmd {
+            Some(event) => event,
+            None => continue,
+        };
+
+        let args = match event {
+            ProcessEvent::Start(args) => args,
+            ProcessEvent::Stop => continue,
+        };
+
+        let program = match args.first() {
+            Some(arg) => arg,
+            None => continue,
+        };
+
+        // start the PHP process - detatching stdin for now but capturing stdout/stderr
+        let mut process = Command::new(program)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .stdin(Stdio::null())
+            .args(&args[1..])
+            .spawn()?;
+
+
+        let sender = parent_sender.clone();
+
+        let io_task = task::spawn(io_loop(
+            process.stdout.take().unwrap(),
+            process.stderr.take().unwrap(),
+            sender
+        ));
+
+        let sender = parent_sender.clone();
+
+        loop {
+            select! {
+                exit_code = process.wait() => {
+                    let exit_code = match exit_code {
+                        Ok(e) => e,
+                        // if we 
+                        Err(_) => break,
+                    };
+                    if exit_code.code().unwrap_or_default() != 0 {
+                        let _ = sender.send(
+                            AppEvent::NotifyError(
+                                format!(
+                                    "Process '{:?}' exited with code {}",
+                                    args,
+                                    exit_code.code().unwrap_or_default()
+                                )
+                            )
+                        ).await;
+                    }
+                    break;
+                },
+                cmd = receiver.recv() => {
+                    let event = match cmd {
+                        Some(event) => event,
+                        None => continue,
+                    };
+                    match event {
+                        ProcessEvent::Start(_) => continue,
+                        ProcessEvent::Stop => {
+                            process.kill().await.unwrap();
+                            io_task.abort();
+                            break;
+                        },
+                    };
+                },
+            };
+        }
+    }
+}
+
+async fn io_loop(
+    stdout: ChildStdout,
+    stderr: ChildStderr,
+    sender: Sender<AppEvent>,
+) {
+
+    let mut stdoutreader = BufReader::new(stdout);
+    let mut stderrreader = BufReader::new(stderr);
+    loop {
+        let mut stdout_buff = [0; 255];
+        let mut stderr_buff = [0; 255];
+
+        select! {
+            read = stdoutreader.read(&mut stdout_buff) => {
+                if let Ok(s) = from_utf8(&stdout_buff[..read.unwrap()]) {
+                    if s.is_empty() {
+                        return;
+                    }
+                    sender
+                        .send(AppEvent::ChannelLog("stdout".to_string(), s.to_string()))
+                        .await.unwrap_or_default();
+                };
+            },
+            read = stderrreader.read(&mut stderr_buff) => {
+                if let Ok(s) = from_utf8(&stderr_buff[..read.unwrap()]) {
+                    if s.is_empty() {
+                        return;
+                    }
+                    sender
+                        .send(
+                            AppEvent::ChannelLog("stderr".to_string(), s.to_string())
+                        ).await.unwrap_or_default();
+                };
+            },
+        };
+    }
+}
diff --git a/src/view/context.rs b/src/view/context.rs
index d40a1dd..d7b446a 100644
--- a/src/view/context.rs
+++ b/src/view/context.rs
@@ -45,7 +45,7 @@ impl View for ContextComponent {
         }
     }
 
-    fn draw(app: &App, frame: &mut Frame, area: Rect) {
+    fn draw(app: &App, frame: &mut Frame, inner_area: Rect, _area: Rect) {
         let entry = match app.history.current() {
             Some(e) => e,
             None => return,
@@ -61,7 +61,7 @@ impl View for ContextComponent {
             .constraints([Constraint::Length(
                 if app.session_view.context_filter.show { 3 } else { 0 }
             ), Constraint::Min(1)]);
-        let areas = layout.split(area);
+        let areas = layout.split(inner_area);
 
         frame.render_widget(Paragraph::new(Line::from(vec![
             Span::raw(app.session_view.context_filter.input.value()).style(app.theme().text_input),
@@ -69,10 +69,10 @@ impl View for ContextComponent {
         ).block(Block::default().borders(Borders::all())), areas[0]);
 
         if app.session_view.context_filter.show {
-            let width = area.width.max(3);
+            let width = inner_area.width.max(3);
             let scroll = app.session_view.context_filter.input.visual_scroll(width as usize);
             let x = app.session_view.context_filter.input.visual_cursor().max(scroll) - scroll + 1;
-            frame.set_cursor_position((area.x + x as u16, area.y + 1));
+            frame.set_cursor_position((inner_area.x + x as u16, inner_area.y + 1));
         }
             
         let mut filter_path = app.session_view.context_filter.segments().clone();
diff --git a/src/view/eval.rs b/src/view/eval.rs
index c61e01d..3313d32 100644
--- a/src/view/eval.rs
+++ b/src/view/eval.rs
@@ -1,6 +1,13 @@
+use std::cell::Cell;
+
 use super::centered_rect_absolute;
 use super::View;
+use ansi_to_tui::IntoText;
+use ratatui::layout::Offset;
+use ratatui::widgets::Tabs;
 use crate::app::App;
+use crate::channel::Channel;
+use crate::channel::Channels;
 use crate::dbgp::client::EvalResponse;
 use crate::dbgp::client::Property;
 use crate::dbgp::client::PropertyType;
@@ -18,17 +25,28 @@ use ratatui::Frame;
 use tui_input::backend::crossterm::EventHandler;
 use tui_input::Input;
 
-pub struct EvalComponent {}
+pub struct ChannelsComponent {}
 pub struct EvalDialog {}
 
 #[derive(Default)]
 pub struct EvalState {
     pub response: Option<EvalResponse>,
+    pub eval_area: Cell<Rect>,
     pub input: Input,
+    pub channel: usize,
     pub scroll: (u16, u16),
 }
+impl EvalState {
+    pub(crate) fn focus(&mut self, channels: &Channels, name: String) {
+        self.channel = channels.offset_by_name(name).unwrap_or(0);
+        self.scroll.1 = 0;
+        let channel = channels.channel_by_offset(self.channel).expect("channel does not exist!");
+        let area = self.eval_area.get();
+        self.scroll.0 = (channel.lines.len() as i16 - area.height as i16).max(0) as u16;
+    }
+}
 
-impl View for EvalComponent {
+impl View for ChannelsComponent {
     fn handle(_app: &mut App, event: AppEvent) -> Option<AppEvent> {
         match event {
             AppEvent::Scroll(scroll) => Some(AppEvent::ScrollEval(scroll)),
@@ -36,30 +54,31 @@ impl View for EvalComponent {
         }
     }
 
-    fn draw(app: &App, frame: &mut Frame, area: Rect) {
-        if let Some(entry) = &app.history.current() {
-            if let Some(eval_entry) = &entry.eval {
-                if let Some(error) = &eval_entry.response.error {
-                    frame.render_widget(
-                        Paragraph::new(error.message.clone()).style(app.theme().notification_error),
-                        area,
-                    );
-                } else {
-                    let mut lines: Vec<Line> = Vec::new();
-                    draw_properties(
-                        &app.theme(),
-                        eval_entry.response.properties.defined_properties(),
-                        &mut lines,
-                        0,
-                        &mut Vec::new(),
-                    );
-                    frame.render_widget(
-                        Paragraph::new(lines).scroll(app.session_view.eval_state.scroll),
-                        area,
-                    );
-                }
-            }
-        }
+    fn draw(app: &App, frame: &mut Frame, inner_area: Rect, area: Rect) {
+        let tabs = Tabs::new(app.channels.names()).select(app.session_view.eval_state.channel);
+        frame.render_widget(tabs, area.offset(Offset{x: 1, y: 0}));
+        let channel = match app.channels.channel_by_offset(
+            app.session_view.eval_state.channel
+        ) {
+            Some(c) => c,
+            None => &Channel::default(),
+        };
+
+        // make the app aware of the channel area so we can
+        // scroll it correctly when its updated
+        app.session_view.eval_state.eval_area.set(inner_area);
+
+        frame.render_widget(
+            Paragraph::new(
+                channel.viewport(
+                    inner_area.height,
+                    app.session_view.eval_state.scroll.0
+                ).join("\n").as_bytes().to_text().unwrap()
+            ).scroll(
+                (0, app.session_view.eval_state.scroll.1)
+            ).style(app.theme().source_line),
+            inner_area,
+        );
     }
 }
 
@@ -83,8 +102,8 @@ impl View for EvalDialog {
         }
     }
 
-    fn draw(app: &App, frame: &mut Frame, area: Rect) {
-        let darea = centered_rect_absolute(area.width - 10, 3, area);
+    fn draw(app: &App, frame: &mut Frame, inner_area: Rect, _area: Rect) {
+        let darea = centered_rect_absolute(inner_area.width - 10, 3, inner_area);
         frame.render_widget(Clear, darea);
         frame.render_widget(
             Paragraph::new(Line::from(vec![Span::raw(
@@ -119,33 +138,21 @@ impl View for EvalDialog {
 }
 
 pub fn draw_properties(
-    theme: &Scheme,
     properties: Vec<&Property>,
-    lines: &mut Vec<Line>,
+    lines: &mut Vec<String>,
     level: usize,
-    filter_path: &mut Vec<&str>,
 ) {
-    let filter = filter_path.pop();
-
     for property in properties {
-        if let Some(filter) = filter {
-            if !property.name.starts_with(filter) {
-                continue;
-            }
-        }
         let mut spans = vec![
-            Span::raw("  ".repeat(level)),
-            Span::styled(property.name.to_string(), theme.syntax_label),
-            Span::raw(" ".to_string()),
-            Span::styled(
-                property.type_name(),
-                match property.property_type {
-                    PropertyType::Object => theme.syntax_type_object,
-                    _ => theme.syntax_type,
-                },
-            ),
-            Span::raw(" = ".to_string()),
-            render_value(theme, property),
+            "  ".repeat(level),
+            property.name.to_string(),
+            if !property.name.is_empty() { " ".to_string() } else {"".to_string()},
+            property.type_name(),
+            " = ".to_string(),
+            match &property.value {
+                Some(s) => s.to_string(),
+                None => "".to_string(),
+            }
         ];
 
         let delimiters = match property.property_type {
@@ -154,14 +161,14 @@ pub fn draw_properties(
         };
 
         if !property.children.is_empty() {
-            spans.push(Span::raw(delimiters.0).style(theme.syntax_brace));
+            spans.push(delimiters.0.to_string());
         }
 
-        lines.push(Line::from(spans));
+        lines.push(spans.join(""));
 
         if !property.children.is_empty() {
-            draw_properties(theme, property.children.defined_properties(), lines, level + 1, filter_path);
-            lines.push(Line::from(vec![Span::raw(format!("{}{}", "  ".repeat(level), delimiters.1))]).style(theme.syntax_brace));
+            draw_properties(property.children.defined_properties(), lines, level + 1);
+            lines.push(format!("{}{}", "  ".repeat(level), delimiters.1));
         }
     }
 }
@@ -185,7 +192,7 @@ pub fn render_value<'a>(theme: &Scheme, property: &Property) -> Span<'a> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{dbgp::client::Properties, theme::Theme};
+    use crate::{dbgp::client::Properties};
     use anyhow::Result;
     use pretty_assertions::assert_eq;
 
@@ -193,11 +200,9 @@ mod test {
     fn test_draw_properties_empty() -> Result<()> {
         let mut lines = vec![];
         draw_properties(
-            &Theme::SolarizedDark.scheme(),
             Vec::new(),
             &mut lines,
             0,
-            &mut Vec::new(),
         );
         assert_eq!(0, lines.len());
         Ok(())
@@ -213,14 +218,16 @@ mod test {
         prop1.name = "foo".to_string();
 
         draw_properties(
-            &Theme::SolarizedDark.scheme(),
             vec![&prop1],
             &mut lines,
             0,
-            &mut Vec::new(),
         );
         assert_eq!(
-            vec!["foo string = \"\"{", "  bar string = \"\"", "}",],
+            vec![
+                "foo string = {", 
+                "  bar string = ", 
+                "}",
+            ],
             lines
                 .iter()
                 .map(|l| { l.to_string() })
@@ -229,36 +236,4 @@ mod test {
         Ok(())
     }
 
-    #[test]
-    fn test_filter_property_multiple_level() -> Result<()> {
-        let mut lines = vec![];
-        let mut prop1 = Property::default();
-        let mut prop2 = Property::default();
-        let prop3 = Property::default();
-
-        prop2.name = "bar".to_string();
-        prop1.children = Properties::from_properties(vec![prop2]);
-        prop1.name = "foo".to_string();
-
-        // segments are reversed
-        let filter = &mut vec!["bar", "foo"];
-
-        draw_properties(
-            &Theme::SolarizedDark.scheme(),
-            vec![&prop1, &prop3],
-            &mut lines,
-            0,
-            filter,
-        );
-
-        assert_eq!(
-            vec!["foo string = \"\"{", "  bar string = \"\"", "}",],
-            lines
-                .iter()
-                .map(|l| { l.to_string() })
-                .collect::<Vec<String>>()
-        );
-
-        Ok(())
-    }
 }
diff --git a/src/view/help.rs b/src/view/help.rs
index cb35d89..004d497 100644
--- a/src/view/help.rs
+++ b/src/view/help.rs
@@ -21,9 +21,9 @@ impl View for HelpView {
         }
     }
 
-    fn draw(_app: &App, frame: &mut Frame, area: Rect) {
+    fn draw(_app: &App, frame: &mut Frame, inner_area: Rect, _area: Rect) {
 
-        frame.render_widget(Paragraph::new(help()), area);
+        frame.render_widget(Paragraph::new(help()), inner_area);
 
     }
 }
@@ -35,6 +35,7 @@ Help for you - press any key to return.
 Key mappings (prefix with number to repeat):
 
 [r]     run
+[R]     restart php script (if provided)
 [n]     next / step into
 [N]     step over
 [p]     previous (switches to history mode if in current mode)
diff --git a/src/view/layout.rs b/src/view/layout.rs
index b7c4678..f66bc0a 100644
--- a/src/view/layout.rs
+++ b/src/view/layout.rs
@@ -27,7 +27,7 @@ impl View for LayoutView {
         None
     }
 
-    fn draw(app: &App, f: &mut Frame, area: Rect) {
+    fn draw(app: &App, f: &mut Frame, area: Rect, _outer_area: Rect) {
         let constraints = vec![Constraint::Length(1), Constraint::Min(4)];
 
         let rows = Layout::default()
@@ -40,20 +40,20 @@ impl View for LayoutView {
         f.render_widget(notification_widget(app), rows[0]);
 
         match app.view_current {
-            SelectedView::Listen => ListenView::draw(app, f, rows[1]),
-            SelectedView::Session => SessionView::draw(app, f, rows[1]),
-            SelectedView::Help => HelpView::draw(app, f, rows[1]),
+            SelectedView::Listen => ListenView::draw(app, f, rows[1], rows[1]),
+            SelectedView::Session => SessionView::draw(app, f, rows[1], rows[1]),
+            SelectedView::Help => HelpView::draw(app, f, rows[1], rows[1]),
         }
 
         if let Some(dialog) = &app.active_dialog {
             match &dialog {
-                ActiveDialog::Eval => EvalDialog::draw(app, f, area),
+                ActiveDialog::Eval => EvalDialog::draw(app, f, area, rows[1]),
             }
         }
     }
 }
 
-fn notification_widget(app: &App) -> Paragraph<'_> {
+fn notification_widget<'a>(app: &'a App) -> Paragraph<'a> {
     Paragraph::new(vec![Line::from(Span::styled(
         match app.notification.is_visible() {
             true => format!(
diff --git a/src/view/listen.rs b/src/view/listen.rs
index dc50d95..d076a67 100644
--- a/src/view/listen.rs
+++ b/src/view/listen.rs
@@ -1,6 +1,9 @@
 use super::View;
 use crate::app::App;
 use crate::event::input::AppEvent;
+use crate::view::eval::ChannelsComponent;
+use ratatui::layout::Rect;
+use ratatui::widgets::{Block, Borders, Clear};
 use ratatui::Frame;
 
 pub struct ListenView {}
@@ -10,5 +13,14 @@ impl View for ListenView {
         None
     }
 
-    fn draw(_app: &App, _f: &mut Frame, _area: ratatui::prelude::Rect) {}
+    fn draw(app: &App, frame: &mut Frame, area: Rect, _outer_area: Rect) {
+
+        let block = Block::default()
+            .borders(Borders::all())
+            .style(app.theme().pane_border_active);
+
+        frame.render_widget(Clear, area);
+        frame.render_widget(&block, area);
+        ChannelsComponent::draw(app, frame, block.inner(area), area);
+    }
 }
diff --git a/src/view/mod.rs b/src/view/mod.rs
index 17435e9..40dc0f9 100644
--- a/src/view/mod.rs
+++ b/src/view/mod.rs
@@ -17,7 +17,7 @@ use ratatui::Frame;
 
 pub trait View {
     fn handle(app: &mut App, event: AppEvent) -> Option<AppEvent>;
-    fn draw(app: &App, frame: &mut Frame, area: Rect);
+    fn draw(app: &App, frame: &mut Frame, area: Rect, outer_area: Rect);
 }
 
 #[derive(Debug)]
diff --git a/src/view/session.rs b/src/view/session.rs
index c1d0c77..6167bf8 100644
--- a/src/view/session.rs
+++ b/src/view/session.rs
@@ -1,5 +1,5 @@
 use super::context::ContextComponent;
-use super::eval::EvalComponent;
+use super::eval::ChannelsComponent;
 use super::eval::EvalState;
 use super::source::SourceComponent;
 use super::stack::StackComponent;
@@ -52,6 +52,7 @@ impl View for SessionView {
             KeyCode::Down => return Some(AppEvent::Scroll((multiplier, 0))),
             KeyCode::Char(char) => match char {
                 'e' => return Some(AppEvent::EvalStart),
+                'c' => return Some(AppEvent::NextChannel),
                 'j' => return Some(AppEvent::Scroll((1, 0))),
                 'k' => return Some(AppEvent::Scroll((-1, 0))),
                 'J' => return Some(AppEvent::Scroll((10, 0))),
@@ -72,6 +73,7 @@ impl View for SessionView {
                     '+' => Some(AppEvent::ContextDepth(1)),
                     '-' => Some(AppEvent::ContextDepth(-1)),
                     'r' => Some(AppEvent::Run),
+                    'R' => Some(AppEvent::RestartProcess),
                     'n' => Some(AppEvent::StepInto),
                     'N' => Some(AppEvent::StepOver),
                     'o' => Some(AppEvent::StepOut),
@@ -87,6 +89,7 @@ impl View for SessionView {
                     'n' => Some(AppEvent::HistoryNext),
                     'p' => Some(AppEvent::HistoryPrevious),
                     'd' => Some(AppEvent::Disconnect),
+                    'R' => Some(AppEvent::RestartProcess),
                     'b' => escape(app),
                     _ => None,
                 },
@@ -101,7 +104,7 @@ impl View for SessionView {
         delegate_event_to_pane(app, event)
     }
 
-    fn draw(app: &App, frame: &mut Frame, area: ratatui::prelude::Rect) {
+    fn draw(app: &App, frame: &mut Frame, area: ratatui::prelude::Rect, _outer_area: Rect) {
         if app.session_view.full_screen {
             build_pane_widget(
                 frame,
@@ -162,7 +165,7 @@ fn delegate_event_to_pane(app: &mut App, event: AppEvent) -> Option<AppEvent> {
         ComponentType::Source => SourceComponent::handle(app, event),
         ComponentType::Context => ContextComponent::handle(app, event),
         ComponentType::Stack => StackComponent::handle(app, event),
-        ComponentType::Eval => EvalComponent::handle(app, event),
+        ComponentType::Eval => ChannelsComponent::handle(app, event),
     }
 }
 
@@ -196,12 +199,13 @@ fn build_pane_widget(frame: &mut Frame, app: &App, pane: &Pane, area: Rect, inde
             ),
             ComponentType::Eval => match app.history.current() {
                 Some(entry) => format!(
-                    "Eval: {}",
+                    "Eval: {} {}",
                     if let Some(eval) = &entry.eval {
                         eval.expr.clone()
                     } else {
                         "Press 'e' to enter an expression".to_string()
-                    }
+                    },
+                    ", 'c' to change channel",
                 ),
                 None => "".to_string(),
             },
@@ -216,16 +220,16 @@ fn build_pane_widget(frame: &mut Frame, app: &App, pane: &Pane, area: Rect, inde
 
     match pane.component_type {
         ComponentType::Source => {
-            SourceComponent::draw(app, frame, block.inner(area));
+            SourceComponent::draw(app, frame, block.inner(area), area);
         }
         ComponentType::Context => {
-            ContextComponent::draw(app, frame, block.inner(area));
+            ContextComponent::draw(app, frame, block.inner(area),  area);
         }
         ComponentType::Stack => {
-            StackComponent::draw(app, frame, block.inner(area));
+            StackComponent::draw(app, frame, block.inner(area), area);
         }
         ComponentType::Eval => {
-            EvalComponent::draw(app, frame, block.inner(area));
+            ChannelsComponent::draw(app, frame, block.inner(area), area);
         }
     };
 }
diff --git a/src/view/source.rs b/src/view/source.rs
index 6533cf7..321ffa6 100644
--- a/src/view/source.rs
+++ b/src/view/source.rs
@@ -22,7 +22,7 @@ impl View for SourceComponent {
         }
     }
 
-    fn draw(app: &App, frame: &mut Frame, area: Rect) {
+    fn draw(app: &App, frame: &mut Frame, area: Rect, _outer_area: Rect) {
         let history_entry = match app.history.current() {
             Some(s) => s,
             None => return,
diff --git a/src/view/stack.rs b/src/view/stack.rs
index f8d3ab3..9d1e392 100644
--- a/src/view/stack.rs
+++ b/src/view/stack.rs
@@ -17,7 +17,7 @@ impl View for StackComponent {
         }
     }
 
-    fn draw(app: &App, frame: &mut Frame, area: Rect) {
+    fn draw(app: &App, frame: &mut Frame, area: Rect, _outer_area: Rect) {
         let entry = match app.history.current() {
             Some(s) => s,
             None => return,