From 67cc9453a58235a0fd722eda946b086849d214e3 Mon Sep 17 00:00:00 2001
From: Septian Dwic <septianopqr@gmail.com>
Date: Thu, 15 Nov 2018 21:00:55 +0700
Subject: [PATCH] Fix rbenv -> phpenv test

---
 test/--version.bats          |  28 +++----
 test/commands.bats           |  12 +--
 test/completions.bats        |  18 ++---
 test/exec.bats               |  84 +++++++--------------
 test/global.bats             |  26 +++----
 test/help.bats               |  80 ++++++++++----------
 test/hooks.bats              |  38 +++++-----
 test/init.bats               |  68 ++++++++---------
 test/libexec/phpenv-echo     |   2 +-
 test/local.bats              | 106 +++++++++++++-------------
 test/phpenv.bats             |  56 +++++++-------
 test/prefix.bats             |  30 ++++----
 test/rehash.bats             | 118 ++++++++++++++---------------
 test/run                     |   2 +-
 test/shell.bats              |  42 +++++------
 test/shims.bats              |  26 +++----
 test/test_helper.bash        |  36 ++++-----
 test/version-file-read.bats  |  54 ++++++-------
 test/version-file-write.bats |  24 +++---
 test/version-file.bats       | 104 ++++++++++++-------------
 test/version-name.bats       |  72 +++++++++---------
 test/version-origin.bats     |  50 ++++++------
 test/version.bats            |  36 ++++-----
 test/versions.bats           | 142 +++++++++++++++++------------------
 test/whence.bats             |  24 +++---
 test/which.bats              | 110 +++++++++++++--------------
 26 files changed, 678 insertions(+), 710 deletions(-)

diff --git a/test/--version.bats b/test/--version.bats
index 556c7d6..2f07559 100644
--- a/test/--version.bats
+++ b/test/--version.bats
@@ -2,13 +2,13 @@
 
 load test_helper
 
-export GIT_DIR="${RBENV_TEST_DIR}/.git"
+export GIT_DIR="${PHPENV_TEST_DIR}/.git"
 
 setup() {
   mkdir -p "$HOME"
   git config --global user.name  "Tester"
   git config --global user.email "tester@test.local"
-  cd "$RBENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
 }
 
 git_commit() {
@@ -16,40 +16,40 @@ git_commit() {
 }
 
 @test "default version" {
-  assert [ ! -e "$RBENV_ROOT" ]
-  run rbenv---version
+  assert [ ! -e "$PHPENV_ROOT" ]
+  run phpenv---version
   assert_success
-  [[ $output == "rbenv "?.?.? ]]
+  [[ $output == "phpenv "?.?.? ]]
 }
 
-@test "doesn't read version from non-rbenv repo" {
+@test "doesn't read version from non-phpenv repo" {
   git init
   git remote add origin https://github.com/homebrew/homebrew.git
   git_commit
   git tag v1.0
 
-  run rbenv---version
+  run phpenv---version
   assert_success
-  [[ $output == "rbenv "?.?.? ]]
+  [[ $output == "phpenv "?.?.? ]]
 }
 
 @test "reads version from git repo" {
   git init
-  git remote add origin https://github.com/rbenv/rbenv.git
+  git remote add origin https://github.com/sptndc/phpenv.git
   git_commit
   git tag v0.4.1
   git_commit
   git_commit
 
-  run rbenv---version
-  assert_success "rbenv 0.4.1-2-g$(git rev-parse --short HEAD)"
+  run phpenv---version
+  assert_success "phpenv 0.4.1-2-g$(git rev-parse --short HEAD)"
 }
 
 @test "prints default version if no tags in git repo" {
   git init
-  git remote add origin https://github.com/rbenv/rbenv.git
+  git remote add origin https://github.com/sptndc/phpenv.git
   git_commit
 
-  run rbenv---version
-  [[ $output == "rbenv "?.?.? ]]
+  run phpenv---version
+  [[ $output == "phpenv "?.?.? ]]
 }
diff --git a/test/commands.bats b/test/commands.bats
index 81d3860..5f09b3d 100644
--- a/test/commands.bats
+++ b/test/commands.bats
@@ -3,7 +3,7 @@
 load test_helper
 
 @test "commands" {
-  run rbenv-commands
+  run phpenv-commands
   assert_success
   assert_line "init"
   assert_line "rehash"
@@ -13,26 +13,26 @@ load test_helper
 }
 
 @test "commands --sh" {
-  run rbenv-commands --sh
+  run phpenv-commands --sh
   assert_success
   refute_line "init"
   assert_line "shell"
 }
 
 @test "commands in path with spaces" {
-  path="${RBENV_TEST_DIR}/my commands"
-  cmd="${path}/rbenv-sh-hello"
+  path="${PHPENV_TEST_DIR}/my commands"
+  cmd="${path}/phpenv-sh-hello"
   mkdir -p "$path"
   touch "$cmd"
   chmod +x "$cmd"
 
-  PATH="${path}:$PATH" run rbenv-commands --sh
+  PATH="${path}:$PATH" run phpenv-commands --sh
   assert_success
   assert_line "hello"
 }
 
 @test "commands --no-sh" {
-  run rbenv-commands --no-sh
+  run phpenv-commands --no-sh
   assert_success
   assert_line "init"
   refute_line "shell"
diff --git a/test/completions.bats b/test/completions.bats
index 6871cf5..7ce5b69 100644
--- a/test/completions.bats
+++ b/test/completions.bats
@@ -3,28 +3,28 @@
 load test_helper
 
 create_command() {
-  bin="${RBENV_TEST_DIR}/bin"
+  bin="${PHPENV_TEST_DIR}/bin"
   mkdir -p "$bin"
   echo "$2" > "${bin}/$1"
   chmod +x "${bin}/$1"
 }
 
 @test "command with no completion support" {
-  create_command "rbenv-hello" "#!$BASH
+  create_command "phpenv-hello" "#!$BASH
     echo hello"
-  run rbenv-completions hello
+  run phpenv-completions hello
   assert_success "--help"
 }
 
 @test "command with completion support" {
-  create_command "rbenv-hello" "#!$BASH
-# Provide rbenv completions
+  create_command "phpenv-hello" "#!$BASH
+# Provide phpenv completions
 if [[ \$1 = --complete ]]; then
   echo hello
 else
   exit 1
 fi"
-  run rbenv-completions hello
+  run phpenv-completions hello
   assert_success
   assert_output <<OUT
 --help
@@ -33,15 +33,15 @@ OUT
 }
 
 @test "forwards extra arguments" {
-  create_command "rbenv-hello" "#!$BASH
-# provide rbenv completions
+  create_command "phpenv-hello" "#!$BASH
+# provide phpenv completions
 if [[ \$1 = --complete ]]; then
   shift 1
   for arg; do echo \$arg; done
 else
   exit 1
 fi"
-  run rbenv-completions hello happy world
+  run phpenv-completions hello happy world
   assert_success
   assert_output <<OUT
 --help
diff --git a/test/exec.bats b/test/exec.bats
index aeb0456..2e37a19 100644
--- a/test/exec.bats
+++ b/test/exec.bats
@@ -5,7 +5,7 @@ load test_helper
 create_executable() {
   name="${1?}"
   shift 1
-  bin="${RBENV_ROOT}/versions/${RBENV_VERSION}/bin"
+  bin="${PHPENV_ROOT}/versions/${PHPENV_VERSION}/bin"
   mkdir -p "$bin"
   { if [ $# -eq 0 ]; then cat -
     else echo "$@"
@@ -15,62 +15,62 @@ create_executable() {
 }
 
 @test "fails with invalid version" {
-  export RBENV_VERSION="2.0"
-  run rbenv-exec ruby -v
-  assert_failure "rbenv: version \`2.0' is not installed (set by RBENV_VERSION environment variable)"
+  export PHPENV_VERSION="2.0"
+  run phpenv-exec php -v
+  assert_failure "phpenv: version \`2.0' is not installed (set by PHPENV_VERSION environment variable)"
 }
 
 @test "fails with invalid version set from file" {
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
-  echo 1.9 > .ruby-version
-  run rbenv-exec rspec
-  assert_failure "rbenv: version \`1.9' is not installed (set by $PWD/.ruby-version)"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
+  echo 7.1 > .php-version
+  run phpenv-exec phpize
+  assert_failure "phpenv: version \`7.1' is not installed (set by $PWD/.php-version)"
 }
 
 @test "completes with names of executables" {
-  export RBENV_VERSION="2.0"
-  create_executable "ruby" "#!/bin/sh"
-  create_executable "rake" "#!/bin/sh"
+  export PHPENV_VERSION="7.2"
+  create_executable "php" "#!/bin/sh"
+  create_executable "php-cgi" "#!/bin/sh"
 
-  rbenv-rehash
-  run rbenv-completions exec
+  phpenv-rehash
+  run phpenv-completions exec
   assert_success
   assert_output <<OUT
 --help
-rake
-ruby
+php
+php-cgi
 OUT
 }
 
 @test "supports hook path with spaces" {
-  hook_path="${RBENV_TEST_DIR}/custom stuff/rbenv hooks"
+  hook_path="${PHPENV_TEST_DIR}/custom stuff/phpenv hooks"
   mkdir -p "${hook_path}/exec"
   echo "export HELLO='from hook'" > "${hook_path}/exec/hello.bash"
 
-  export RBENV_VERSION=system
-  RBENV_HOOK_PATH="$hook_path" run rbenv-exec env
+  export PHPENV_VERSION=system
+  PHPENV_HOOK_PATH="$hook_path" run phpenv-exec env
   assert_success
   assert_line "HELLO=from hook"
 }
 
 @test "carries original IFS within hooks" {
-  hook_path="${RBENV_TEST_DIR}/rbenv.d"
+  hook_path="${PHPENV_TEST_DIR}/phpenv.d"
   mkdir -p "${hook_path}/exec"
   cat > "${hook_path}/exec/hello.bash" <<SH
 hellos=(\$(printf "hello\\tugly world\\nagain"))
 echo HELLO="\$(printf ":%s" "\${hellos[@]}")"
 SH
 
-  export RBENV_VERSION=system
-  RBENV_HOOK_PATH="$hook_path" IFS=$' \t\n' run rbenv-exec env
+  export PHPENV_VERSION=system
+  PHPENV_HOOK_PATH="$hook_path" IFS=$' \t\n' run phpenv-exec env
   assert_success
   assert_line "HELLO=:hello:ugly:world:again"
 }
 
 @test "forwards all arguments" {
-  export RBENV_VERSION="2.0"
-  create_executable "ruby" <<SH
+  export PHPENV_VERSION="7.2"
+  create_executable "php" <<SH
 #!$BASH
 echo \$0
 for arg; do
@@ -79,44 +79,14 @@ for arg; do
 done
 SH
 
-  run rbenv-exec ruby -w "/path to/ruby script.rb" -- extra args
+  run phpenv-exec php -w "/path to/php script.php" -- extra args
   assert_success
   assert_output <<OUT
-${RBENV_ROOT}/versions/2.0/bin/ruby
+${PHPENV_ROOT}/versions/7.2/bin/php
   -w
-  /path to/ruby script.rb
+  /path to/php script.php
   --
   extra
   args
 OUT
 }
-
-@test "supports ruby -S <cmd>" {
-  export RBENV_VERSION="2.0"
-
-  # emulate `ruby -S' behavior
-  create_executable "ruby" <<SH
-#!$BASH
-if [[ \$1 == "-S"* ]]; then
-  found="\$(PATH="\${RUBYPATH:-\$PATH}" which \$2)"
-  # assert that the found executable has ruby for shebang
-  if head -1 "\$found" | grep ruby >/dev/null; then
-    \$BASH "\$found"
-  else
-    echo "ruby: no Ruby script found in input (LoadError)" >&2
-    exit 1
-  fi
-else
-  echo 'ruby 2.0 (rbenv test)'
-fi
-SH
-
-  create_executable "rake" <<SH
-#!/usr/bin/env ruby
-echo hello rake
-SH
-
-  rbenv-rehash
-  run ruby -S rake
-  assert_success "hello rake"
-}
diff --git a/test/global.bats b/test/global.bats
index f6dcc3e..550da08 100644
--- a/test/global.bats
+++ b/test/global.bats
@@ -3,29 +3,29 @@
 load test_helper
 
 @test "default" {
-  run rbenv global
+  run phpenv global
   assert_success
   assert_output "system"
 }
 
-@test "read RBENV_ROOT/version" {
-  mkdir -p "$RBENV_ROOT"
-  echo "1.2.3" > "$RBENV_ROOT/version"
-  run rbenv-global
+@test "read PHPENV_ROOT/version" {
+  mkdir -p "$PHPENV_ROOT"
+  echo "1.2.3" > "$PHPENV_ROOT/version"
+  run phpenv-global
   assert_success
   assert_output "1.2.3"
 }
 
-@test "set RBENV_ROOT/version" {
-  mkdir -p "$RBENV_ROOT/versions/1.2.3"
-  run rbenv-global "1.2.3"
+@test "set PHPENV_ROOT/version" {
+  mkdir -p "$PHPENV_ROOT/versions/1.2.3"
+  run phpenv-global "1.2.3"
   assert_success
-  run rbenv global
+  run phpenv global
   assert_success "1.2.3"
 }
 
-@test "fail setting invalid RBENV_ROOT/version" {
-  mkdir -p "$RBENV_ROOT"
-  run rbenv-global "1.2.3"
-  assert_failure "rbenv: version \`1.2.3' not installed"
+@test "fail setting invalid PHPENV_ROOT/version" {
+  mkdir -p "$PHPENV_ROOT"
+  run phpenv-global "1.2.3"
+  assert_failure "phpenv: version \`1.2.3' not installed"
 }
diff --git a/test/help.bats b/test/help.bats
index 9862d63..0ec7b30 100644
--- a/test/help.bats
+++ b/test/help.bats
@@ -3,97 +3,97 @@
 load test_helper
 
 @test "without args shows summary of common commands" {
-  run rbenv-help
+  run phpenv-help
   assert_success
-  assert_line "Usage: rbenv <command> [<args>]"
-  assert_line "Some useful rbenv commands are:"
+  assert_line "Usage: phpenv <command> [<args>]"
+  assert_line "Some useful phpenv commands are:"
 }
 
 @test "invalid command" {
-  run rbenv-help hello
-  assert_failure "rbenv: no such command \`hello'"
+  run phpenv-help hello
+  assert_failure "phpenv: no such command \`hello'"
 }
 
 @test "shows help for a specific command" {
-  mkdir -p "${RBENV_TEST_DIR}/bin"
-  cat > "${RBENV_TEST_DIR}/bin/rbenv-hello" <<SH
+  mkdir -p "${PHPENV_TEST_DIR}/bin"
+  cat > "${PHPENV_TEST_DIR}/bin/phpenv-hello" <<SH
 #!shebang
-# Usage: rbenv hello <world>
-# Summary: Says "hello" to you, from rbenv
+# Usage: phpenv hello <world>
+# Summary: Says "hello" to you, from phpenv
 # This command is useful for saying hello.
 echo hello
 SH
 
-  run rbenv-help hello
+  run phpenv-help hello
   assert_success
   assert_output <<SH
-Usage: rbenv hello <world>
+Usage: phpenv hello <world>
 
 This command is useful for saying hello.
 SH
 }
 
 @test "replaces missing extended help with summary text" {
-  mkdir -p "${RBENV_TEST_DIR}/bin"
-  cat > "${RBENV_TEST_DIR}/bin/rbenv-hello" <<SH
+  mkdir -p "${PHPENV_TEST_DIR}/bin"
+  cat > "${PHPENV_TEST_DIR}/bin/phpenv-hello" <<SH
 #!shebang
-# Usage: rbenv hello <world>
-# Summary: Says "hello" to you, from rbenv
+# Usage: phpenv hello <world>
+# Summary: Says "hello" to you, from phpenv
 echo hello
 SH
 
-  run rbenv-help hello
+  run phpenv-help hello
   assert_success
   assert_output <<SH
-Usage: rbenv hello <world>
+Usage: phpenv hello <world>
 
-Says "hello" to you, from rbenv
+Says "hello" to you, from phpenv
 SH
 }
 
 @test "extracts only usage" {
-  mkdir -p "${RBENV_TEST_DIR}/bin"
-  cat > "${RBENV_TEST_DIR}/bin/rbenv-hello" <<SH
+  mkdir -p "${PHPENV_TEST_DIR}/bin"
+  cat > "${PHPENV_TEST_DIR}/bin/phpenv-hello" <<SH
 #!shebang
-# Usage: rbenv hello <world>
-# Summary: Says "hello" to you, from rbenv
+# Usage: phpenv hello <world>
+# Summary: Says "hello" to you, from phpenv
 # This extended help won't be shown.
 echo hello
 SH
 
-  run rbenv-help --usage hello
-  assert_success "Usage: rbenv hello <world>"
+  run phpenv-help --usage hello
+  assert_success "Usage: phpenv hello <world>"
 }
 
 @test "multiline usage section" {
-  mkdir -p "${RBENV_TEST_DIR}/bin"
-  cat > "${RBENV_TEST_DIR}/bin/rbenv-hello" <<SH
+  mkdir -p "${PHPENV_TEST_DIR}/bin"
+  cat > "${PHPENV_TEST_DIR}/bin/phpenv-hello" <<SH
 #!shebang
-# Usage: rbenv hello <world>
-#        rbenv hi [everybody]
-#        rbenv hola --translate
-# Summary: Says "hello" to you, from rbenv
+# Usage: phpenv hello <world>
+#        phpenv hi [everybody]
+#        phpenv hola --translate
+# Summary: Says "hello" to you, from phpenv
 # Help text.
 echo hello
 SH
 
-  run rbenv-help hello
+  run phpenv-help hello
   assert_success
   assert_output <<SH
-Usage: rbenv hello <world>
-       rbenv hi [everybody]
-       rbenv hola --translate
+Usage: phpenv hello <world>
+       phpenv hi [everybody]
+       phpenv hola --translate
 
 Help text.
 SH
 }
 
 @test "multiline extended help section" {
-  mkdir -p "${RBENV_TEST_DIR}/bin"
-  cat > "${RBENV_TEST_DIR}/bin/rbenv-hello" <<SH
+  mkdir -p "${PHPENV_TEST_DIR}/bin"
+  cat > "${PHPENV_TEST_DIR}/bin/phpenv-hello" <<SH
 #!shebang
-# Usage: rbenv hello <world>
-# Summary: Says "hello" to you, from rbenv
+# Usage: phpenv hello <world>
+# Summary: Says "hello" to you, from phpenv
 # This is extended help text.
 # It can contain multiple lines.
 #
@@ -102,10 +102,10 @@ SH
 echo hello
 SH
 
-  run rbenv-help hello
+  run phpenv-help hello
   assert_success
   assert_output <<SH
-Usage: rbenv hello <world>
+Usage: phpenv hello <world>
 
 This is extended help text.
 It can contain multiple lines.
diff --git a/test/hooks.bats b/test/hooks.bats
index 99dc4bf..8a62519 100644
--- a/test/hooks.bats
+++ b/test/hooks.bats
@@ -8,53 +8,53 @@ create_hook() {
 }
 
 @test "prints usage help given no argument" {
-  run rbenv-hooks
-  assert_failure "Usage: rbenv hooks <command>"
+  run phpenv-hooks
+  assert_failure "Usage: phpenv hooks <command>"
 }
 
 @test "prints list of hooks" {
-  path1="${RBENV_TEST_DIR}/rbenv.d"
-  path2="${RBENV_TEST_DIR}/etc/rbenv_hooks"
+  path1="${PHPENV_TEST_DIR}/phpenv.d"
+  path2="${PHPENV_TEST_DIR}/etc/phpenv_hooks"
   create_hook "$path1" exec "hello.bash"
   create_hook "$path1" exec "ahoy.bash"
   create_hook "$path1" exec "invalid.sh"
   create_hook "$path1" which "boom.bash"
   create_hook "$path2" exec "bueno.bash"
 
-  RBENV_HOOK_PATH="$path1:$path2" run rbenv-hooks exec
+  PHPENV_HOOK_PATH="$path1:$path2" run phpenv-hooks exec
   assert_success
   assert_output <<OUT
-${RBENV_TEST_DIR}/rbenv.d/exec/ahoy.bash
-${RBENV_TEST_DIR}/rbenv.d/exec/hello.bash
-${RBENV_TEST_DIR}/etc/rbenv_hooks/exec/bueno.bash
+${PHPENV_TEST_DIR}/phpenv.d/exec/ahoy.bash
+${PHPENV_TEST_DIR}/phpenv.d/exec/hello.bash
+${PHPENV_TEST_DIR}/etc/phpenv_hooks/exec/bueno.bash
 OUT
 }
 
 @test "supports hook paths with spaces" {
-  path1="${RBENV_TEST_DIR}/my hooks/rbenv.d"
-  path2="${RBENV_TEST_DIR}/etc/rbenv hooks"
+  path1="${PHPENV_TEST_DIR}/my hooks/phpenv.d"
+  path2="${PHPENV_TEST_DIR}/etc/phpenv hooks"
   create_hook "$path1" exec "hello.bash"
   create_hook "$path2" exec "ahoy.bash"
 
-  RBENV_HOOK_PATH="$path1:$path2" run rbenv-hooks exec
+  PHPENV_HOOK_PATH="$path1:$path2" run phpenv-hooks exec
   assert_success
   assert_output <<OUT
-${RBENV_TEST_DIR}/my hooks/rbenv.d/exec/hello.bash
-${RBENV_TEST_DIR}/etc/rbenv hooks/exec/ahoy.bash
+${PHPENV_TEST_DIR}/my hooks/phpenv.d/exec/hello.bash
+${PHPENV_TEST_DIR}/etc/phpenv hooks/exec/ahoy.bash
 OUT
 }
 
 @test "resolves relative paths" {
-  path="${RBENV_TEST_DIR}/rbenv.d"
+  path="${PHPENV_TEST_DIR}/phpenv.d"
   create_hook "$path" exec "hello.bash"
   mkdir -p "$HOME"
 
-  RBENV_HOOK_PATH="${HOME}/../rbenv.d" run rbenv-hooks exec
-  assert_success "${RBENV_TEST_DIR}/rbenv.d/exec/hello.bash"
+  PHPENV_HOOK_PATH="${HOME}/../phpenv.d" run phpenv-hooks exec
+  assert_success "${PHPENV_TEST_DIR}/phpenv.d/exec/hello.bash"
 }
 
 @test "resolves symlinks" {
-  path="${RBENV_TEST_DIR}/rbenv.d"
+  path="${PHPENV_TEST_DIR}/phpenv.d"
   mkdir -p "${path}/exec"
   mkdir -p "$HOME"
   touch "${HOME}/hola.bash"
@@ -62,10 +62,10 @@ OUT
   touch "${path}/exec/bright.sh"
   ln -s "bright.sh" "${path}/exec/world.bash"
 
-  RBENV_HOOK_PATH="$path" run rbenv-hooks exec
+  PHPENV_HOOK_PATH="$path" run phpenv-hooks exec
   assert_success
   assert_output <<OUT
 ${HOME}/hola.bash
-${RBENV_TEST_DIR}/rbenv.d/exec/bright.sh
+${PHPENV_TEST_DIR}/phpenv.d/exec/bright.sh
 OUT
 }
diff --git a/test/init.bats b/test/init.bats
index d700548..e5eeb8e 100644
--- a/test/init.bats
+++ b/test/init.bats
@@ -3,40 +3,40 @@
 load test_helper
 
 @test "creates shims and versions directories" {
-  assert [ ! -d "${RBENV_ROOT}/shims" ]
-  assert [ ! -d "${RBENV_ROOT}/versions" ]
-  run rbenv-init -
+  assert [ ! -d "${PHPENV_ROOT}/shims" ]
+  assert [ ! -d "${PHPENV_ROOT}/versions" ]
+  run phpenv-init -
   assert_success
-  assert [ -d "${RBENV_ROOT}/shims" ]
-  assert [ -d "${RBENV_ROOT}/versions" ]
+  assert [ -d "${PHPENV_ROOT}/shims" ]
+  assert [ -d "${PHPENV_ROOT}/versions" ]
 }
 
 @test "auto rehash" {
-  run rbenv-init -
+  run phpenv-init -
   assert_success
-  assert_line "command rbenv rehash 2>/dev/null"
+  assert_line "command phpenv rehash 2>/dev/null"
 }
 
 @test "setup shell completions" {
   root="$(cd $BATS_TEST_DIRNAME/.. && pwd)"
-  run rbenv-init - bash
+  run phpenv-init - bash
   assert_success
-  assert_line "source '${root}/test/../libexec/../completions/rbenv.bash'"
+  assert_line "source '${root}/test/../libexec/../completions/phpenv.bash'"
 }
 
 @test "detect parent shell" {
-  SHELL=/bin/false run rbenv-init -
+  SHELL=/bin/false run phpenv-init -
   assert_success
-  assert_line "export RBENV_SHELL=bash"
+  assert_line "export PHPENV_SHELL=bash"
 }
 
 @test "detect parent shell from script" {
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
   cat > myscript.sh <<OUT
 #!/bin/sh
-eval "\$(rbenv-init -)"
-echo \$RBENV_SHELL
+eval "\$(phpenv-init -)"
+echo \$PHPENV_SHELL
 OUT
   chmod +x myscript.sh
   run ./myscript.sh /bin/zsh
@@ -45,63 +45,63 @@ OUT
 
 @test "setup shell completions (fish)" {
   root="$(cd $BATS_TEST_DIRNAME/.. && pwd)"
-  run rbenv-init - fish
+  run phpenv-init - fish
   assert_success
-  assert_line ". '${root}/test/../libexec/../completions/rbenv.fish'"
+  assert_line ". '${root}/test/../libexec/../completions/phpenv.fish'"
 }
 
 @test "fish instructions" {
-  run rbenv-init fish
+  run phpenv-init fish
   assert [ "$status" -eq 1 ]
-  assert_line 'status --is-interactive; and . (rbenv init -|psub)'
+  assert_line 'status --is-interactive; and . (phpenv init -|psub)'
 }
 
 @test "option to skip rehash" {
-  run rbenv-init - --no-rehash
+  run phpenv-init - --no-rehash
   assert_success
-  refute_line "rbenv rehash 2>/dev/null"
+  refute_line "phpenv rehash 2>/dev/null"
 }
 
 @test "adds shims to PATH" {
   export PATH="${BATS_TEST_DIRNAME}/../libexec:/usr/bin:/bin:/usr/local/bin"
-  run rbenv-init - bash
+  run phpenv-init - bash
   assert_success
-  assert_line 0 'export PATH="'${RBENV_ROOT}'/shims:${PATH}"'
+  assert_line 0 'export PATH="'${PHPENV_ROOT}'/shims:${PATH}"'
 }
 
 @test "adds shims to PATH (fish)" {
   export PATH="${BATS_TEST_DIRNAME}/../libexec:/usr/bin:/bin:/usr/local/bin"
-  run rbenv-init - fish
+  run phpenv-init - fish
   assert_success
-  assert_line 0 "setenv PATH '${RBENV_ROOT}/shims' \$PATH"
+  assert_line 0 "setenv PATH '${PHPENV_ROOT}/shims' \$PATH"
 }
 
 @test "can add shims to PATH more than once" {
-  export PATH="${RBENV_ROOT}/shims:$PATH"
-  run rbenv-init - bash
+  export PATH="${PHPENV_ROOT}/shims:$PATH"
+  run phpenv-init - bash
   assert_success
-  assert_line 0 'export PATH="'${RBENV_ROOT}'/shims:${PATH}"'
+  assert_line 0 'export PATH="'${PHPENV_ROOT}'/shims:${PATH}"'
 }
 
 @test "can add shims to PATH more than once (fish)" {
-  export PATH="${RBENV_ROOT}/shims:$PATH"
-  run rbenv-init - fish
+  export PATH="${PHPENV_ROOT}/shims:$PATH"
+  run phpenv-init - fish
   assert_success
-  assert_line 0 "setenv PATH '${RBENV_ROOT}/shims' \$PATH"
+  assert_line 0 "setenv PATH '${PHPENV_ROOT}/shims' \$PATH"
 }
 
 @test "outputs sh-compatible syntax" {
-  run rbenv-init - bash
+  run phpenv-init - bash
   assert_success
   assert_line '  case "$command" in'
 
-  run rbenv-init - zsh
+  run phpenv-init - zsh
   assert_success
   assert_line '  case "$command" in'
 }
 
 @test "outputs fish-specific syntax (fish)" {
-  run rbenv-init - fish
+  run phpenv-init - fish
   assert_success
   assert_line '  switch "$command"'
   refute_line '  case "$command" in'
diff --git a/test/libexec/phpenv-echo b/test/libexec/phpenv-echo
index a94af7b..75fa8bc 100755
--- a/test/libexec/phpenv-echo
+++ b/test/libexec/phpenv-echo
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Usage: rbenv echo [-F<char>] VAR
+# Usage: phpenv echo [-F<char>] VAR
 
 if [[ $1 == -F* ]]; then
   sep="${1:2}"
diff --git a/test/local.bats b/test/local.bats
index a84833e..22dc789 100644
--- a/test/local.bats
+++ b/test/local.bats
@@ -3,101 +3,101 @@
 load test_helper
 
 setup() {
-  mkdir -p "${RBENV_TEST_DIR}/myproject"
-  cd "${RBENV_TEST_DIR}/myproject"
+  mkdir -p "${PHPENV_TEST_DIR}/myproject"
+  cd "${PHPENV_TEST_DIR}/myproject"
 }
 
 @test "no version" {
-  assert [ ! -e "${PWD}/.ruby-version" ]
-  run rbenv-local
-  assert_failure "rbenv: no local version configured for this directory"
+  assert [ ! -e "${PWD}/.php-version" ]
+  run phpenv-local
+  assert_failure "phpenv: no local version configured for this directory"
 }
 
 @test "local version" {
-  echo "1.2.3" > .ruby-version
-  run rbenv-local
+  echo "1.2.3" > .php-version
+  run phpenv-local
   assert_success "1.2.3"
 }
 
-@test "supports legacy .rbenv-version file" {
-  echo "1.2.3" > .rbenv-version
-  run rbenv-local
+@test "supports legacy .phpenv-version file" {
+  echo "1.2.3" > .phpenv-version
+  run phpenv-local
   assert_success "1.2.3"
 }
 
-@test "local .ruby-version has precedence over .rbenv-version" {
-  echo "1.8" > .rbenv-version
-  echo "2.0" > .ruby-version
-  run rbenv-local
-  assert_success "2.0"
+@test "local .php-version has precedence over .phpenv-version" {
+  echo "7.0" > .phpenv-version
+  echo "7.2" > .php-version
+  run phpenv-local
+  assert_success "7.2"
 }
 
 @test "discovers version file in parent directory" {
-  echo "1.2.3" > .ruby-version
+  echo "1.2.3" > .php-version
   mkdir -p "subdir" && cd "subdir"
-  run rbenv-local
+  run phpenv-local
   assert_success "1.2.3"
 }
 
-@test "ignores RBENV_DIR" {
-  echo "1.2.3" > .ruby-version
+@test "ignores PHPENV_DIR" {
+  echo "1.2.3" > .php-version
   mkdir -p "$HOME"
-  echo "2.0-home" > "${HOME}/.ruby-version"
-  RBENV_DIR="$HOME" run rbenv-local
+  echo "7.2-home" > "${HOME}/.php-version"
+  PHPENV_DIR="$HOME" run phpenv-local
   assert_success "1.2.3"
 }
 
 @test "sets local version" {
-  mkdir -p "${RBENV_ROOT}/versions/1.2.3"
-  run rbenv-local 1.2.3
+  mkdir -p "${PHPENV_ROOT}/versions/1.2.3"
+  run phpenv-local 1.2.3
   assert_success ""
-  assert [ "$(cat .ruby-version)" = "1.2.3" ]
+  assert [ "$(cat .php-version)" = "1.2.3" ]
 }
 
 @test "changes local version" {
-  echo "1.0-pre" > .ruby-version
-  mkdir -p "${RBENV_ROOT}/versions/1.2.3"
-  run rbenv-local
-  assert_success "1.0-pre"
-  run rbenv-local 1.2.3
+  echo "5.6-pre" > .php-version
+  mkdir -p "${PHPENV_ROOT}/versions/1.2.3"
+  run phpenv-local
+  assert_success "5.6-pre"
+  run phpenv-local 1.2.3
   assert_success ""
-  assert [ "$(cat .ruby-version)" = "1.2.3" ]
+  assert [ "$(cat .php-version)" = "1.2.3" ]
 }
 
-@test "renames .rbenv-version to .ruby-version" {
-  echo "1.8.7" > .rbenv-version
-  mkdir -p "${RBENV_ROOT}/versions/1.9.3"
-  run rbenv-local
-  assert_success "1.8.7"
-  run rbenv-local "1.9.3"
+@test "renames .phpenv-version to .php-version" {
+  echo "7.0.32" > .phpenv-version
+  mkdir -p "${PHPENV_ROOT}/versions/7.1.23"
+  run phpenv-local
+  assert_success "7.0.32"
+  run phpenv-local "7.1.23"
   assert_success
   assert_output <<OUT
-rbenv: removed existing \`.rbenv-version' file and migrated
-       local version specification to \`.ruby-version' file
+phpenv: removed existing \`.phpenv-version' file and migrated
+        local version specification to \`.php-version' file
 OUT
-  assert [ ! -e .rbenv-version ]
-  assert [ "$(cat .ruby-version)" = "1.9.3" ]
+  assert [ ! -e .phpenv-version ]
+  assert [ "$(cat .php-version)" = "7.1.23" ]
 }
 
-@test "doesn't rename .rbenv-version if changing the version failed" {
-  echo "1.8.7" > .rbenv-version
-  assert [ ! -e "${RBENV_ROOT}/versions/1.9.3" ]
-  run rbenv-local "1.9.3"
-  assert_failure "rbenv: version \`1.9.3' not installed"
-  assert [ ! -e .ruby-version ]
-  assert [ "$(cat .rbenv-version)" = "1.8.7" ]
+@test "doesn't rename .phpenv-version if changing the version failed" {
+  echo "7.0.32" > .phpenv-version
+  assert [ ! -e "${PHPENV_ROOT}/versions/7.1.23" ]
+  run phpenv-local "7.1.23"
+  assert_failure "phpenv: version \`7.1.23' not installed"
+  assert [ ! -e .php-version ]
+  assert [ "$(cat .phpenv-version)" = "7.0.32" ]
 }
 
 @test "unsets local version" {
-  touch .ruby-version
-  run rbenv-local --unset
+  touch .php-version
+  run phpenv-local --unset
   assert_success ""
-  assert [ ! -e .rbenv-version ]
+  assert [ ! -e .phpenv-version ]
 }
 
 @test "unsets alternate version file" {
-  touch .rbenv-version
-  run rbenv-local --unset
+  touch .phpenv-version
+  run phpenv-local --unset
   assert_success ""
-  assert [ ! -e .rbenv-version ]
+  assert [ ! -e .phpenv-version ]
 }
diff --git a/test/phpenv.bats b/test/phpenv.bats
index 6ded889..03f2af6 100644
--- a/test/phpenv.bats
+++ b/test/phpenv.bats
@@ -3,73 +3,71 @@
 load test_helper
 
 @test "blank invocation" {
-  run rbenv
+  run phpenv
   assert_failure
-  assert_line 0 "$(rbenv---version)"
+  assert_line 0 "$(phpenv---version)"
 }
 
 @test "invalid command" {
-  run rbenv does-not-exist
+  run phpenv does-not-exist
   assert_failure
-  assert_output "rbenv: no such command \`does-not-exist'"
+  assert_output "phpenv: no such command \`does-not-exist'"
 }
 
-@test "default RBENV_ROOT" {
-  RBENV_ROOT="" HOME=/home/mislav run rbenv root
+@test "default PHPENV_ROOT" {
+  PHPENV_ROOT="" HOME=/home/sptndc run phpenv root
   assert_success
-  assert_output "/home/mislav/.rbenv"
+  assert_output "/home/sptndc/.phpenv"
 }
 
-@test "inherited RBENV_ROOT" {
-  RBENV_ROOT=/opt/rbenv run rbenv root
+@test "inherited PHPENV_ROOT" {
+  PHPENV_ROOT=/opt/phpenv run phpenv root
   assert_success
-  assert_output "/opt/rbenv"
+  assert_output "/opt/phpenv"
 }
 
-@test "default RBENV_DIR" {
-  run rbenv echo RBENV_DIR
+@test "default PHPENV_DIR" {
+  run phpenv echo PHPENV_DIR
   assert_output "$(pwd)"
 }
 
-@test "inherited RBENV_DIR" {
+@test "inherited PHPENV_DIR" {
   dir="${BATS_TMPDIR}/myproject"
   mkdir -p "$dir"
-  RBENV_DIR="$dir" run rbenv echo RBENV_DIR
+  PHPENV_DIR="$dir" run phpenv echo PHPENV_DIR
   assert_output "$dir"
 }
 
-@test "invalid RBENV_DIR" {
+@test "invalid PHPENV_DIR" {
   dir="${BATS_TMPDIR}/does-not-exist"
   assert [ ! -d "$dir" ]
-  RBENV_DIR="$dir" run rbenv echo RBENV_DIR
+  PHPENV_DIR="$dir" run phpenv echo PHPENV_DIR
   assert_failure
-  assert_output "rbenv: cannot change working directory to \`$dir'"
+  assert_output "phpenv: cannot change working directory to \`$dir'"
 }
 
 @test "adds its own libexec to PATH" {
-  run rbenv echo "PATH"
+  run phpenv echo "PATH"
   assert_success "${BATS_TEST_DIRNAME%/*}/libexec:$PATH"
 }
 
 @test "adds plugin bin dirs to PATH" {
-  mkdir -p "$RBENV_ROOT"/plugins/ruby-build/bin
-  mkdir -p "$RBENV_ROOT"/plugins/rbenv-each/bin
-  run rbenv echo -F: "PATH"
+  mkdir -p "$PHPENV_ROOT"/plugins/php-build/bin
+  run phpenv echo -F: "PATH"
   assert_success
   assert_line 0 "${BATS_TEST_DIRNAME%/*}/libexec"
-  assert_line 1 "${RBENV_ROOT}/plugins/ruby-build/bin"
-  assert_line 2 "${RBENV_ROOT}/plugins/rbenv-each/bin"
+  assert_line 1 "${PHPENV_ROOT}/plugins/php-build/bin"
 }
 
-@test "RBENV_HOOK_PATH preserves value from environment" {
-  RBENV_HOOK_PATH=/my/hook/path:/other/hooks run rbenv echo -F: "RBENV_HOOK_PATH"
+@test "PHPENV_HOOK_PATH preserves value from environment" {
+  PHPENV_HOOK_PATH=/my/hook/path:/other/hooks run phpenv echo -F: "PHPENV_HOOK_PATH"
   assert_success
   assert_line 0 "/my/hook/path"
   assert_line 1 "/other/hooks"
-  assert_line 2 "${RBENV_ROOT}/rbenv.d"
+  assert_line 2 "${PHPENV_ROOT}/phpenv.d"
 }
 
-@test "RBENV_HOOK_PATH includes rbenv built-in plugins" {
-  run rbenv echo "RBENV_HOOK_PATH"
-  assert_success "${RBENV_ROOT}/rbenv.d:${BATS_TEST_DIRNAME%/*}/rbenv.d:/usr/local/etc/rbenv.d:/etc/rbenv.d:/usr/lib/rbenv/hooks"
+@test "PHPENV_HOOK_PATH includes phpenv built-in plugins" {
+  run phpenv echo "PHPENV_HOOK_PATH"
+  assert_success "${PHPENV_ROOT}/phpenv.d:${BATS_TEST_DIRNAME%/*}/phpenv.d:/usr/local/etc/phpenv.d:/etc/phpenv.d:/usr/lib/phpenv/hooks"
 }
diff --git a/test/prefix.bats b/test/prefix.bats
index 3fb9408..37c9039 100644
--- a/test/prefix.bats
+++ b/test/prefix.bats
@@ -3,28 +3,28 @@
 load test_helper
 
 @test "prefix" {
-  mkdir -p "${RBENV_TEST_DIR}/myproject"
-  cd "${RBENV_TEST_DIR}/myproject"
-  echo "1.2.3" > .ruby-version
-  mkdir -p "${RBENV_ROOT}/versions/1.2.3"
-  run rbenv-prefix
-  assert_success "${RBENV_ROOT}/versions/1.2.3"
+  mkdir -p "${PHPENV_TEST_DIR}/myproject"
+  cd "${PHPENV_TEST_DIR}/myproject"
+  echo "1.2.3" > .php-version
+  mkdir -p "${PHPENV_ROOT}/versions/1.2.3"
+  run phpenv-prefix
+  assert_success "${PHPENV_ROOT}/versions/1.2.3"
 }
 
 @test "prefix for invalid version" {
-  RBENV_VERSION="1.2.3" run rbenv-prefix
-  assert_failure "rbenv: version \`1.2.3' not installed"
+  PHPENV_VERSION="1.2.3" run phpenv-prefix
+  assert_failure "phpenv: version \`1.2.3' not installed"
 }
 
 @test "prefix for system" {
-  mkdir -p "${RBENV_TEST_DIR}/bin"
-  touch "${RBENV_TEST_DIR}/bin/ruby"
-  chmod +x "${RBENV_TEST_DIR}/bin/ruby"
-  RBENV_VERSION="system" run rbenv-prefix
-  assert_success "$RBENV_TEST_DIR"
+  mkdir -p "${PHPENV_TEST_DIR}/bin"
+  touch "${PHPENV_TEST_DIR}/bin/php"
+  chmod +x "${PHPENV_TEST_DIR}/bin/php"
+  PHPENV_VERSION="system" run phpenv-prefix
+  assert_success "$PHPENV_TEST_DIR"
 }
 
 @test "prefix for invalid system" {
-  PATH="$(path_without ruby)" run rbenv-prefix system
-  assert_failure "rbenv: system version not found in PATH"
+  PATH="$(path_without php)" run phpenv-prefix system
+  assert_failure "phpenv: system version not found in PATH"
 }
diff --git a/test/rehash.bats b/test/rehash.bats
index 74f55a9..695d14b 100755
--- a/test/rehash.bats
+++ b/test/rehash.bats
@@ -3,109 +3,109 @@
 load test_helper
 
 create_executable() {
-  local bin="${RBENV_ROOT}/versions/${1}/bin"
+  local bin="${PHPENV_ROOT}/versions/${1}/bin"
   mkdir -p "$bin"
   touch "${bin}/$2"
   chmod +x "${bin}/$2"
 }
 
 @test "empty rehash" {
-  assert [ ! -d "${RBENV_ROOT}/shims" ]
-  run rbenv-rehash
+  assert [ ! -d "${PHPENV_ROOT}/shims" ]
+  run phpenv-rehash
   assert_success ""
-  assert [ -d "${RBENV_ROOT}/shims" ]
-  rmdir "${RBENV_ROOT}/shims"
+  assert [ -d "${PHPENV_ROOT}/shims" ]
+  rmdir "${PHPENV_ROOT}/shims"
 }
 
 @test "non-writable shims directory" {
-  mkdir -p "${RBENV_ROOT}/shims"
-  chmod -w "${RBENV_ROOT}/shims"
-  run rbenv-rehash
-  assert_failure "rbenv: cannot rehash: ${RBENV_ROOT}/shims isn't writable"
+  mkdir -p "${PHPENV_ROOT}/shims"
+  chmod -w "${PHPENV_ROOT}/shims"
+  run phpenv-rehash
+  assert_failure "phpenv: cannot rehash: ${PHPENV_ROOT}/shims isn't writable"
 }
 
 @test "rehash in progress" {
-  mkdir -p "${RBENV_ROOT}/shims"
-  touch "${RBENV_ROOT}/shims/.rbenv-shim"
-  run rbenv-rehash
-  assert_failure "rbenv: cannot rehash: ${RBENV_ROOT}/shims/.rbenv-shim exists"
+  mkdir -p "${PHPENV_ROOT}/shims"
+  touch "${PHPENV_ROOT}/shims/.phpenv-shim"
+  run phpenv-rehash
+  assert_failure "phpenv: cannot rehash: ${PHPENV_ROOT}/shims/.phpenv-shim exists"
 }
 
 @test "creates shims" {
-  create_executable "1.8" "ruby"
-  create_executable "1.8" "rake"
-  create_executable "2.0" "ruby"
-  create_executable "2.0" "rspec"
+  create_executable "7.0" "php"
+  create_executable "7.0" "php-cgi"
+  create_executable "7.2" "php"
+  create_executable "7.2" "phpdbg"
 
-  assert [ ! -e "${RBENV_ROOT}/shims/ruby" ]
-  assert [ ! -e "${RBENV_ROOT}/shims/rake" ]
-  assert [ ! -e "${RBENV_ROOT}/shims/rspec" ]
+  assert [ ! -e "${PHPENV_ROOT}/shims/php" ]
+  assert [ ! -e "${PHPENV_ROOT}/shims/php-cgi" ]
+  assert [ ! -e "${PHPENV_ROOT}/shims/phpdbg" ]
 
-  run rbenv-rehash
+  run phpenv-rehash
   assert_success ""
 
-  run ls "${RBENV_ROOT}/shims"
+  run ls "${PHPENV_ROOT}/shims"
   assert_success
   assert_output <<OUT
-rake
-rspec
-ruby
+php
+php-cgi
+phpdbg
 OUT
 }
 
 @test "removes outdated shims" {
-  mkdir -p "${RBENV_ROOT}/shims"
-  touch "${RBENV_ROOT}/shims/oldshim1"
-  chmod +x "${RBENV_ROOT}/shims/oldshim1"
+  mkdir -p "${PHPENV_ROOT}/shims"
+  touch "${PHPENV_ROOT}/shims/oldshim1"
+  chmod +x "${PHPENV_ROOT}/shims/oldshim1"
 
-  create_executable "2.0" "rake"
-  create_executable "2.0" "ruby"
+  create_executable "7.2" "php"
+  create_executable "7.2" "php-cgi"
 
-  run rbenv-rehash
+  run phpenv-rehash
   assert_success ""
 
-  assert [ ! -e "${RBENV_ROOT}/shims/oldshim1" ]
+  assert [ ! -e "${PHPENV_ROOT}/shims/oldshim1" ]
 }
 
 @test "do exact matches when removing stale shims" {
-  create_executable "2.0" "unicorn_rails"
-  create_executable "2.0" "rspec-core"
+  create_executable "7.2" "phpdbg"
+  create_executable "7.2" "phar"
 
-  rbenv-rehash
+  phpenv-rehash
 
-  cp "$RBENV_ROOT"/shims/{rspec-core,rspec}
-  cp "$RBENV_ROOT"/shims/{rspec-core,rails}
-  cp "$RBENV_ROOT"/shims/{rspec-core,uni}
-  chmod +x "$RBENV_ROOT"/shims/{rspec,rails,uni}
+  cp "$PHPENV_ROOT"/shims/{phar,phpcbf}
+  cp "$PHPENV_ROOT"/shims/{phar,phpcs}
+  cp "$PHPENV_ROOT"/shims/{phar,phpunit}
+  chmod +x "$PHPENV_ROOT"/shims/{phpcbf,phpcs,phpunit}
 
-  run rbenv-rehash
+  run phpenv-rehash
   assert_success ""
 
-  assert [ ! -e "${RBENV_ROOT}/shims/rails" ]
-  assert [ ! -e "${RBENV_ROOT}/shims/rake" ]
-  assert [ ! -e "${RBENV_ROOT}/shims/uni" ]
+  assert [ ! -e "${PHPENV_ROOT}/shims/phpcbf" ]
+  assert [ ! -e "${PHPENV_ROOT}/shims/phpcs" ]
+  assert [ ! -e "${PHPENV_ROOT}/shims/phpunit" ]
 }
 
 @test "binary install locations containing spaces" {
-  create_executable "dirname1 p247" "ruby"
-  create_executable "dirname2 preview1" "rspec"
+  create_executable "dirname1 RC1" "php"
+  create_executable "dirname2 beta1" "phpize"
 
-  assert [ ! -e "${RBENV_ROOT}/shims/ruby" ]
-  assert [ ! -e "${RBENV_ROOT}/shims/rspec" ]
+  assert [ ! -e "${PHPENV_ROOT}/shims/php" ]
+  assert [ ! -e "${PHPENV_ROOT}/shims/phpize" ]
 
-  run rbenv-rehash
+  run phpenv-rehash
   assert_success ""
 
-  run ls "${RBENV_ROOT}/shims"
+  run ls "${PHPENV_ROOT}/shims"
   assert_success
   assert_output <<OUT
-rspec
-ruby
+php
+phpize
 OUT
 }
 
 @test "carries original IFS within hooks" {
-  hook_path="${RBENV_TEST_DIR}/rbenv.d"
+  hook_path="${PHPENV_TEST_DIR}/phpenv.d"
   mkdir -p "${hook_path}/rehash"
   cat > "${hook_path}/rehash/hello.bash" <<SH
 hellos=(\$(printf "hello\\tugly world\\nagain"))
@@ -113,21 +113,21 @@ echo HELLO="\$(printf ":%s" "\${hellos[@]}")"
 exit
 SH
 
-  RBENV_HOOK_PATH="$hook_path" IFS=$' \t\n' run rbenv-rehash
+  PHPENV_HOOK_PATH="$hook_path" IFS=$' \t\n' run phpenv-rehash
   assert_success
   assert_output "HELLO=:hello:ugly:world:again"
 }
 
 @test "sh-rehash in bash" {
-  create_executable "2.0" "ruby"
-  RBENV_SHELL=bash run rbenv-sh-rehash
+  create_executable "7.2" "php"
+  PHPENV_SHELL=bash run phpenv-sh-rehash
   assert_success "hash -r 2>/dev/null || true"
-  assert [ -x "${RBENV_ROOT}/shims/ruby" ]
+  assert [ -x "${PHPENV_ROOT}/shims/php" ]
 }
 
 @test "sh-rehash in fish" {
-  create_executable "2.0" "ruby"
-  RBENV_SHELL=fish run rbenv-sh-rehash
+  create_executable "7.2" "php"
+  PHPENV_SHELL=fish run phpenv-sh-rehash
   assert_success ""
-  assert [ -x "${RBENV_ROOT}/shims/ruby" ]
+  assert [ -x "${PHPENV_ROOT}/shims/php" ]
 }
diff --git a/test/run b/test/run
index 9d3b9e5..b4f3b33 100755
--- a/test/run
+++ b/test/run
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -e
 
-if [ -n "$RBENV_NATIVE_EXT" ]; then
+if [ -n "$PHPENV_NATIVE_EXT" ]; then
   src/configure
   make -C src
 fi
diff --git a/test/shell.bats b/test/shell.bats
index 0f77674..18a4aff 100644
--- a/test/shell.bats
+++ b/test/shell.bats
@@ -3,50 +3,50 @@
 load test_helper
 
 @test "no shell version" {
-  mkdir -p "${RBENV_TEST_DIR}/myproject"
-  cd "${RBENV_TEST_DIR}/myproject"
-  echo "1.2.3" > .ruby-version
-  RBENV_VERSION="" run rbenv-sh-shell
-  assert_failure "rbenv: no shell-specific version configured"
+  mkdir -p "${PHPENV_TEST_DIR}/myproject"
+  cd "${PHPENV_TEST_DIR}/myproject"
+  echo "1.2.3" > .php-version
+  PHPENV_VERSION="" run phpenv-sh-shell
+  assert_failure "phpenv: no shell-specific version configured"
 }
 
 @test "shell version" {
-  RBENV_SHELL=bash RBENV_VERSION="1.2.3" run rbenv-sh-shell
-  assert_success 'echo "$RBENV_VERSION"'
+  PHPENV_SHELL=bash PHPENV_VERSION="1.2.3" run phpenv-sh-shell
+  assert_success 'echo "$PHPENV_VERSION"'
 }
 
 @test "shell version (fish)" {
-  RBENV_SHELL=fish RBENV_VERSION="1.2.3" run rbenv-sh-shell
-  assert_success 'echo "$RBENV_VERSION"'
+  PHPENV_SHELL=fish PHPENV_VERSION="1.2.3" run phpenv-sh-shell
+  assert_success 'echo "$PHPENV_VERSION"'
 }
 
 @test "shell unset" {
-  RBENV_SHELL=bash run rbenv-sh-shell --unset
-  assert_success "unset RBENV_VERSION"
+  PHPENV_SHELL=bash run phpenv-sh-shell --unset
+  assert_success "unset PHPENV_VERSION"
 }
 
 @test "shell unset (fish)" {
-  RBENV_SHELL=fish run rbenv-sh-shell --unset
-  assert_success "set -e RBENV_VERSION"
+  PHPENV_SHELL=fish run phpenv-sh-shell --unset
+  assert_success "set -e PHPENV_VERSION"
 }
 
 @test "shell change invalid version" {
-  run rbenv-sh-shell 1.2.3
+  run phpenv-sh-shell 1.2.3
   assert_failure
   assert_output <<SH
-rbenv: version \`1.2.3' not installed
+phpenv: version \`1.2.3' not installed
 false
 SH
 }
 
 @test "shell change version" {
-  mkdir -p "${RBENV_ROOT}/versions/1.2.3"
-  RBENV_SHELL=bash run rbenv-sh-shell 1.2.3
-  assert_success 'export RBENV_VERSION="1.2.3"'
+  mkdir -p "${PHPENV_ROOT}/versions/1.2.3"
+  PHPENV_SHELL=bash run phpenv-sh-shell 1.2.3
+  assert_success 'export PHPENV_VERSION="1.2.3"'
 }
 
 @test "shell change version (fish)" {
-  mkdir -p "${RBENV_ROOT}/versions/1.2.3"
-  RBENV_SHELL=fish run rbenv-sh-shell 1.2.3
-  assert_success 'setenv RBENV_VERSION "1.2.3"'
+  mkdir -p "${PHPENV_ROOT}/versions/1.2.3"
+  PHPENV_SHELL=fish run phpenv-sh-shell 1.2.3
+  assert_success 'setenv PHPENV_VERSION "1.2.3"'
 }
diff --git a/test/shims.bats b/test/shims.bats
index 194554a..66cd1d5 100644
--- a/test/shims.bats
+++ b/test/shims.bats
@@ -3,27 +3,27 @@
 load test_helper
 
 @test "no shims" {
-  run rbenv-shims
+  run phpenv-shims
   assert_success
   assert [ -z "$output" ]
 }
 
 @test "shims" {
-  mkdir -p "${RBENV_ROOT}/shims"
-  touch "${RBENV_ROOT}/shims/ruby"
-  touch "${RBENV_ROOT}/shims/irb"
-  run rbenv-shims
+  mkdir -p "${PHPENV_ROOT}/shims"
+  touch "${PHPENV_ROOT}/shims/php"
+  touch "${PHPENV_ROOT}/shims/phpdbg"
+  run phpenv-shims
   assert_success
-  assert_line "${RBENV_ROOT}/shims/ruby"
-  assert_line "${RBENV_ROOT}/shims/irb"
+  assert_line "${PHPENV_ROOT}/shims/php"
+  assert_line "${PHPENV_ROOT}/shims/phpdbg"
 }
 
 @test "shims --short" {
-  mkdir -p "${RBENV_ROOT}/shims"
-  touch "${RBENV_ROOT}/shims/ruby"
-  touch "${RBENV_ROOT}/shims/irb"
-  run rbenv-shims --short
+  mkdir -p "${PHPENV_ROOT}/shims"
+  touch "${PHPENV_ROOT}/shims/php"
+  touch "${PHPENV_ROOT}/shims/phpdbg"
+  run phpenv-shims --short
   assert_success
-  assert_line "irb"
-  assert_line "ruby"
+  assert_line "php"
+  assert_line "phpdbg"
 }
diff --git a/test/test_helper.bash b/test/test_helper.bash
index b62cdc1..33b502a 100644
--- a/test/test_helper.bash
+++ b/test/test_helper.bash
@@ -1,28 +1,28 @@
-unset RBENV_VERSION
-unset RBENV_DIR
+unset PHPENV_VERSION
+unset PHPENV_DIR
 
 # guard against executing this block twice due to bats internals
-if [ -z "$RBENV_TEST_DIR" ]; then
-  RBENV_TEST_DIR="${BATS_TMPDIR}/rbenv"
-  export RBENV_TEST_DIR="$(mktemp -d "${RBENV_TEST_DIR}.XXX" 2>/dev/null || echo "$RBENV_TEST_DIR")"
+if [ -z "$PHPENV_TEST_DIR" ]; then
+  PHPENV_TEST_DIR="${BATS_TMPDIR}/phpenv"
+  export PHPENV_TEST_DIR="$(mktemp -d "${PHPENV_TEST_DIR}.XXX" 2>/dev/null || echo "$PHPENV_TEST_DIR")"
 
-  if enable -f "${BATS_TEST_DIRNAME}"/../libexec/rbenv-realpath.dylib realpath 2>/dev/null; then
-    export RBENV_TEST_DIR="$(realpath "$RBENV_TEST_DIR")"
+  if enable -f "${BATS_TEST_DIRNAME}"/../libexec/phpenv-realpath.dylib realpath 2>/dev/null; then
+    export PHPENV_TEST_DIR="$(realpath "$PHPENV_TEST_DIR")"
   else
-    if [ -n "$RBENV_NATIVE_EXT" ]; then
-      echo "rbenv: failed to load \`realpath' builtin" >&2
+    if [ -n "$PHPENV_NATIVE_EXT" ]; then
+      echo "phpenv: failed to load \`realpath' builtin" >&2
       exit 1
     fi
   fi
 
-  export RBENV_ROOT="${RBENV_TEST_DIR}/root"
-  export HOME="${RBENV_TEST_DIR}/home"
+  export PHPENV_ROOT="${PHPENV_TEST_DIR}/root"
+  export HOME="${PHPENV_TEST_DIR}/home"
 
   PATH=/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin
-  PATH="${RBENV_TEST_DIR}/bin:$PATH"
+  PATH="${PHPENV_TEST_DIR}/bin:$PATH"
   PATH="${BATS_TEST_DIRNAME}/../libexec:$PATH"
   PATH="${BATS_TEST_DIRNAME}/libexec:$PATH"
-  PATH="${RBENV_ROOT}/shims:$PATH"
+  PATH="${PHPENV_ROOT}/shims:$PATH"
   export PATH
 
   for xdg_var in `env 2>/dev/null | grep ^XDG_ | cut -d= -f1`; do unset "$xdg_var"; done
@@ -30,14 +30,14 @@ if [ -z "$RBENV_TEST_DIR" ]; then
 fi
 
 teardown() {
-  rm -rf "$RBENV_TEST_DIR"
+  rm -rf "$PHPENV_TEST_DIR"
 }
 
 flunk() {
   { if [ "$#" -eq 0 ]; then cat -
     else echo "$@"
     fi
-  } | sed "s:${RBENV_TEST_DIR}:TEST_DIR:g" >&2
+  } | sed "s:${PHPENV_TEST_DIR}:TEST_DIR:g" >&2
   return 1
 }
 
@@ -108,15 +108,15 @@ assert() {
 }
 
 # Output a modified PATH that ensures that the given executable is not present,
-# but in which system utils necessary for rbenv operation are still available.
+# but in which system utils necessary for phpenv operation are still available.
 path_without() {
   local exe="$1"
   local path=":${PATH}:"
   local found alt util
   for found in $(which -a "$exe"); do
     found="${found%/*}"
-    if [ "$found" != "${RBENV_ROOT}/shims" ]; then
-      alt="${RBENV_TEST_DIR}/$(echo "${found#/}" | tr '/' '-')"
+    if [ "$found" != "${PHPENV_ROOT}/shims" ]; then
+      alt="${PHPENV_TEST_DIR}/$(echo "${found#/}" | tr '/' '-')"
       mkdir -p "$alt"
       for util in bash head cut readlink greadlink; do
         if [ -x "${found}/$util" ]; then
diff --git a/test/version-file-read.bats b/test/version-file-read.bats
index bf7bf91..04ba753 100644
--- a/test/version-file-read.bats
+++ b/test/version-file-read.bats
@@ -3,70 +3,70 @@
 load test_helper
 
 setup() {
-  mkdir -p "${RBENV_TEST_DIR}/myproject"
-  cd "${RBENV_TEST_DIR}/myproject"
+  mkdir -p "${PHPENV_TEST_DIR}/myproject"
+  cd "${PHPENV_TEST_DIR}/myproject"
 }
 
 @test "fails without arguments" {
-  run rbenv-version-file-read
+  run phpenv-version-file-read
   assert_failure ""
 }
 
 @test "fails for invalid file" {
-  run rbenv-version-file-read "non-existent"
+  run phpenv-version-file-read "non-existent"
   assert_failure ""
 }
 
 @test "fails for blank file" {
   echo > my-version
-  run rbenv-version-file-read my-version
+  run phpenv-version-file-read my-version
   assert_failure ""
 }
 
 @test "reads simple version file" {
-  cat > my-version <<<"1.9.3"
-  run rbenv-version-file-read my-version
-  assert_success "1.9.3"
+  cat > my-version <<<"7.1.23"
+  run phpenv-version-file-read my-version
+  assert_success "7.1.23"
 }
 
 @test "ignores leading spaces" {
-  cat > my-version <<<"  1.9.3"
-  run rbenv-version-file-read my-version
-  assert_success "1.9.3"
+  cat > my-version <<<"  7.1.23"
+  run phpenv-version-file-read my-version
+  assert_success "7.1.23"
 }
 
 @test "reads only the first word from file" {
-  cat > my-version <<<"1.9.3-p194@tag 1.8.7 hi"
-  run rbenv-version-file-read my-version
-  assert_success "1.9.3-p194@tag"
+  cat > my-version <<<"7.1.23@tag 7.0.32 hi"
+  run phpenv-version-file-read my-version
+  assert_success "7.1.23@tag"
 }
 
 @test "loads only the first line in file" {
   cat > my-version <<IN
-1.8.7 one
-1.9.3 two
+7.0.32 one
+7.1.23 two
 IN
-  run rbenv-version-file-read my-version
-  assert_success "1.8.7"
+  run phpenv-version-file-read my-version
+  assert_success "7.0.32"
 }
 
 @test "ignores leading blank lines" {
   cat > my-version <<IN
 
-1.9.3
+7.1.23
 IN
-  run rbenv-version-file-read my-version
-  assert_success "1.9.3"
+  run phpenv-version-file-read my-version
+  assert_success "7.1.23"
 }
 
 @test "handles the file with no trailing newline" {
-  echo -n "1.8.7" > my-version
-  run rbenv-version-file-read my-version
-  assert_success "1.8.7"
+  echo -n "7.0.32" > my-version
+  run phpenv-version-file-read my-version
+  assert_success "7.0.32"
 }
 
 @test "ignores carriage returns" {
-  cat > my-version <<< $'1.9.3\r'
-  run rbenv-version-file-read my-version
-  assert_success "1.9.3"
+  cat > my-version <<< $'7.1.23\r'
+  run phpenv-version-file-read my-version
+  assert_success "7.1.23"
 }
diff --git a/test/version-file-write.bats b/test/version-file-write.bats
index 0393a97..ee1bdd8 100644
--- a/test/version-file-write.bats
+++ b/test/version-file-write.bats
@@ -3,28 +3,28 @@
 load test_helper
 
 setup() {
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
 }
 
 @test "invocation without 2 arguments prints usage" {
-  run rbenv-version-file-write
-  assert_failure "Usage: rbenv version-file-write <file> <version>"
-  run rbenv-version-file-write "one" ""
+  run phpenv-version-file-write
+  assert_failure "Usage: phpenv version-file-write <file> <version>"
+  run phpenv-version-file-write "one" ""
   assert_failure
 }
 
 @test "setting nonexistent version fails" {
-  assert [ ! -e ".ruby-version" ]
-  run rbenv-version-file-write ".ruby-version" "1.8.7"
-  assert_failure "rbenv: version \`1.8.7' not installed"
-  assert [ ! -e ".ruby-version" ]
+  assert [ ! -e ".php-version" ]
+  run phpenv-version-file-write ".php-version" "7.0.32"
+  assert_failure "phpenv: version \`7.0.32' not installed"
+  assert [ ! -e ".php-version" ]
 }
 
 @test "writes value to arbitrary file" {
-  mkdir -p "${RBENV_ROOT}/versions/1.8.7"
+  mkdir -p "${PHPENV_ROOT}/versions/7.0.32"
   assert [ ! -e "my-version" ]
-  run rbenv-version-file-write "${PWD}/my-version" "1.8.7"
+  run phpenv-version-file-write "${PWD}/my-version" "7.0.32"
   assert_success ""
-  assert [ "$(cat my-version)" = "1.8.7" ]
+  assert [ "$(cat my-version)" = "7.0.32" ]
 }
diff --git a/test/version-file.bats b/test/version-file.bats
index ef7901f..290fb4a 100644
--- a/test/version-file.bats
+++ b/test/version-file.bats
@@ -3,8 +3,8 @@
 load test_helper
 
 setup() {
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
 }
 
 create_file() {
@@ -13,98 +13,98 @@ create_file() {
 }
 
 @test "prints global file if no version files exist" {
-  assert [ ! -e "${RBENV_ROOT}/version" ]
-  assert [ ! -e ".ruby-version" ]
-  run rbenv-version-file
-  assert_success "${RBENV_ROOT}/version"
+  assert [ ! -e "${PHPENV_ROOT}/version" ]
+  assert [ ! -e ".php-version" ]
+  run phpenv-version-file
+  assert_success "${PHPENV_ROOT}/version"
 }
 
 @test "detects 'global' file" {
-  create_file "${RBENV_ROOT}/global"
-  run rbenv-version-file
-  assert_success "${RBENV_ROOT}/global"
+  create_file "${PHPENV_ROOT}/global"
+  run phpenv-version-file
+  assert_success "${PHPENV_ROOT}/global"
 }
 
 @test "detects 'default' file" {
-  create_file "${RBENV_ROOT}/default"
-  run rbenv-version-file
-  assert_success "${RBENV_ROOT}/default"
+  create_file "${PHPENV_ROOT}/default"
+  run phpenv-version-file
+  assert_success "${PHPENV_ROOT}/default"
 }
 
 @test "'version' has precedence over 'global' and 'default'" {
-  create_file "${RBENV_ROOT}/version"
-  create_file "${RBENV_ROOT}/global"
-  create_file "${RBENV_ROOT}/default"
-  run rbenv-version-file
-  assert_success "${RBENV_ROOT}/version"
+  create_file "${PHPENV_ROOT}/version"
+  create_file "${PHPENV_ROOT}/global"
+  create_file "${PHPENV_ROOT}/default"
+  run phpenv-version-file
+  assert_success "${PHPENV_ROOT}/version"
 }
 
 @test "in current directory" {
-  create_file ".ruby-version"
-  run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/.ruby-version"
+  create_file ".php-version"
+  run phpenv-version-file
+  assert_success "${PHPENV_TEST_DIR}/.php-version"
 }
 
 @test "legacy file in current directory" {
-  create_file ".rbenv-version"
-  run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/.rbenv-version"
+  create_file ".phpenv-version"
+  run phpenv-version-file
+  assert_success "${PHPENV_TEST_DIR}/.phpenv-version"
 }
 
-@test ".ruby-version has precedence over legacy file" {
-  create_file ".ruby-version"
-  create_file ".rbenv-version"
-  run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/.ruby-version"
+@test ".php-version has precedence over legacy file" {
+  create_file ".php-version"
+  create_file ".phpenv-version"
+  run phpenv-version-file
+  assert_success "${PHPENV_TEST_DIR}/.php-version"
 }
 
 @test "in parent directory" {
-  create_file ".ruby-version"
+  create_file ".php-version"
   mkdir -p project
   cd project
-  run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/.ruby-version"
+  run phpenv-version-file
+  assert_success "${PHPENV_TEST_DIR}/.php-version"
 }
 
 @test "topmost file has precedence" {
-  create_file ".ruby-version"
-  create_file "project/.ruby-version"
+  create_file ".php-version"
+  create_file "project/.php-version"
   cd project
-  run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/project/.ruby-version"
+  run phpenv-version-file
+  assert_success "${PHPENV_TEST_DIR}/project/.php-version"
 }
 
 @test "legacy file has precedence if higher" {
-  create_file ".ruby-version"
-  create_file "project/.rbenv-version"
+  create_file ".php-version"
+  create_file "project/.phpenv-version"
   cd project
-  run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/project/.rbenv-version"
+  run phpenv-version-file
+  assert_success "${PHPENV_TEST_DIR}/project/.phpenv-version"
 }
 
-@test "RBENV_DIR has precedence over PWD" {
-  create_file "widget/.ruby-version"
-  create_file "project/.ruby-version"
+@test "PHPENV_DIR has precedence over PWD" {
+  create_file "widget/.php-version"
+  create_file "project/.php-version"
   cd project
-  RBENV_DIR="${RBENV_TEST_DIR}/widget" run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/widget/.ruby-version"
+  PHPENV_DIR="${PHPENV_TEST_DIR}/widget" run phpenv-version-file
+  assert_success "${PHPENV_TEST_DIR}/widget/.php-version"
 }
 
-@test "PWD is searched if RBENV_DIR yields no results" {
+@test "PWD is searched if PHPENV_DIR yields no results" {
   mkdir -p "widget/blank"
-  create_file "project/.ruby-version"
+  create_file "project/.php-version"
   cd project
-  RBENV_DIR="${RBENV_TEST_DIR}/widget/blank" run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/project/.ruby-version"
+  PHPENV_DIR="${PHPENV_TEST_DIR}/widget/blank" run phpenv-version-file
+  assert_success "${PHPENV_TEST_DIR}/project/.php-version"
 }
 
 @test "finds version file in target directory" {
-  create_file "project/.ruby-version"
-  run rbenv-version-file "${PWD}/project"
-  assert_success "${RBENV_TEST_DIR}/project/.ruby-version"
+  create_file "project/.php-version"
+  run phpenv-version-file "${PWD}/project"
+  assert_success "${PHPENV_TEST_DIR}/project/.php-version"
 }
 
 @test "fails when no version file in target directory" {
-  run rbenv-version-file "$PWD"
+  run phpenv-version-file "$PWD"
   assert_failure ""
 }
diff --git a/test/version-name.bats b/test/version-name.bats
index 82e1b2d..35d24e0 100644
--- a/test/version-name.bats
+++ b/test/version-name.bats
@@ -3,72 +3,72 @@
 load test_helper
 
 create_version() {
-  mkdir -p "${RBENV_ROOT}/versions/$1"
+  mkdir -p "${PHPENV_ROOT}/versions/$1"
 }
 
 setup() {
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
 }
 
 @test "no version selected" {
-  assert [ ! -d "${RBENV_ROOT}/versions" ]
-  run rbenv-version-name
+  assert [ ! -d "${PHPENV_ROOT}/versions" ]
+  run phpenv-version-name
   assert_success "system"
 }
 
 @test "system version is not checked for existance" {
-  RBENV_VERSION=system run rbenv-version-name
+  PHPENV_VERSION=system run phpenv-version-name
   assert_success "system"
 }
 
-@test "RBENV_VERSION can be overridden by hook" {
-  create_version "1.8.7"
-  create_version "1.9.3"
+@test "PHPENV_VERSION can be overridden by hook" {
+  create_version "7.0.32"
+  create_version "7.1.23"
 
-  mkdir -p "${RBENV_ROOT}/rbenv.d/version-name"
-  cat > "${RBENV_ROOT}/rbenv.d/version-name/test.bash" <<HOOK
-RBENV_VERSION=1.9.3
+  mkdir -p "${PHPENV_ROOT}/phpenv.d/version-name"
+  cat > "${PHPENV_ROOT}/phpenv.d/version-name/test.bash" <<HOOK
+PHPENV_VERSION=7.1.23
 HOOK
 
-  RBENV_VERSION=1.8.7 RBENV_HOOK_PATH="${RBENV_ROOT}/rbenv.d" run rbenv-version-name
-  assert_success "1.9.3"
+  PHPENV_VERSION=7.0.32 PHPENV_HOOK_PATH="${PHPENV_ROOT}/phpenv.d" run phpenv-version-name
+  assert_success "7.1.23"
 }
 
-@test "RBENV_VERSION has precedence over local" {
-  create_version "1.8.7"
-  create_version "1.9.3"
+@test "PHPENV_VERSION has precedence over local" {
+  create_version "7.0.32"
+  create_version "7.1.23"
 
-  cat > ".ruby-version" <<<"1.8.7"
-  run rbenv-version-name
-  assert_success "1.8.7"
+  cat > ".php-version" <<<"7.0.32"
+  run phpenv-version-name
+  assert_success "7.0.32"
 
-  RBENV_VERSION=1.9.3 run rbenv-version-name
-  assert_success "1.9.3"
+  PHPENV_VERSION=7.1.23 run phpenv-version-name
+  assert_success "7.1.23"
 }
 
 @test "local file has precedence over global" {
-  create_version "1.8.7"
-  create_version "1.9.3"
+  create_version "7.0.32"
+  create_version "7.1.23"
 
-  cat > "${RBENV_ROOT}/version" <<<"1.8.7"
-  run rbenv-version-name
-  assert_success "1.8.7"
+  cat > "${PHPENV_ROOT}/version" <<<"7.0.32"
+  run phpenv-version-name
+  assert_success "7.0.32"
 
-  cat > ".ruby-version" <<<"1.9.3"
-  run rbenv-version-name
-  assert_success "1.9.3"
+  cat > ".php-version" <<<"7.1.23"
+  run phpenv-version-name
+  assert_success "7.1.23"
 }
 
 @test "missing version" {
-  RBENV_VERSION=1.2 run rbenv-version-name
-  assert_failure "rbenv: version \`1.2' is not installed (set by RBENV_VERSION environment variable)"
+  PHPENV_VERSION=1.2 run phpenv-version-name
+  assert_failure "phpenv: version \`1.2' is not installed (set by PHPENV_VERSION environment variable)"
 }
 
 @test "version with prefix in name" {
-  create_version "1.8.7"
-  cat > ".ruby-version" <<<"ruby-1.8.7"
-  run rbenv-version-name
+  create_version "7.0.32"
+  cat > ".php-version" <<<"php-7.0.32"
+  run phpenv-version-name
   assert_success
-  assert_output "1.8.7"
+  assert_output "7.0.32"
 }
diff --git a/test/version-origin.bats b/test/version-origin.bats
index 61e1dfe..62ad0fd 100644
--- a/test/version-origin.bats
+++ b/test/version-origin.bats
@@ -3,51 +3,51 @@
 load test_helper
 
 setup() {
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
 }
 
 @test "reports global file even if it doesn't exist" {
-  assert [ ! -e "${RBENV_ROOT}/version" ]
-  run rbenv-version-origin
-  assert_success "${RBENV_ROOT}/version"
+  assert [ ! -e "${PHPENV_ROOT}/version" ]
+  run phpenv-version-origin
+  assert_success "${PHPENV_ROOT}/version"
 }
 
 @test "detects global file" {
-  mkdir -p "$RBENV_ROOT"
-  touch "${RBENV_ROOT}/version"
-  run rbenv-version-origin
-  assert_success "${RBENV_ROOT}/version"
+  mkdir -p "$PHPENV_ROOT"
+  touch "${PHPENV_ROOT}/version"
+  run phpenv-version-origin
+  assert_success "${PHPENV_ROOT}/version"
 }
 
-@test "detects RBENV_VERSION" {
-  RBENV_VERSION=1 run rbenv-version-origin
-  assert_success "RBENV_VERSION environment variable"
+@test "detects PHPENV_VERSION" {
+  PHPENV_VERSION=1 run phpenv-version-origin
+  assert_success "PHPENV_VERSION environment variable"
 }
 
 @test "detects local file" {
-  touch .ruby-version
-  run rbenv-version-origin
-  assert_success "${PWD}/.ruby-version"
+  touch .php-version
+  run phpenv-version-origin
+  assert_success "${PWD}/.php-version"
 }
 
 @test "detects alternate version file" {
-  touch .rbenv-version
-  run rbenv-version-origin
-  assert_success "${PWD}/.rbenv-version"
+  touch .phpenv-version
+  run phpenv-version-origin
+  assert_success "${PWD}/.phpenv-version"
 }
 
 @test "reports from hook" {
-  mkdir -p "${RBENV_ROOT}/rbenv.d/version-origin"
-  cat > "${RBENV_ROOT}/rbenv.d/version-origin/test.bash" <<HOOK
-RBENV_VERSION_ORIGIN=plugin
+  mkdir -p "${PHPENV_ROOT}/phpenv.d/version-origin"
+  cat > "${PHPENV_ROOT}/phpenv.d/version-origin/test.bash" <<HOOK
+PHPENV_VERSION_ORIGIN=plugin
 HOOK
 
-  RBENV_VERSION=1 RBENV_HOOK_PATH="${RBENV_ROOT}/rbenv.d" run rbenv-version-origin
+  PHPENV_VERSION=1 PHPENV_HOOK_PATH="${PHPENV_ROOT}/phpenv.d" run phpenv-version-origin
   assert_success "plugin"
 }
 
-@test "doesn't inherit RBENV_VERSION_ORIGIN from environment" {
-  RBENV_VERSION_ORIGIN=ignored run rbenv-version-origin
-  assert_success "${RBENV_ROOT}/version"
+@test "doesn't inherit PHPENV_VERSION_ORIGIN from environment" {
+  PHPENV_VERSION_ORIGIN=ignored run phpenv-version-origin
+  assert_success "${PHPENV_ROOT}/version"
 }
diff --git a/test/version.bats b/test/version.bats
index 886d0ef..2066008 100644
--- a/test/version.bats
+++ b/test/version.bats
@@ -3,36 +3,36 @@
 load test_helper
 
 create_version() {
-  mkdir -p "${RBENV_ROOT}/versions/$1"
+  mkdir -p "${PHPENV_ROOT}/versions/$1"
 }
 
 setup() {
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
 }
 
 @test "no version selected" {
-  assert [ ! -d "${RBENV_ROOT}/versions" ]
-  run rbenv-version
-  assert_success "system (set by ${RBENV_ROOT}/version)"
+  assert [ ! -d "${PHPENV_ROOT}/versions" ]
+  run phpenv-version
+  assert_success "system (set by ${PHPENV_ROOT}/version)"
 }
 
-@test "set by RBENV_VERSION" {
-  create_version "1.9.3"
-  RBENV_VERSION=1.9.3 run rbenv-version
-  assert_success "1.9.3 (set by RBENV_VERSION environment variable)"
+@test "set by PHPENV_VERSION" {
+  create_version "7.1.23"
+  PHPENV_VERSION=7.1.23 run phpenv-version
+  assert_success "7.1.23 (set by PHPENV_VERSION environment variable)"
 }
 
 @test "set by local file" {
-  create_version "1.9.3"
-  cat > ".ruby-version" <<<"1.9.3"
-  run rbenv-version
-  assert_success "1.9.3 (set by ${PWD}/.ruby-version)"
+  create_version "7.1.23"
+  cat > ".php-version" <<<"7.1.23"
+  run phpenv-version
+  assert_success "7.1.23 (set by ${PWD}/.php-version)"
 }
 
 @test "set by global file" {
-  create_version "1.9.3"
-  cat > "${RBENV_ROOT}/version" <<<"1.9.3"
-  run rbenv-version
-  assert_success "1.9.3 (set by ${RBENV_ROOT}/version)"
+  create_version "7.1.23"
+  cat > "${PHPENV_ROOT}/version" <<<"7.1.23"
+  run phpenv-version
+  assert_success "7.1.23 (set by ${PHPENV_ROOT}/version)"
 }
diff --git a/test/versions.bats b/test/versions.bats
index 3273b37..0bada65 100644
--- a/test/versions.bats
+++ b/test/versions.bats
@@ -3,154 +3,154 @@
 load test_helper
 
 create_version() {
-  mkdir -p "${RBENV_ROOT}/versions/$1"
+  mkdir -p "${PHPENV_ROOT}/versions/$1"
 }
 
 setup() {
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
 }
 
-stub_system_ruby() {
-  local stub="${RBENV_TEST_DIR}/bin/ruby"
+stub_system_php() {
+  local stub="${PHPENV_TEST_DIR}/bin/php"
   mkdir -p "$(dirname "$stub")"
   touch "$stub" && chmod +x "$stub"
 }
 
 @test "no versions installed" {
-  stub_system_ruby
-  assert [ ! -d "${RBENV_ROOT}/versions" ]
-  run rbenv-versions
-  assert_success "* system (set by ${RBENV_ROOT}/version)"
+  stub_system_php
+  assert [ ! -d "${PHPENV_ROOT}/versions" ]
+  run phpenv-versions
+  assert_success "* system (set by ${PHPENV_ROOT}/version)"
 }
 
-@test "not even system ruby available" {
-  PATH="$(path_without ruby)" run rbenv-versions
+@test "not even system php available" {
+  PATH="$(path_without php)" run phpenv-versions
   assert_failure
-  assert_output "Warning: no Ruby detected on the system"
+  assert_output "Warning: no PHP detected on the system"
 }
 
 @test "bare output no versions installed" {
-  assert [ ! -d "${RBENV_ROOT}/versions" ]
-  run rbenv-versions --bare
+  assert [ ! -d "${PHPENV_ROOT}/versions" ]
+  run phpenv-versions --bare
   assert_success ""
 }
 
 @test "single version installed" {
-  stub_system_ruby
-  create_version "1.9"
-  run rbenv-versions
+  stub_system_php
+  create_version "7.1"
+  run phpenv-versions
   assert_success
   assert_output <<OUT
-* system (set by ${RBENV_ROOT}/version)
-  1.9
+* system (set by ${PHPENV_ROOT}/version)
+  7.1
 OUT
 }
 
 @test "single version bare" {
-  create_version "1.9"
-  run rbenv-versions --bare
-  assert_success "1.9"
+  create_version "7.1"
+  run phpenv-versions --bare
+  assert_success "7.1"
 }
 
 @test "multiple versions" {
-  stub_system_ruby
-  create_version "1.8.7"
-  create_version "1.9.3"
-  create_version "2.0.0"
-  run rbenv-versions
+  stub_system_php
+  create_version "7.0.32"
+  create_version "7.1.23"
+  create_version "7.2.0"
+  run phpenv-versions
   assert_success
   assert_output <<OUT
-* system (set by ${RBENV_ROOT}/version)
-  1.8.7
-  1.9.3
-  2.0.0
+* system (set by ${PHPENV_ROOT}/version)
+  7.0.32
+  7.1.23
+  7.2.0
 OUT
 }
 
 @test "indicates current version" {
-  stub_system_ruby
-  create_version "1.9.3"
-  create_version "2.0.0"
-  RBENV_VERSION=1.9.3 run rbenv-versions
+  stub_system_php
+  create_version "7.1.23"
+  create_version "7.2.0"
+  PHPENV_VERSION=7.1.23 run phpenv-versions
   assert_success
   assert_output <<OUT
   system
-* 1.9.3 (set by RBENV_VERSION environment variable)
-  2.0.0
+* 7.1.23 (set by PHPENV_VERSION environment variable)
+  7.2.0
 OUT
 }
 
 @test "bare doesn't indicate current version" {
-  create_version "1.9.3"
-  create_version "2.0.0"
-  RBENV_VERSION=1.9.3 run rbenv-versions --bare
+  create_version "7.1.23"
+  create_version "7.2.0"
+  PHPENV_VERSION=7.1.23 run phpenv-versions --bare
   assert_success
   assert_output <<OUT
-1.9.3
-2.0.0
+7.1.23
+7.2.0
 OUT
 }
 
 @test "globally selected version" {
-  stub_system_ruby
-  create_version "1.9.3"
-  create_version "2.0.0"
-  cat > "${RBENV_ROOT}/version" <<<"1.9.3"
-  run rbenv-versions
+  stub_system_php
+  create_version "7.1.23"
+  create_version "7.2.0"
+  cat > "${PHPENV_ROOT}/version" <<<"7.1.23"
+  run phpenv-versions
   assert_success
   assert_output <<OUT
   system
-* 1.9.3 (set by ${RBENV_ROOT}/version)
-  2.0.0
+* 7.1.23 (set by ${PHPENV_ROOT}/version)
+  7.2.0
 OUT
 }
 
 @test "per-project version" {
-  stub_system_ruby
-  create_version "1.9.3"
-  create_version "2.0.0"
-  cat > ".ruby-version" <<<"1.9.3"
-  run rbenv-versions
+  stub_system_php
+  create_version "7.1.23"
+  create_version "7.2.0"
+  cat > ".php-version" <<<"7.1.23"
+  run phpenv-versions
   assert_success
   assert_output <<OUT
   system
-* 1.9.3 (set by ${RBENV_TEST_DIR}/.ruby-version)
-  2.0.0
+* 7.1.23 (set by ${PHPENV_TEST_DIR}/.php-version)
+  7.2.0
 OUT
 }
 
 @test "ignores non-directories under versions" {
-  create_version "1.9"
-  touch "${RBENV_ROOT}/versions/hello"
+  create_version "7.1"
+  touch "${PHPENV_ROOT}/versions/hello"
 
-  run rbenv-versions --bare
-  assert_success "1.9"
+  run phpenv-versions --bare
+  assert_success "7.1"
 }
 
 @test "lists symlinks under versions" {
-  create_version "1.8.7"
-  ln -s "1.8.7" "${RBENV_ROOT}/versions/1.8"
+  create_version "7.0.32"
+  ln -s "7.0.32" "${PHPENV_ROOT}/versions/7.0"
 
-  run rbenv-versions --bare
+  run phpenv-versions --bare
   assert_success
   assert_output <<OUT
-1.8
-1.8.7
+7.0
+7.0.32
 OUT
 }
 
 @test "doesn't list symlink aliases when --skip-aliases" {
-  create_version "1.8.7"
-  ln -s "1.8.7" "${RBENV_ROOT}/versions/1.8"
+  create_version "7.0.32"
+  ln -s "7.0.32" "${PHPENV_ROOT}/versions/7.0"
   mkdir moo
-  ln -s "${PWD}/moo" "${RBENV_ROOT}/versions/1.9"
+  ln -s "${PWD}/moo" "${PHPENV_ROOT}/versions/7.1"
 
-  run rbenv-versions --bare --skip-aliases
+  run phpenv-versions --bare --skip-aliases
   assert_success
 
   assert_output <<OUT
-1.8.7
-1.9
+7.0.32
+7.1
 OUT
 }
diff --git a/test/whence.bats b/test/whence.bats
index 317f89e..3b1ec11 100644
--- a/test/whence.bats
+++ b/test/whence.bats
@@ -3,28 +3,28 @@
 load test_helper
 
 create_executable() {
-  local bin="${RBENV_ROOT}/versions/${1}/bin"
+  local bin="${PHPENV_ROOT}/versions/${1}/bin"
   mkdir -p "$bin"
   touch "${bin}/$2"
   chmod +x "${bin}/$2"
 }
 
 @test "finds versions where present" {
-  create_executable "1.8" "ruby"
-  create_executable "1.8" "rake"
-  create_executable "2.0" "ruby"
-  create_executable "2.0" "rspec"
+  create_executable "7.0" "php"
+  create_executable "7.0" "php-cgi"
+  create_executable "7.2" "php"
+  create_executable "7.2" "phpdbg"
 
-  run rbenv-whence ruby
+  run phpenv-whence php
   assert_success
   assert_output <<OUT
-1.8
-2.0
+7.0
+7.2
 OUT
 
-  run rbenv-whence rake
-  assert_success "1.8"
+  run phpenv-whence php-cgi
+  assert_success "7.0"
 
-  run rbenv-whence rspec
-  assert_success "2.0"
+  run phpenv-whence phpdbg
+  assert_success "7.2"
 }
diff --git a/test/which.bats b/test/which.bats
index 004852f..0f8f03a 100644
--- a/test/which.bats
+++ b/test/which.bats
@@ -5,7 +5,7 @@ load test_helper
 create_executable() {
   local bin
   if [[ $1 == */* ]]; then bin="$1"
-  else bin="${RBENV_ROOT}/versions/${1}/bin"
+  else bin="${PHPENV_ROOT}/versions/${1}/bin"
   fi
   mkdir -p "$bin"
   touch "${bin}/$2"
@@ -13,95 +13,95 @@ create_executable() {
 }
 
 @test "outputs path to executable" {
-  create_executable "1.8" "ruby"
-  create_executable "2.0" "rspec"
+  create_executable "7.0" "php"
+  create_executable "7.2" "phpdbg"
 
-  RBENV_VERSION=1.8 run rbenv-which ruby
-  assert_success "${RBENV_ROOT}/versions/1.8/bin/ruby"
+  PHPENV_VERSION=7.0 run phpenv-which php
+  assert_success "${PHPENV_ROOT}/versions/7.0/bin/php"
 
-  RBENV_VERSION=2.0 run rbenv-which rspec
-  assert_success "${RBENV_ROOT}/versions/2.0/bin/rspec"
+  PHPENV_VERSION=7.2 run phpenv-which phpdbg
+  assert_success "${PHPENV_ROOT}/versions/7.2/bin/phpdbg"
 }
 
 @test "searches PATH for system version" {
-  create_executable "${RBENV_TEST_DIR}/bin" "kill-all-humans"
-  create_executable "${RBENV_ROOT}/shims" "kill-all-humans"
+  create_executable "${PHPENV_TEST_DIR}/bin" "kill-all-humans"
+  create_executable "${PHPENV_ROOT}/shims" "kill-all-humans"
 
-  RBENV_VERSION=system run rbenv-which kill-all-humans
-  assert_success "${RBENV_TEST_DIR}/bin/kill-all-humans"
+  PHPENV_VERSION=system run phpenv-which kill-all-humans
+  assert_success "${PHPENV_TEST_DIR}/bin/kill-all-humans"
 }
 
 @test "searches PATH for system version (shims prepended)" {
-  create_executable "${RBENV_TEST_DIR}/bin" "kill-all-humans"
-  create_executable "${RBENV_ROOT}/shims" "kill-all-humans"
+  create_executable "${PHPENV_TEST_DIR}/bin" "kill-all-humans"
+  create_executable "${PHPENV_ROOT}/shims" "kill-all-humans"
 
-  PATH="${RBENV_ROOT}/shims:$PATH" RBENV_VERSION=system run rbenv-which kill-all-humans
-  assert_success "${RBENV_TEST_DIR}/bin/kill-all-humans"
+  PATH="${PHPENV_ROOT}/shims:$PATH" PHPENV_VERSION=system run phpenv-which kill-all-humans
+  assert_success "${PHPENV_TEST_DIR}/bin/kill-all-humans"
 }
 
 @test "searches PATH for system version (shims appended)" {
-  create_executable "${RBENV_TEST_DIR}/bin" "kill-all-humans"
-  create_executable "${RBENV_ROOT}/shims" "kill-all-humans"
+  create_executable "${PHPENV_TEST_DIR}/bin" "kill-all-humans"
+  create_executable "${PHPENV_ROOT}/shims" "kill-all-humans"
 
-  PATH="$PATH:${RBENV_ROOT}/shims" RBENV_VERSION=system run rbenv-which kill-all-humans
-  assert_success "${RBENV_TEST_DIR}/bin/kill-all-humans"
+  PATH="$PATH:${PHPENV_ROOT}/shims" PHPENV_VERSION=system run phpenv-which kill-all-humans
+  assert_success "${PHPENV_TEST_DIR}/bin/kill-all-humans"
 }
 
 @test "searches PATH for system version (shims spread)" {
-  create_executable "${RBENV_TEST_DIR}/bin" "kill-all-humans"
-  create_executable "${RBENV_ROOT}/shims" "kill-all-humans"
+  create_executable "${PHPENV_TEST_DIR}/bin" "kill-all-humans"
+  create_executable "${PHPENV_ROOT}/shims" "kill-all-humans"
 
-  PATH="${RBENV_ROOT}/shims:${RBENV_ROOT}/shims:/tmp/non-existent:$PATH:${RBENV_ROOT}/shims" \
-    RBENV_VERSION=system run rbenv-which kill-all-humans
-  assert_success "${RBENV_TEST_DIR}/bin/kill-all-humans"
+  PATH="${PHPENV_ROOT}/shims:${PHPENV_ROOT}/shims:/tmp/non-existent:$PATH:${PHPENV_ROOT}/shims" \
+    PHPENV_VERSION=system run phpenv-which kill-all-humans
+  assert_success "${PHPENV_TEST_DIR}/bin/kill-all-humans"
 }
 
 @test "doesn't include current directory in PATH search" {
   export PATH="$(path_without "kill-all-humans")"
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
   touch kill-all-humans
   chmod +x kill-all-humans
-  RBENV_VERSION=system run rbenv-which kill-all-humans
-  assert_failure "rbenv: kill-all-humans: command not found"
+  PHPENV_VERSION=system run phpenv-which kill-all-humans
+  assert_failure "phpenv: kill-all-humans: command not found"
 }
 
 @test "version not installed" {
-  create_executable "2.0" "rspec"
-  RBENV_VERSION=1.9 run rbenv-which rspec
-  assert_failure "rbenv: version \`1.9' is not installed (set by RBENV_VERSION environment variable)"
+  create_executable "7.2" "phpdbg"
+  PHPENV_VERSION=7.1 run phpenv-which phpdbg
+  assert_failure "phpenv: version \`7.1' is not installed (set by PHPENV_VERSION environment variable)"
 }
 
 @test "no executable found" {
-  create_executable "1.8" "rspec"
-  RBENV_VERSION=1.8 run rbenv-which rake
-  assert_failure "rbenv: rake: command not found"
+  create_executable "7.0" "phpdbg"
+  PHPENV_VERSION=7.0 run phpenv-which php-cgi
+  assert_failure "phpenv: php-cgi: command not found"
 }
 
 @test "no executable found for system version" {
-  export PATH="$(path_without "rake")"
-  RBENV_VERSION=system run rbenv-which rake
-  assert_failure "rbenv: rake: command not found"
+  export PATH="$(path_without "php-cgi")"
+  PHPENV_VERSION=system run phpenv-which php-cgi
+  assert_failure "phpenv: php-cgi: command not found"
 }
 
 @test "executable found in other versions" {
-  create_executable "1.8" "ruby"
-  create_executable "1.9" "rspec"
-  create_executable "2.0" "rspec"
+  create_executable "7.0" "php"
+  create_executable "7.1" "phpdbg"
+  create_executable "7.2" "phpdbg"
 
-  RBENV_VERSION=1.8 run rbenv-which rspec
+  PHPENV_VERSION=7.0 run phpenv-which phpdbg
   assert_failure
   assert_output <<OUT
-rbenv: rspec: command not found
+phpenv: phpdbg: command not found
 
-The \`rspec' command exists in these Ruby versions:
-  1.9
-  2.0
+The \`phpdbg' command exists in these PHP versions:
+  7.1
+  7.2
 OUT
 }
 
 @test "carries original IFS within hooks" {
-  hook_path="${RBENV_TEST_DIR}/rbenv.d"
+  hook_path="${PHPENV_TEST_DIR}/phpenv.d"
   mkdir -p "${hook_path}/which"
   cat > "${hook_path}/which/hello.bash" <<SH
 hellos=(\$(printf "hello\\tugly world\\nagain"))
@@ -109,19 +109,19 @@ echo HELLO="\$(printf ":%s" "\${hellos[@]}")"
 exit
 SH
 
-  RBENV_HOOK_PATH="$hook_path" IFS=$' \t\n' RBENV_VERSION=system run rbenv-which anything
+  PHPENV_HOOK_PATH="$hook_path" IFS=$' \t\n' PHPENV_VERSION=system run phpenv-which anything
   assert_success
   assert_output "HELLO=:hello:ugly:world:again"
 }
 
-@test "discovers version from rbenv-version-name" {
-  mkdir -p "$RBENV_ROOT"
-  cat > "${RBENV_ROOT}/version" <<<"1.8"
-  create_executable "1.8" "ruby"
+@test "discovers version from phpenv-version-name" {
+  mkdir -p "$PHPENV_ROOT"
+  cat > "${PHPENV_ROOT}/version" <<<"7.0"
+  create_executable "7.0" "php"
 
-  mkdir -p "$RBENV_TEST_DIR"
-  cd "$RBENV_TEST_DIR"
+  mkdir -p "$PHPENV_TEST_DIR"
+  cd "$PHPENV_TEST_DIR"
 
-  RBENV_VERSION= run rbenv-which ruby
-  assert_success "${RBENV_ROOT}/versions/1.8/bin/ruby"
+  PHPENV_VERSION= run phpenv-which php
+  assert_success "${PHPENV_ROOT}/versions/7.0/bin/php"
 }