test(refactor): switch to bashunit and start fleshing out a new test suite

.env

@@ -0,0 +1 @@
+BASHUNIT_BOOTSTRAP=tests/bootstrap.sh

.gitignore

@@ -1,3 +1,4 @@
-test-runner.sh
+test-legacy/test-runner.sh
-test/assert.sh
+test-legacy/assert.sh
-test/stub.sh
+test-legacy/stub.sh
+test/bashunit

AGENTS.md

@@ -0,0 +1,150 @@
+# AGENTS.md
+
+This file provides guidance to AI Agents when working with code in this
+repository.
+
+## Project Overview
+
+Tmuxifier is a shell-based tool for creating and managing complex Tmux session
+and window layouts. Users write layout files as shell scripts that use tmux
+commands and helper functions to define session/window configurations.
+
+## Architecture
+
+### Core Components
+
+- **bin/tmuxifier**: Main executable that bootstraps the environment, validates
+  Tmux version (≥1.6), and dispatches to libexec commands
+- **libexec/**: Command implementations (tmuxifier-*, e.g.,
+  tmuxifier-load-session, tmuxifier-new-window)
+- **lib/layout-helpers.sh**: Helper functions available within layout files
+  (new_window, split_v, split_h, run_cmd, select_pane, etc.)
+- **lib/runtime.sh**: Runtime environment loader sourced by layout files
+- **lib/env.sh**: Sets up TMUXIFIER_LAYOUT_PATH (defaults to $TMUXIFIER/layouts)
+- **templates/**: Templates for new session.sh and window.sh layout files
+- **examples/**: Example layout files demonstrating usage
+
+### Layout File Types
+
+**Session layouts** (*.session.sh):
+
+- Define entire Tmux sessions with multiple windows
+- Must call `initialize_session` to create the session
+- Can load window layouts via `load_window` or define windows inline
+- Must call `finalize_and_go_to_session` at the end
+- Can set `session_root` for default directory
+
+**Window layouts** (*.window.sh):
+
+- Define single window configurations with panes
+- Loaded into existing sessions or from session layouts
+- Can set `window_root` for window-specific directory
+- Use helper functions to split panes and run commands
+
+### Key Concepts
+
+- Layout files are executed as shell scripts with lib/layout-helpers.sh sourced
+- Helper functions wrap tmux commands, managing session/window context
+- The `tmux` command itself is aliased to tmuxifier-tmux wrapper
+- Session creation moves default window to position 999, then kills it in
+  finalize_and_go_to_session
+- TMUXIFIER_TMUX_OPTS allows passing custom arguments to tmux
+
+## Development Commands
+
+### Testing
+
+Tests use [bashunit](https://github.com/TypedDevs/bashunit) framework. Use
+deepwiki MCP tool to lookup bashunit documentation if needed.
+
+```bash
+make test                                  # Run all tests
+make test FILE=tests/lib/util/foo_test.sh  # Run a single test file
+make bootstrap                             # Fetch test dependencies
+```
+
+Tests are located in `tests/` directory and follow bashunit conventions. Test
+files are named `*_test.sh`.
+
+Legacy tests in `test-legacy/` use test-runner.sh framework with assert.sh and
+stub.sh libraries. Run with `make test-legacy`.
+
+### Manual Testing
+
+```bash
+# Create and load a test window layout
+./bin/tmuxifier new-window test-window
+./bin/tmuxifier load-window test-window
+
+# Create and load a test session layout
+./bin/tmuxifier new-session test-session
+./bin/tmuxifier load-session test-session
+
+# List available layouts
+./bin/tmuxifier list-sessions
+./bin/tmuxifier list-windows
+```
+
+## Code Style
+
+- Shell scripts follow Bash conventions
+- 2-space indentation
+- Functions document arguments in comments
+- Use local variables for function scope
+- Prefer `[ ]` over `[[ ]]` for basic tests
+- Command substitution uses `$()` not backticks
+
+## Important Implementation Details
+
+### Helper Function Pattern
+
+Helper functions in lib/layout-helpers.sh follow this pattern:
+
+```bash
+function_name() {
+  # Parse optional arguments
+  if [ -n "$1" ]; then local arg=(-flag "$1"); fi
+
+  # Execute tmux command with session/window context
+  tmuxifier-tmux command -t "$session:$window" "${arg[@]}"
+
+  # Update state if needed
+  __go_to_window_or_session_path
+}
+```
+
+### Tmux Version Handling
+
+Code must support Tmux 1.6+. Version-specific behavior uses
+tmuxifier-tmux-version comparisons:
+
+```bash
+if [ "$(tmuxifier-tmux-version "1.9")" == "<" ]; then
+  # Tmux 1.8 and earlier
+else
+  # Tmux 1.9 and later
+fi
+```
+
+### Path Expansion
+
+Use `__expand_path` to handle ~ and variables in paths:
+
+```bash
+session_root() {
+  local dir="$(__expand_path $@)"
+  if [ -d "$dir" ]; then
+    session_root="$dir"
+  fi
+}
+```
+
+## Environment Variables
+
+- **TMUXIFIER**: Set to installation directory (auto-detected from bin location)
+- **TMUXIFIER_LAYOUT_PATH**: Custom layouts directory (default:
+  $TMUXIFIER/layouts)
+- **TMUXIFIER_TMUX_OPTS**: Custom arguments passed to tmux
+- **TMUXIFIER_TMUX_ITERM_ATTACH**: Set to "-CC" for iTerm2 integration
+- **TMUXIFIER_NO_COMPLETE**: Disable shell completion if set
+- **TMUXIFIER_MIN_TMUX_VERSION**: Minimum required Tmux version (1.6)

CLAUDE.md

@@ -0,0 +1 @@
+./AGENTS.md

Makefile

@@ -1,50 +1,43 @@
+FETCHED_FILES :=
+
+# $(1) = local file path, $(2) = remote URL, $(3) = optional post-curl command
+define FETCH_FILE
+FETCHED_FILES += $(1)
+
+$(1):
+	echo "fetching $(1)..." && \
+	mkdir -p $(dir $(1)) && \
+	curl -s -L -o $(1) $(2)$(if $(3), && $(3),)
+
+remove_$(1):
+	test -f "$(1)" && rm "$(1)" && echo "removed $(1)" || true
+
+update_$(1): remove_$(1) $(1)
+endef
+
+$(eval $(call FETCH_FILE,tests/bashunit,\
+	https://github.com/TypedDevs/bashunit/releases/download/0.26.0/bashunit,\
+	chmod +x tests/bashunit))
+
+$(eval $(call FETCH_FILE,test-legacy/test-runner.sh,\
+	https://github.com/jimeh/test-runner.sh/raw/v0.2.0/test-runner.sh,\
+	chmod +x test-legacy/test-runner.sh))
+$(eval $(call FETCH_FILE,test-legacy/assert.sh,\
+	https://raw.github.com/lehmannro/assert.sh/v1.0.2/assert.sh))
+$(eval $(call FETCH_FILE,test-legacy/stub.sh,\
+	https://raw.github.com/jimeh/stub.sh/v1.0.1/stub.sh))
+
 test: bootstrap
-	./test-runner.sh
+	./tests/bashunit $(FILE)
 
-bootstrap: test-runner.sh test/assert.sh test/stub.sh
+test-legacy: bootstrap
-clean: remove_test-runner.sh remove_test/assert.sh remove_test/stub.sh
+	./test-legacy/test-runner.sh $(FILE)
-update: update_test-runner.sh update_test/assert.sh update_test/stub.sh
 
-test-runner.sh:
+bootstrap: $(FETCHED_FILES)
-	echo "fetching test-runner.sh..." && \
+clean: $(addprefix remove_,$(FETCHED_FILES))
-	curl -s -L -o test-runner.sh \
+update: $(addprefix update_,$(FETCHED_FILES))
-		https://github.com/jimeh/test-runner.sh/raw/v0.2.0/test-runner.sh && \
-	chmod +x test-runner.sh
-
-remove_test-runner.sh:
-	( \
-		test -f "test-runner.sh" && rm "test-runner.sh" && \
-		echo "removed test-runner.sh"\
-	) || exit 0
-
-update_test-runner.sh: remove_test-runner.sh test-runner.sh
-
-test/assert.sh:
-	echo "fetching test/assert.sh..." && \
-	curl -s -L -o test/assert.sh \
-		https://raw.github.com/lehmannro/assert.sh/v1.0.2/assert.sh
-
-remove_test/assert.sh:
-	test -f "test/assert.sh" && \
-		rm "test/assert.sh" && \
-		echo "removed test/assert.sh"
-
-update_test/assert.sh: remove_test/assert.sh test/assert.sh
-
-test/stub.sh:
-	echo "fetching test/stub.sh..." && \
-	curl -s -L -o test/stub.sh \
-		https://raw.github.com/jimeh/stub.sh/v1.0.1/stub.sh
-
-remove_test/stub.sh:
-	test -f "test/stub.sh" && \
-		rm "test/stub.sh" && \
-		echo "removed test/stub.sh"
-
-update_test/stub.sh: remove_test/stub.sh test/stub.sh
 
 .SILENT:
-.PHONY: test bootstrap clean \
+.PHONY: test bootstrap clean update \
-	remove_test-runner.sh update_test-runner.sh \
+	$(addprefix remove_,$(FETCHED_FILES)) \
-	remove_test/assert.sh update_test/assert.sh \
+	$(addprefix update_,$(FETCHED_FILES))
-	remove_test/stub.sh   update_test/stub.sh

lib/layout-helpers.sh

@@ -300,7 +300,7 @@ initialize_session() {
   # Tmux 1.8 and earlier.
   if [ "$(tmuxifier-tmux-version "1.9")" == "<" ]; then
     # Create the new session.
-    env TMUX="" tmuxifier-tmux new-session -d -s "$session"
+    TMUX="" tmuxifier-tmux new-session -d -s "$session"
 
     # Set default-path for session
     if [ -n "$session_root" ] && [ -d "$session_root" ]; then
@@ -317,7 +317,7 @@ initialize_session() {
       local session_args=(-c "$session_root")
     fi
 
-    env TMUX="" tmuxifier-tmux new-session \
+    TMUX="" tmuxifier-tmux new-session \
       -d -s "$session" "${session_args[@]}"
   fi
 
@@ -362,7 +362,7 @@ finalize_and_go_to_session() {
 #   /Users/jimeh/Projects
 #
 __expand_path() {
-  echo $(eval echo "$@")
+  eval echo "$*"
 }
 
 __get_first_window_index() {

lib/util.sh

@@ -1,11 +1,79 @@
+# Check if --help or -h flag is present in arguments.
+#
+# Usage:
+#   calling-help "$@" && { show_help; exit 0; }
+#
+# Arguments:
+#   $@ - Command-line arguments to check
+#
+# Returns:
+#   0 - If --help or -h is present as a standalone argument
+#   1 - Otherwise
 calling-help() {
   if [[ " $* " != *" --help "* ]] && [[ " $* " != *" -h "* ]]; then
     return 1
   fi
 }
 
+# Check if --complete flag is present in arguments.
+#
+# Used to detect when shell completion is requesting completions.
+#
+# Usage:
+#   calling-complete "$@" && { generate_completions; exit 0; }
+#
+# Arguments:
+#   $@ - Command-line arguments to check
+#
+# Returns:
+#   0 - If --complete is present as a standalone argument
+#   1 - Otherwise
 calling-complete() {
   if [[ " $* " != *" --complete "* ]]; then
     return 1
   fi
 }
+
+# Compare two dot-separated version strings.
+#
+# Based on: http://stackoverflow.com/a/4025065/42146
+#
+# Usage:
+#   vercomp "1.9.0" "1.10.0"
+#   case $? in
+#     0) echo "equal" ;;
+#     1) echo "first is greater" ;;
+#     2) echo "second is greater" ;;
+#   esac
+#
+# Arguments:
+#   $1 - First version string (e.g., "1.2.3")
+#   $2 - Second version string (e.g., "1.2.4")
+#
+# Returns:
+#   0 - Versions are equal
+#   1 - First version is greater than second
+#   2 - First version is less than second
+vercomp() {
+  if [[ "$1" == "$2" ]]; then return 0; fi
+
+  local IFS=. i
+  local -a ver1 ver2
+  read -ra ver1 <<< "$1"
+  read -ra ver2 <<< "$2"
+
+  # Fill empty fields in ver1 with zeros
+  for ((i = ${#ver1[@]}; i < ${#ver2[@]}; i++)); do ver1[i]=0; done
+
+  for ((i = 0; i < ${#ver1[@]}; i++)); do
+    # Fill empty fields in ver2 with zeros
+    if [[ -z ${ver2[i]} ]]; then ver2[i]=0; fi
+
+    if ((10#${ver1[i]} > 10#${ver2[i]})); then
+      return 1
+    elif ((10#${ver1[i]} < 10#${ver2[i]})); then
+      return 2
+    fi
+  done
+  return 0
+}

libexec/tmuxifier-tmux-version

@@ -17,30 +17,6 @@ The three possible outputs are \"=\", \"<\", and \">\"."
   exit
 fi
 
-# The vercomp() function is shamelessly ripped/borrowed from the following
-# StackOverflow answer: http://stackoverflow.com/a/4025065/42146
-vercomp() {
-  if [[ $1 == $2 ]]; then return 0; fi
-
-  local IFS=.
-  local i ver1=($1) ver2=($2)
-
-  # fill empty fields in ver1 with zeros
-  for ((i = ${#ver1[@]}; i < ${#ver2[@]}; i++)); do ver1[i]=0; done
-
-  for ((i = 0; i < ${#ver1[@]}; i++)); do
-    # fill empty fields in ver2 with zeros
-    if [[ -z ${ver2[i]} ]]; then ver2[i]=0; fi
-
-    if ((10#${ver1[i]} > 10#${ver2[i]})); then
-      return 1
-    elif ((10#${ver1[i]} < 10#${ver2[i]})); then
-      return 2
-    fi
-  done
-  return 0
-}
-
 version=$(tmux -V)
 version=${version/tmux /}
 

test-legacy/lib/layout-helpers/split_h.test.sh

@@ -0,0 +1,70 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# split_h() tests.
+#
+
+# When called without arguments, calls tmuxifier-tmux split-window with -h flag.
+session="test-session"
+window="0"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_h
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test-session:0. -h" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with percentage argument, includes -p flag.
+session="test-session"
+window="0"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_h 30
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test-session:0. -h -p 30" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with percentage and target pane, targets that pane.
+session="mysession"
+window="2"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_h 50 1
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t mysession:2.1 -h -p 50" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with only target pane (empty percentage), targets that pane.
+session="test"
+window="1"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_h "" 2
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test:1.2 -h" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# Integration: actually splits pane in tmux session.
+create-test-session
+window="0"
+stub __go_to_window_or_session_path
+assert "test-socket-pane-count" "1"
+split_h
+assert "test-socket-pane-count" "2"
+split_h 30
+assert "test-socket-pane-count" "3"
+restore __go_to_window_or_session_path
+kill-test-session
+
+# End of tests.
+assert_end "split_h()"

test-legacy/lib/layout-helpers/split_hl.test.sh

@@ -0,0 +1,70 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# split_hl() tests.
+#
+
+# When called without arguments, calls tmuxifier-tmux split-window with -h flag.
+session="test-session"
+window="0"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_hl
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test-session:0. -h" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with column count argument, includes -l flag.
+session="test-session"
+window="0"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_hl 20
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test-session:0. -h -l 20" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with column count and target pane, targets that pane.
+session="mysession"
+window="2"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_hl 25 1
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t mysession:2.1 -h -l 25" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with only target pane (empty column count), targets that pane.
+session="test"
+window="1"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_hl "" 2
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test:1.2 -h" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# Integration: actually splits pane in tmux session.
+create-test-session
+window="0"
+stub __go_to_window_or_session_path
+assert "test-socket-pane-count" "1"
+split_hl
+assert "test-socket-pane-count" "2"
+split_hl 10
+assert "test-socket-pane-count" "3"
+restore __go_to_window_or_session_path
+kill-test-session
+
+# End of tests.
+assert_end "split_hl()"

test-legacy/lib/layout-helpers/split_v.test.sh

@@ -0,0 +1,70 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# split_v() tests.
+#
+
+# When called without arguments, calls tmuxifier-tmux split-window with -v flag.
+session="test-session"
+window="0"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_v
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test-session:0. -v" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with percentage argument, includes -p flag.
+session="test-session"
+window="0"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_v 30
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test-session:0. -v -p 30" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with percentage and target pane, targets that pane.
+session="mysession"
+window="2"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_v 50 1
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t mysession:2.1 -v -p 50" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with only target pane (empty percentage), targets that pane.
+session="test"
+window="1"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_v "" 2
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test:1.2 -v" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# Integration: actually splits pane in tmux session.
+create-test-session
+window="0"
+stub __go_to_window_or_session_path
+assert "test-socket-pane-count" "1"
+split_v
+assert "test-socket-pane-count" "2"
+split_v 30
+assert "test-socket-pane-count" "3"
+restore __go_to_window_or_session_path
+kill-test-session
+
+# End of tests.
+assert_end "split_v()"

test-legacy/lib/layout-helpers/split_vl.test.sh

@@ -0,0 +1,70 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# split_vl() tests.
+#
+
+# When called without arguments, calls tmuxifier-tmux split-window with -v flag.
+session="test-session"
+window="0"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_vl
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test-session:0. -v" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with line count argument, includes -l flag.
+session="test-session"
+window="0"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_vl 10
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test-session:0. -v -l 10" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with line count and target pane, targets that pane.
+session="mysession"
+window="2"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_vl 15 1
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t mysession:2.1 -v -l 15" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# When called with only target pane (empty line count), targets that pane.
+session="test"
+window="1"
+stub tmuxifier-tmux
+stub __go_to_window_or_session_path
+split_vl "" 2
+assert_raises \
+  "stub_called_with tmuxifier-tmux split-window -t test:1.2 -v" 0
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+restore tmuxifier-tmux
+
+# Integration: actually splits pane in tmux session.
+create-test-session
+window="0"
+stub __go_to_window_or_session_path
+assert "test-socket-pane-count" "1"
+split_vl
+assert "test-socket-pane-count" "2"
+split_vl 5
+assert "test-socket-pane-count" "3"
+restore __go_to_window_or_session_path
+kill-test-session
+
+# End of tests.
+assert_end "split_vl()"

test-legacy/libexec/tmuxifier-tmux.test.sh

@@ -7,12 +7,12 @@ source "${root}/lib/util.sh"
 #
 
 # Setup.
-libexec="${root}/libexec"
 test-socket-tmux new-session -d -s foobar
 test-socket-tmux new-session -d -s dude
+baseCommand="${root}/bin/tmuxifier tmux"
 
 # Passes all arguments to Tmux.
-assert "${libexec}/tmuxifier-tmux list-sessions -F \"- #{session_name}\"" \
+assert "${baseCommand} list-sessions -F \"- #{session_name}\"" \
        "- dude\n- foobar"
 
 # Tear down.

test-legacy/test-helper.sh

@@ -47,14 +47,13 @@ unset TMUXIFIER_NO_COMPLETE
 source "${testroot}/assert.sh"
 source "${testroot}/stub.sh"
 
-
 #
 # Test Helpers
 #
 
 test-socket-tmux() {
   export TMUXIFIER_TMUX_OPTS="-L tmuxifier-tests"
-  "$TMUX_BIN" $TMUXIFIER_TMUX_OPTS $@
+  "$TMUX_BIN" $TMUXIFIER_TMUX_OPTS "$@"
 }
 
 create-test-session() {
@@ -85,3 +84,8 @@ test-socket-window-count() {
     echo "$list" | wc -l | awk '{print $1}'
   fi
 }
+
+test-socket-pane-count() {
+  local list="$(test-socket-tmux list-panes -t "$session:")"
+  echo "$list" | wc -l | awk '{print $1}'
+}

tests/bootstrap.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+# Place your common test setup here
+
+# Resolve the project root directory
+_test_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+_root_dir="$(cd "${_test_dir}/.." && pwd)"
+
+# Set TMUXIFIER so libexec commands can find lib/util.sh
+export TMUXIFIER="${_root_dir}"
+
+# Add libexec to PATH so tmuxifier commands are available
+export PATH="${_root_dir}/libexec:${PATH}"

tests/lib/layout-helpers/__get_current_window_index_test.sh

@@ -0,0 +1,209 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# __get_current_window_index() tests
+#
+
+function set_up() {
+  # Reset session variable to known state
+  session=""
+}
+
+function tear_down() {
+  unset session
+}
+
+#
+# Basic functionality
+#
+
+function test_get_current_window_index_returns_active_window_index() {
+  session="test-session"
+  mock tmuxifier-tmux << EOF
+1:0
+0:1
+0:2
+EOF
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_same "0" "$result"
+}
+
+function test_get_current_window_index_returns_index_when_second_window_active() {
+  session="test-session"
+  mock tmuxifier-tmux << EOF
+0:0
+1:1
+0:2
+EOF
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_same "1" "$result"
+}
+
+function test_get_current_window_index_returns_index_when_last_window_active() {
+  session="test-session"
+  mock tmuxifier-tmux << EOF
+0:0
+0:1
+1:2
+EOF
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_same "2" "$result"
+}
+
+#
+# Non-standard window indices
+#
+
+function test_get_current_window_index_handles_non_zero_base_index() {
+  session="test-session"
+  # When base-index is 1
+  mock tmuxifier-tmux << EOF
+1:1
+0:2
+0:3
+EOF
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_same "1" "$result"
+}
+
+function test_get_current_window_index_handles_high_window_index() {
+  session="test-session"
+  mock tmuxifier-tmux << EOF
+0:0
+0:1
+1:999
+EOF
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_same "999" "$result"
+}
+
+function test_get_current_window_index_handles_gaps_in_window_indices() {
+  session="test-session"
+  # Windows 0, 5, 10 with window 5 being active
+  mock tmuxifier-tmux << EOF
+0:0
+1:5
+0:10
+EOF
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_same "5" "$result"
+}
+
+#
+# Single window
+#
+
+function test_get_current_window_index_returns_index_for_single_window() {
+  session="test-session"
+  mock tmuxifier-tmux echo "1:0"
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_same "0" "$result"
+}
+
+function test_get_current_window_index_returns_index_for_single_window_non_zero() {
+  session="test-session"
+  mock tmuxifier-tmux echo "1:5"
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_same "5" "$result"
+}
+
+#
+# Edge cases and error handling
+#
+
+function test_get_current_window_index_returns_empty_when_no_active_window() {
+  session="test-session"
+  # No window marked as active (shouldn't happen in practice)
+  mock tmuxifier-tmux << EOF
+0:0
+0:1
+0:2
+EOF
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_empty "$result"
+}
+
+function test_get_current_window_index_returns_empty_when_no_windows() {
+  session="test-session"
+  mock tmuxifier-tmux echo ""
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_empty "$result"
+}
+
+function test_get_current_window_index_returns_empty_on_tmux_error() {
+  session="test-session"
+  # Simulate tmux error (stderr is redirected to /dev/null in the function)
+  mock tmuxifier-tmux return 1
+
+  local result
+  result=$(__get_current_window_index)
+
+  assert_empty "$result"
+}
+
+#
+# Tmux command verification
+#
+
+function test_get_current_window_index_calls_tmux_with_correct_args() {
+  session="my-session"
+  spy tmuxifier-tmux
+
+  __get_current_window_index
+
+  assert_have_been_called_with tmuxifier-tmux \
+    "list-windows -t my-session: -F #{window_active}:#{window_index}"
+}
+
+function test_get_current_window_index_uses_session_variable() {
+  session="another-session"
+  spy tmuxifier-tmux
+
+  __get_current_window_index
+
+  assert_have_been_called_with tmuxifier-tmux \
+    "list-windows -t another-session: -F #{window_active}:#{window_index}"
+}
+
+function test_get_current_window_index_handles_special_session_names() {
+  session="my-project_v2"
+  spy tmuxifier-tmux
+
+  __get_current_window_index
+
+  assert_have_been_called_with tmuxifier-tmux \
+    "list-windows -t my-project_v2: -F #{window_active}:#{window_index}"
+}

tests/lib/layout-helpers/__get_first_window_index_test.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# __get_first_window_index() tests
+#
+
+function set_up() {
+  # Reset session variable to known state
+  session=""
+}
+
+function tear_down() {
+  unset session
+}
+
+#
+# Return value behavior
+#
+
+function test_get_first_window_index_returns_first_index_from_list() {
+  session="test-session"
+  mock tmuxifier-tmux echo "0"
+
+  local result
+  result=$(__get_first_window_index)
+
+  assert_same "0" "$result"
+}
+
+function test_get_first_window_index_returns_first_of_multiple_indices() {
+  session="test-session"
+  mock tmuxifier-tmux echo $'1\n2\n3'
+
+  local result
+  result=$(__get_first_window_index)
+
+  assert_same "1" "$result"
+}
+
+function test_get_first_window_index_returns_0_when_list_empty() {
+  session="test-session"
+  mock tmuxifier-tmux echo ""
+
+  local result
+  result=$(__get_first_window_index)
+
+  assert_same "0" "$result"
+}
+
+function test_get_first_window_index_returns_0_when_command_fails() {
+  session="test-session"
+  # Simulate tmux command failure by returning nothing
+  mock tmuxifier-tmux true
+
+  local result
+  result=$(__get_first_window_index)
+
+  assert_same "0" "$result"
+}
+
+#
+# Non-zero first window index
+#
+
+function test_get_first_window_index_handles_nonzero_first_index() {
+  session="test-session"
+  mock tmuxifier-tmux echo "5"
+
+  local result
+  result=$(__get_first_window_index)
+
+  assert_same "5" "$result"
+}
+
+function test_get_first_window_index_returns_first_even_when_not_sequential() {
+  session="test-session"
+  # Simulate windows at indices 3, 7, 12
+  mock tmuxifier-tmux echo $'3\n7\n12'
+
+  local result
+  result=$(__get_first_window_index)
+
+  assert_same "3" "$result"
+}
+
+#
+# Session target format
+#
+
+function test_get_first_window_index_uses_session_variable() {
+  session="my-project"
+  spy tmuxifier-tmux
+
+  __get_first_window_index > /dev/null
+
+  assert_have_been_called_with tmuxifier-tmux \
+    "list-windows -t my-project: -F #{window_index}"
+}
+
+function test_get_first_window_index_includes_trailing_colon_in_target() {
+  session="test"
+  spy tmuxifier-tmux
+
+  __get_first_window_index > /dev/null
+
+  # Verify the -t argument includes trailing colon
+  assert_have_been_called_with tmuxifier-tmux \
+    "list-windows -t test: -F #{window_index}"
+}
+
+#
+# Edge cases
+#
+
+function test_get_first_window_index_handles_session_with_special_chars() {
+  session="my-project_v2"
+  spy tmuxifier-tmux
+
+  __get_first_window_index > /dev/null
+
+  assert_have_been_called_with tmuxifier-tmux \
+    "list-windows -t my-project_v2: -F #{window_index}"
+}
+
+function test_get_first_window_index_handles_high_window_index() {
+  session="test-session"
+  mock tmuxifier-tmux echo "999"
+
+  local result
+  result=$(__get_first_window_index)
+
+  assert_same "999" "$result"
+}
+
+function test_get_first_window_index_handles_empty_session_name() {
+  session=""
+  spy tmuxifier-tmux
+
+  __get_first_window_index > /dev/null
+
+  assert_have_been_called_with tmuxifier-tmux \
+    "list-windows -t : -F #{window_index}"
+}

tests/lib/layout-helpers/__go_to_window_or_session_path_test.sh

@@ -0,0 +1,197 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# __go_to_window_or_session_path() tests
+#
+
+function set_up() {
+  # Reset all path-related variables before each test
+  window_root=""
+  session_root=""
+  TMUXIFIER_SESSION_ROOT=""
+
+  # Default session and window for run_cmd context
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset window_root session_root TMUXIFIER_SESSION_ROOT
+  unset session window
+}
+
+#
+# No path set
+#
+
+function test_does_nothing_when_no_paths_set() {
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_not_called run_cmd
+}
+
+function test_does_nothing_with_empty_string_paths() {
+  window_root=""
+  session_root=""
+  TMUXIFIER_SESSION_ROOT=""
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_not_called run_cmd
+}
+
+#
+# Single path set
+#
+
+function test_uses_session_root_when_only_session_root_is_set() {
+  session_root="/path/to/session"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_have_been_called_times 2 run_cmd
+  assert_have_been_called_with run_cmd ' cd "/path/to/session"' 1
+  assert_have_been_called_with run_cmd ' clear' 2
+}
+
+function test_uses_tmuxifier_session_root_when_only_env_var_is_set() {
+  TMUXIFIER_SESSION_ROOT="/path/from/env"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_have_been_called_times 2 run_cmd
+  assert_have_been_called_with run_cmd ' cd "/path/from/env"' 1
+  assert_have_been_called_with run_cmd ' clear' 2
+}
+
+function test_uses_window_root_when_only_window_root_is_set() {
+  window_root="/path/to/window"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_have_been_called_times 2 run_cmd
+  assert_have_been_called_with run_cmd ' cd "/path/to/window"' 1
+  assert_have_been_called_with run_cmd ' clear' 2
+}
+
+#
+# Priority: window_root > TMUXIFIER_SESSION_ROOT > session_root
+#
+
+function test_window_root_takes_priority_over_session_root() {
+  window_root="/window/path"
+  session_root="/session/path"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_have_been_called_with run_cmd ' cd "/window/path"' 1
+}
+
+function test_tmuxifier_session_root_takes_priority_over_session_root() {
+  TMUXIFIER_SESSION_ROOT="/env/path"
+  session_root="/session/path"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_have_been_called_with run_cmd ' cd "/env/path"' 1
+}
+
+function test_window_root_takes_priority_over_tmuxifier_session_root() {
+  window_root="/window/path"
+  TMUXIFIER_SESSION_ROOT="/env/path"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_have_been_called_with run_cmd ' cd "/window/path"' 1
+}
+
+function test_window_root_takes_priority_over_all_other_paths() {
+  window_root="/window/path"
+  TMUXIFIER_SESSION_ROOT="/env/path"
+  session_root="/session/path"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_have_been_called_with run_cmd ' cd "/window/path"' 1
+}
+
+#
+# Command format
+#
+
+function test_cd_command_has_leading_space_for_history_suppression() {
+  session_root="/some/path"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  # Leading space prevents command from being saved in shell history
+  assert_have_been_called_with run_cmd ' cd "/some/path"' 1
+}
+
+function test_clear_command_has_leading_space_for_history_suppression() {
+  session_root="/some/path"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  # Leading space prevents command from being saved in shell history
+  assert_have_been_called_with run_cmd ' clear' 2
+}
+
+function test_path_is_quoted_in_cd_command() {
+  session_root="/path/with spaces/in it"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  # Path should be quoted to handle spaces
+  assert_have_been_called_with run_cmd ' cd "/path/with spaces/in it"' 1
+}
+
+#
+# Edge cases
+#
+
+function test_handles_path_with_special_characters() {
+  session_root="/path/with\$pecial-chars_123"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_have_been_called_with run_cmd ' cd "/path/with$pecial-chars_123"' 1
+}
+
+function test_handles_home_directory_path() {
+  session_root="$HOME"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  assert_have_been_called_with run_cmd " cd \"$HOME\"" 1
+}
+
+function test_always_calls_clear_after_cd() {
+  window_root="/any/path"
+  spy run_cmd
+
+  __go_to_window_or_session_path
+
+  # Verify order: cd first, then clear
+  assert_have_been_called_times 2 run_cmd
+  assert_have_been_called_with run_cmd ' cd "/any/path"' 1
+  assert_have_been_called_with run_cmd ' clear' 2
+}

tests/lib/layout-helpers/balance_windows_horizontal_test.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# balance_windows_horizontal() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_balance_windows_horizontal_uses_current_window_by_default() {
+  spy tmuxifier-tmux
+
+  balance_windows_horizontal
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-layout -t test-session:0 even-horizontal"
+}
+
+function test_balance_windows_horizontal_with_specific_window() {
+  spy tmuxifier-tmux
+
+  balance_windows_horizontal 2
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-layout -t test-session:2 even-horizontal"
+}
+
+function test_balance_windows_horizontal_with_window_name() {
+  spy tmuxifier-tmux
+
+  balance_windows_horizontal "editor"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-layout -t test-session:editor even-horizontal"
+}
+
+function test_balance_windows_horizontal_with_different_session() {
+  session="mysession"
+  window="3"
+  spy tmuxifier-tmux
+
+  balance_windows_horizontal
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-layout -t mysession:3 even-horizontal"
+}

tests/lib/layout-helpers/balance_windows_vertical_test.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# balance_windows_vertical() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_balance_windows_vertical_uses_current_window_by_default() {
+  spy tmuxifier-tmux
+
+  balance_windows_vertical
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-layout -t test-session:0 even-vertical"
+}
+
+function test_balance_windows_vertical_with_specific_window() {
+  spy tmuxifier-tmux
+
+  balance_windows_vertical 2
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-layout -t test-session:2 even-vertical"
+}
+
+function test_balance_windows_vertical_with_window_name() {
+  spy tmuxifier-tmux
+
+  balance_windows_vertical "editor"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-layout -t test-session:editor even-vertical"
+}
+
+function test_balance_windows_vertical_with_different_session() {
+  session="mysession"
+  window="3"
+  spy tmuxifier-tmux
+
+  balance_windows_vertical
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-layout -t mysession:3 even-vertical"
+}

tests/lib/layout-helpers/clock_test.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# clock() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_clock_calls_tmux_clock_mode() {
+  spy tmuxifier-tmux
+
+  clock
+
+  assert_have_been_called_with tmuxifier-tmux "clock-mode -t test-session:0."
+}
+
+function test_clock_with_target_pane() {
+  spy tmuxifier-tmux
+
+  clock 1
+
+  assert_have_been_called_with tmuxifier-tmux "clock-mode -t test-session:0.1"
+}
+
+function test_clock_with_different_session_and_window() {
+  session="mysession"
+  window="2"
+  spy tmuxifier-tmux
+
+  clock 3
+
+  assert_have_been_called_with tmuxifier-tmux "clock-mode -t mysession:2.3"
+}
+
+function test_clock_with_named_window() {
+  session="dev"
+  window="editor"
+  spy tmuxifier-tmux
+
+  clock 0
+
+  assert_have_been_called_with tmuxifier-tmux "clock-mode -t dev:editor.0"
+}

tests/lib/layout-helpers/finalize_and_go_to_session_test.sh

@@ -0,0 +1,255 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# finalize_and_go_to_session() tests
+#
+
+function set_up() {
+  # Create temp directory for testing
+  _test_tmp_dir=$(mktemp -d)
+
+  # Save original values
+  _orig_home="$HOME"
+  _orig_tmux="$TMUX"
+  _orig_iterm_attach="$TMUXIFIER_TMUX_ITERM_ATTACH"
+  HOME="$_test_tmp_dir"
+
+  # Reset variables to known state
+  session=""
+  TMUX=""
+  TMUXIFIER_TMUX_ITERM_ATTACH=""
+}
+
+function tear_down() {
+  HOME="$_orig_home"
+  TMUX="$_orig_tmux"
+  TMUXIFIER_TMUX_ITERM_ATTACH="$_orig_iterm_attach"
+  unset session
+  rm -rf "$_test_tmp_dir"
+}
+
+#
+# Kill window 999 behavior
+#
+
+function test_finalize_kills_window_999() {
+  session="mysession"
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "mysession"
+
+  finalize_and_go_to_session
+
+  assert_have_been_called_with tmuxifier-tmux "kill-window -t mysession:999"
+}
+
+function test_finalize_continues_when_kill_window_fails() {
+  session="mysession"
+  # Simulate kill-window failure (window doesn't exist)
+  mock tmuxifier-tmux return 1
+  mock tmuxifier-current-session echo "mysession"
+
+  local result
+  finalize_and_go_to_session
+  result=$?
+
+  # Function should succeed even if kill-window fails due to ! negation
+  assert_same "0" "$result"
+}
+
+function test_finalize_continues_when_kill_window_succeeds() {
+  session="mysession"
+  mock tmuxifier-tmux return 0
+  mock tmuxifier-current-session echo "mysession"
+
+  local result
+  finalize_and_go_to_session
+  result=$?
+
+  # Function succeeds when kill-window succeeds
+  # Note: ! negation means exit code is inverted (1 becomes 0, 0 becomes 1)
+  # but the conditional check for __go_to_session still runs
+  assert_successful_code "true"
+}
+
+#
+# Session switching when current session differs
+#
+
+function test_finalize_calls_attach_when_current_session_differs_and_not_in_tmux() {
+  session="newsession"
+  TMUX=""
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "othersession"
+
+  finalize_and_go_to_session
+
+  # Should call attach-session when not inside tmux
+  assert_have_been_called_with tmuxifier-tmux \
+    "-u attach-session -t newsession:" 2
+}
+
+function test_finalize_calls_switch_when_current_session_differs_and_inside_tmux() {
+  session="newsession"
+  TMUX="/tmp/tmux-1000/default,12345,0"
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "othersession"
+
+  finalize_and_go_to_session
+
+  # Should call switch-client when inside tmux
+  assert_have_been_called_with tmuxifier-tmux \
+    "-u switch-client -t newsession:" 2
+}
+
+#
+# Session switching when current session matches
+#
+
+function test_finalize_does_not_switch_when_current_session_matches() {
+  session="mysession"
+  TMUX=""
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "mysession"
+
+  finalize_and_go_to_session
+
+  # Should only call kill-window, not attach/switch
+  assert_have_been_called_times 1 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux "kill-window -t mysession:999" 1
+}
+
+function test_finalize_does_not_switch_when_already_in_session_inside_tmux() {
+  session="current"
+  TMUX="/tmp/tmux-1000/default,12345,0"
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "current"
+
+  finalize_and_go_to_session
+
+  # Should only call kill-window
+  assert_have_been_called_times 1 tmuxifier-tmux
+}
+
+#
+# iTerm2 integration
+#
+
+function test_finalize_uses_iterm_attach_flag_when_set() {
+  session="newsession"
+  TMUX=""
+  TMUXIFIER_TMUX_ITERM_ATTACH="-CC"
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "othersession"
+
+  finalize_and_go_to_session
+
+  # Should include -CC flag for iTerm2 integration
+  assert_have_been_called_with tmuxifier-tmux \
+    "-CC -u attach-session -t newsession:" 2
+}
+
+function test_finalize_iterm_flag_not_used_when_switching_client() {
+  session="newsession"
+  TMUX="/tmp/tmux-1000/default,12345,0"
+  TMUXIFIER_TMUX_ITERM_ATTACH="-CC"
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "othersession"
+
+  finalize_and_go_to_session
+
+  # switch-client doesn't use ITERM_ATTACH
+  assert_have_been_called_with tmuxifier-tmux \
+    "-u switch-client -t newsession:" 2
+}
+
+#
+# Edge cases
+#
+
+function test_finalize_handles_session_with_special_characters() {
+  session="my-project_v2.0"
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "my-project_v2.0"
+
+  finalize_and_go_to_session
+
+  assert_have_been_called_with tmuxifier-tmux \
+    "kill-window -t my-project_v2.0:999"
+}
+
+function test_finalize_handles_empty_current_session_output() {
+  session="newsession"
+  TMUX=""
+  spy tmuxifier-tmux
+  # Empty output from tmuxifier-current-session (not in any session)
+  mock tmuxifier-current-session echo ""
+
+  finalize_and_go_to_session
+
+  # Empty != "newsession", so should call attach
+  assert_have_been_called_with tmuxifier-tmux \
+    "-u attach-session -t newsession:" 2
+}
+
+function test_finalize_handles_session_name_with_spaces() {
+  session="my session"
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "my session"
+
+  finalize_and_go_to_session
+
+  assert_have_been_called_with tmuxifier-tmux \
+    "kill-window -t my session:999"
+}
+
+#
+# Integration-style tests
+#
+
+function test_finalize_full_flow_when_session_exists_and_matches() {
+  session="existing"
+  TMUX=""
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "existing"
+
+  finalize_and_go_to_session
+
+  # Verify single call to kill-window only
+  assert_have_been_called_times 1 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux "kill-window -t existing:999" 1
+}
+
+function test_finalize_full_flow_when_session_needs_attach() {
+  session="newproject"
+  TMUX=""
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo ""
+
+  finalize_and_go_to_session
+
+  # Verify both calls: kill-window and attach-session
+  assert_have_been_called_times 2 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux \
+    "kill-window -t newproject:999" 1
+  assert_have_been_called_with tmuxifier-tmux \
+    "-u attach-session -t newproject:" 2
+}
+
+function test_finalize_full_flow_when_switching_from_another_session() {
+  session="target"
+  TMUX="/tmp/tmux-1000/default,12345,0"
+  spy tmuxifier-tmux
+  mock tmuxifier-current-session echo "source"
+
+  finalize_and_go_to_session
+
+  # Verify both calls: kill-window and switch-client
+  assert_have_been_called_times 2 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux \
+    "kill-window -t target:999" 1
+  assert_have_been_called_with tmuxifier-tmux \
+    "-u switch-client -t target:" 2
+}

tests/lib/layout-helpers/initialize_session_test.sh

@@ -0,0 +1,430 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# initialize_session() tests
+#
+
+function set_up() {
+  # Create temp directory for testing
+  _test_tmp_dir=$(mktemp -d)
+
+  # Save original values
+  _orig_home="$HOME"
+  HOME="$_test_tmp_dir"
+
+  # Reset variables to known state
+  session=""
+  session_root="$HOME"
+  set_default_path=true
+  window=""
+  TMUX=""
+}
+
+function tear_down() {
+  HOME="$_orig_home"
+  unset session session_root set_default_path window
+  rm -rf "$_test_tmp_dir"
+}
+
+#
+# Session name handling
+#
+
+function test_initialize_session_uses_session_variable_when_no_argument() {
+  session="my-session"
+  mock tmuxifier-tmux echo ""
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  assert_same "my-session" "$session"
+}
+
+function test_initialize_session_uses_argument_as_session_name() {
+  session=""
+  mock tmuxifier-tmux echo ""
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session "custom-session"
+
+  assert_same "custom-session" "$session"
+}
+
+function test_initialize_session_overrides_session_variable_with_argument() {
+  session="original"
+  mock tmuxifier-tmux echo ""
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session "override"
+
+  assert_same "override" "$session"
+}
+
+#
+# Server startup
+#
+
+function test_initialize_session_starts_tmux_server() {
+  session="test"
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  assert_have_been_called_with tmuxifier-tmux "start-server" 1
+}
+
+#
+# Session existence check
+#
+
+function test_initialize_session_returns_1_when_session_exists() {
+  session="existing"
+  # Mock list-sessions to return a matching session (output is also used by
+  # start-server but ignored there)
+  mock tmuxifier-tmux printf '%s\n' "existing: 1 windows"
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  local result
+  initialize_session
+  result=$?
+
+  assert_same "1" "$result"
+}
+
+function test_initialize_session_returns_0_when_session_does_not_exist() {
+  session="newsession"
+  mock tmuxifier-tmux echo ""
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  local result
+  initialize_session
+  result=$?
+
+  assert_same "0" "$result"
+}
+
+function test_initialize_session_checks_exact_session_name_match() {
+  session="test"
+  # Return a session with similar but different name - grep pattern "^test:"
+  # won't match "test-other:"
+  mock tmuxifier-tmux printf '%s\n' "test-other: 1 windows"
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  local result
+  initialize_session
+  result=$?
+
+  # Should succeed because "test:" pattern doesn't match "test-other:"
+  assert_same "0" "$result"
+}
+
+#
+# Tmux 1.9+ behavior (modern tmux)
+#
+
+function test_initialize_session_creates_session_with_c_flag_for_tmux_19_plus() {
+  session="newsession"
+  session_root="$_test_tmp_dir"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Calls: start-server(1), list-sessions(2), new-session(3), setenv(4),
+  # move-window(5)
+  assert_have_been_called_with tmuxifier-tmux \
+    "new-session -d -s newsession -c $_test_tmp_dir" 3
+}
+
+function test_initialize_session_omits_c_flag_when_set_default_path_false() {
+  session="newsession"
+  session_root="$_test_tmp_dir"
+  set_default_path=false
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Calls: start-server(1), list-sessions(2), new-session(3), move-window(4)
+  assert_have_been_called_with tmuxifier-tmux \
+    "new-session -d -s newsession" 3
+}
+
+#
+# Tmux 1.8 and earlier behavior (legacy tmux)
+#
+
+function test_initialize_session_creates_session_without_c_for_tmux_18() {
+  session="newsession"
+  session_root="$_test_tmp_dir"
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< "<"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Calls: start-server(1), list-sessions(2), new-session(3), ...
+  assert_have_been_called_with tmuxifier-tmux \
+    "new-session -d -s newsession" 3
+}
+
+function test_initialize_session_sets_default_path_option_for_tmux_18() {
+  session="newsession"
+  session_root="$_test_tmp_dir"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< "<"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Calls: start-server(1), list-sessions(2), new-session(3), set-option(4),
+  # setenv(5), move-window(6)
+  assert_have_been_called_with tmuxifier-tmux \
+    "set-option -t newsession: default-path $_test_tmp_dir" 4
+}
+
+function test_initialize_session_skips_default_path_when_set_default_path_false() {
+  session="newsession"
+  session_root="$_test_tmp_dir"
+  set_default_path=false
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< "<"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Should have 4 calls: start-server, list-sessions, new-session, move-window
+  # (no set-option default-path call, no setenv call)
+  assert_have_been_called_times 4 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux "start-server" 1
+  assert_have_been_called_with tmuxifier-tmux "list-sessions" 2
+  assert_have_been_called_with tmuxifier-tmux "new-session -d -s newsession" 3
+  assert_have_been_called_with tmuxifier-tmux \
+    "move-window -s newsession:0 -t newsession:999" 4
+}
+
+#
+# Session root environment variable
+#
+
+function test_initialize_session_sets_session_root_env_when_not_home() {
+  session="newsession"
+  # Use a subdirectory so session_root != HOME
+  mkdir -p "$_test_tmp_dir/project"
+  session_root="$_test_tmp_dir/project"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Calls: start-server(1), list-sessions(2), new-session(3), setenv(4),
+  # move-window(5)
+  assert_have_been_called_with tmuxifier-tmux \
+    "setenv -t newsession: TMUXIFIER_SESSION_ROOT $_test_tmp_dir/project" 4
+}
+
+function test_initialize_session_skips_session_root_env_when_equal_to_home() {
+  session="newsession"
+  session_root="$HOME"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Should have 4 calls (no setenv call when session_root == HOME)
+  assert_have_been_called_times 4 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux "start-server" 1
+  assert_have_been_called_with tmuxifier-tmux "list-sessions" 2
+  assert_have_been_called_with tmuxifier-tmux \
+    "new-session -d -s newsession -c $HOME" 3
+  assert_have_been_called_with tmuxifier-tmux \
+    "move-window -s newsession:0 -t newsession:999" 4
+}
+
+function test_initialize_session_skips_session_root_env_when_set_default_path_false() {
+  session="newsession"
+  session_root="$_test_tmp_dir"
+  set_default_path=false
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Should have 4 calls (no setenv call when set_default_path is false)
+  assert_have_been_called_times 4 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux "start-server" 1
+  assert_have_been_called_with tmuxifier-tmux "list-sessions" 2
+  assert_have_been_called_with tmuxifier-tmux "new-session -d -s newsession" 3
+  assert_have_been_called_with tmuxifier-tmux \
+    "move-window -s newsession:0 -t newsession:999" 4
+}
+
+#
+# Default window handling
+#
+
+function test_initialize_session_moves_default_window_to_position_999() {
+  session="newsession"
+  session_root="$HOME"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  assert_have_been_called_with tmuxifier-tmux \
+    "move-window -s newsession:0 -t newsession:999"
+}
+
+function test_initialize_session_uses_first_window_index_for_move() {
+  session="newsession"
+  session_root="$HOME"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "1"
+
+  initialize_session
+
+  # Should use the actual first window index (1 in this case)
+  assert_have_been_called_with tmuxifier-tmux \
+    "move-window -s newsession:1 -t newsession:999"
+}
+
+#
+# Integration-style tests
+#
+
+function test_initialize_session_full_flow_tmux_19_returns_success() {
+  session="myproject"
+  mkdir -p "$_test_tmp_dir/project"
+  session_root="$_test_tmp_dir/project"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  local result
+  initialize_session
+  result=$?
+
+  assert_same "0" "$result"
+  assert_same "myproject" "$session"
+}
+
+function test_initialize_session_full_flow_tmux_19_calls_expected_commands() {
+  session="myproject"
+  mkdir -p "$_test_tmp_dir/project"
+  session_root="$_test_tmp_dir/project"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Verify all expected calls
+  assert_have_been_called_times 5 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux "start-server" 1
+  assert_have_been_called_with tmuxifier-tmux "list-sessions" 2
+  assert_have_been_called_with tmuxifier-tmux \
+    "new-session -d -s myproject -c $_test_tmp_dir/project" 3
+  assert_have_been_called_with tmuxifier-tmux \
+    "setenv -t myproject: TMUXIFIER_SESSION_ROOT $_test_tmp_dir/project" 4
+  assert_have_been_called_with tmuxifier-tmux \
+    "move-window -s myproject:0 -t myproject:999" 5
+}
+
+function test_initialize_session_full_flow_tmux_18_returns_success() {
+  session="oldproject"
+  mkdir -p "$_test_tmp_dir/project"
+  session_root="$_test_tmp_dir/project"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< "<"
+  mock __get_first_window_index echo "0"
+
+  local result
+  initialize_session
+  result=$?
+
+  assert_same "0" "$result"
+  assert_same "oldproject" "$session"
+}
+
+function test_initialize_session_full_flow_tmux_18_calls_expected_commands() {
+  session="oldproject"
+  mkdir -p "$_test_tmp_dir/project"
+  session_root="$_test_tmp_dir/project"
+  set_default_path=true
+  spy tmuxifier-tmux
+  mock tmuxifier-tmux-version <<< "<"
+  mock __get_first_window_index echo "0"
+
+  initialize_session
+
+  # Verify all expected calls
+  assert_have_been_called_times 6 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux "start-server" 1
+  assert_have_been_called_with tmuxifier-tmux "list-sessions" 2
+  assert_have_been_called_with tmuxifier-tmux \
+    "new-session -d -s oldproject" 3
+  assert_have_been_called_with tmuxifier-tmux \
+    "set-option -t oldproject: default-path $_test_tmp_dir/project" 4
+  assert_have_been_called_with tmuxifier-tmux \
+    "setenv -t oldproject: TMUXIFIER_SESSION_ROOT $_test_tmp_dir/project" 5
+  assert_have_been_called_with tmuxifier-tmux \
+    "move-window -s oldproject:0 -t oldproject:999" 6
+}
+
+#
+# Edge cases
+#
+
+function test_initialize_session_does_not_create_when_session_already_exists() {
+  session="existing"
+  mock tmuxifier-tmux printf '%s\n' "existing: 1 windows"
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  local result
+  initialize_session
+  result=$?
+
+  assert_same "1" "$result"
+}
+
+function test_initialize_session_handles_session_with_special_chars() {
+  session="my-project_v2"
+  mock tmuxifier-tmux echo ""
+  mock tmuxifier-tmux-version <<< ">"
+  mock __get_first_window_index echo "0"
+
+  local result
+  initialize_session
+  result=$?
+
+  assert_same "0" "$result"
+  assert_same "my-project_v2" "$session"
+}

tests/lib/layout-helpers/load_session_test.sh

@@ -0,0 +1,200 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# load_session() tests
+#
+
+function set_up() {
+  # Create temp directory structure for testing (per-test for parallel support)
+  _test_tmp_dir=$(mktemp -d)
+  _test_layout_path="${_test_tmp_dir}/layouts"
+  mkdir -p "$_test_layout_path"
+
+  # Create a simple session layout file in layout path
+  cat > "${_test_layout_path}/mysession.session.sh" << 'EOF'
+_test_layout_sourced="mysession"
+EOF
+
+  # Create layout file with .sh extension only
+  cat > "${_test_layout_path}/other.sh" << 'EOF'
+_test_layout_sourced="other"
+EOF
+
+  # Create a layout file as a direct path (with slash)
+  cat > "${_test_tmp_dir}/direct.session.sh" << 'EOF'
+_test_layout_sourced="direct"
+EOF
+
+  # Save original values and set test values
+  _orig_layout_path="$TMUXIFIER_LAYOUT_PATH"
+  _orig_home="$HOME"
+  TMUXIFIER_LAYOUT_PATH="$_test_layout_path"
+
+  # Reset variables
+  session=""
+  session_root=""
+  set_default_path=""
+  _test_layout_sourced=""
+}
+
+function tear_down() {
+  TMUXIFIER_LAYOUT_PATH="$_orig_layout_path"
+  HOME="$_orig_home"
+  unset session session_root set_default_path _test_layout_sourced
+  rm -rf "$_test_tmp_dir"
+}
+
+function test_load_session_finds_layout_by_name_in_layout_path() {
+  load_session "mysession"
+
+  assert_same "mysession" "$_test_layout_sourced"
+}
+
+function test_load_session_finds_layout_by_direct_file_path() {
+  load_session "${_test_tmp_dir}/direct.session.sh"
+
+  assert_same "direct" "$_test_layout_sourced"
+}
+
+function test_load_session_sets_session_from_name_stripping_session_sh() {
+  # Capture session value during source, before it's reset
+  cat > "${_test_layout_path}/capture.session.sh" << 'EOF'
+_captured_session="$session"
+EOF
+
+  load_session "capture"
+
+  assert_same "capture" "$_captured_session"
+}
+
+function test_load_session_sets_session_from_path_stripping_session_sh() {
+  cat > "${_test_tmp_dir}/pathtest.session.sh" << 'EOF'
+_captured_session="$session"
+EOF
+
+  load_session "${_test_tmp_dir}/pathtest.session.sh"
+
+  assert_same "${_test_tmp_dir}/pathtest" "$_captured_session"
+}
+
+function test_load_session_uses_override_name_when_provided() {
+  cat > "${_test_layout_path}/named.session.sh" << 'EOF'
+_captured_session="$session"
+EOF
+
+  load_session "named" "custom-session"
+
+  assert_same "custom-session" "$_captured_session"
+}
+
+function test_load_session_resets_session_variable_after_load() {
+  load_session "mysession"
+
+  assert_empty "$session"
+}
+
+function test_load_session_sets_set_default_path_to_true() {
+  cat > "${_test_layout_path}/checkpath.session.sh" << 'EOF'
+_captured_set_default_path="$set_default_path"
+EOF
+
+  load_session "checkpath"
+
+  assert_same "true" "$_captured_set_default_path"
+}
+
+function test_load_session_resets_session_root_to_home_when_different() {
+  HOME="$_test_tmp_dir"
+  session_root="${_test_tmp_dir}/layouts"
+
+  load_session "mysession"
+
+  assert_same "$_test_tmp_dir" "$session_root"
+}
+
+function test_load_session_does_not_reset_session_root_when_equal_to_home() {
+  HOME="$_test_tmp_dir"
+  session_root="$_test_tmp_dir"
+
+  # Create a layout that changes session_root
+  cat > "${_test_layout_path}/nochange.session.sh" << 'EOF'
+# This layout doesn't change session_root
+EOF
+
+  load_session "nochange"
+
+  # session_root should still be the same (HOME)
+  assert_same "$_test_tmp_dir" "$session_root"
+}
+
+function test_load_session_returns_1_when_file_not_found() {
+  load_session "nonexistent" 2> /dev/null
+  local exit_code=$?
+
+  assert_same "1" "$exit_code"
+}
+
+function test_load_session_prints_error_to_stderr_when_not_found() {
+  local stderr_output
+  stderr_output=$(load_session "nonexistent" 2>&1 > /dev/null)
+
+  assert_contains "nonexistent" "$stderr_output"
+  assert_contains "not found" "$stderr_output"
+}
+
+function test_load_session_sources_file_content() {
+  cat > "${_test_layout_path}/content.session.sh" << 'EOF'
+_test_var_one="session_value1"
+_test_var_two="session_value2"
+EOF
+
+  load_session "content"
+
+  assert_same "session_value1" "$_test_var_one"
+  assert_same "session_value2" "$_test_var_two"
+}
+
+function test_load_session_prefers_layout_path_when_no_slash_in_name() {
+  # Create a file in layout path
+  cat > "${_test_layout_path}/conflict.session.sh" << 'EOF'
+_test_layout_sourced="from_layout_path"
+EOF
+
+  # When given name without slash, should use layout path
+  load_session "conflict"
+
+  assert_same "from_layout_path" "$_test_layout_sourced"
+}
+
+function test_load_session_uses_direct_path_when_slash_present() {
+  mkdir -p "${_test_layout_path}/sub"
+  cat > "${_test_layout_path}/sub/nested.session.sh" << 'EOF'
+_test_layout_sourced="from_nested"
+EOF
+
+  # When given path with slash, should use it directly
+  load_session "${_test_layout_path}/sub/nested.session.sh"
+
+  assert_same "from_nested" "$_test_layout_sourced"
+}
+
+function test_load_session_handles_relative_path_in_current_dir() {
+  # Save current directory and change to temp dir
+  local orig_pwd="$PWD"
+  cd "$_test_tmp_dir"
+
+  # Create a file without .session.sh suffix in current dir
+  cat > "localfile.sh" << 'EOF'
+_test_layout_sourced="from_local"
+EOF
+
+  # When file exists locally and no slash, it should prepend ./
+  load_session "localfile.sh"
+
+  assert_same "from_local" "$_test_layout_sourced"
+
+  cd "$orig_pwd"
+}

tests/lib/layout-helpers/load_window_test.sh

@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# load_window() tests
+#
+
+function set_up() {
+  # Create temp directory structure for testing (per-test for parallel support)
+  _test_tmp_dir=$(mktemp -d)
+  _test_layout_path="${_test_tmp_dir}/layouts"
+  mkdir -p "$_test_layout_path"
+
+  # Create a simple window layout file in layout path
+  cat > "${_test_layout_path}/mywindow.window.sh" << 'EOF'
+_test_layout_sourced="mywindow"
+EOF
+
+  # Create layout file with .sh extension only
+  cat > "${_test_layout_path}/other.sh" << 'EOF'
+_test_layout_sourced="other"
+EOF
+
+  # Create a layout file as a direct path
+  cat > "${_test_tmp_dir}/direct.window.sh" << 'EOF'
+_test_layout_sourced="direct"
+EOF
+
+  # Create a layout that modifies window_root
+  cat > "${_test_layout_path}/chroot.window.sh" << 'EOF'
+_test_layout_sourced="chroot"
+EOF
+
+  # Save original TMUXIFIER_LAYOUT_PATH and set test value
+  _orig_layout_path="$TMUXIFIER_LAYOUT_PATH"
+  TMUXIFIER_LAYOUT_PATH="$_test_layout_path"
+
+  # Reset variables
+  window=""
+  window_root=""
+  session_root=""
+  _test_layout_sourced=""
+}
+
+function tear_down() {
+  TMUXIFIER_LAYOUT_PATH="$_orig_layout_path"
+  unset window window_root session_root _test_layout_sourced
+  rm -rf "$_test_tmp_dir"
+}
+
+function test_load_window_finds_layout_by_name_in_layout_path() {
+  load_window "mywindow"
+
+  assert_same "mywindow" "$_test_layout_sourced"
+}
+
+function test_load_window_finds_layout_by_direct_file_path() {
+  load_window "${_test_tmp_dir}/direct.window.sh"
+
+  assert_same "direct" "$_test_layout_sourced"
+}
+
+function test_load_window_sets_window_from_name_stripping_window_sh() {
+  # We need to capture window value during source, before it's reset
+  cat > "${_test_layout_path}/capture.window.sh" << 'EOF'
+_captured_window="$window"
+EOF
+
+  load_window "capture"
+
+  assert_same "capture" "$_captured_window"
+}
+
+function test_load_window_sets_window_from_name_stripping_sh_only() {
+  cat > "${_test_layout_path}/simple.sh" << 'EOF'
+_captured_window="$window"
+EOF
+
+  # Load by direct path to test .sh stripping
+  load_window "${_test_layout_path}/simple.sh"
+
+  assert_same "${_test_layout_path}/simple" "$_captured_window"
+}
+
+function test_load_window_uses_override_name_when_provided() {
+  cat > "${_test_layout_path}/named.window.sh" << 'EOF'
+_captured_window="$window"
+EOF
+
+  load_window "named" "custom-name"
+
+  assert_same "custom-name" "$_captured_window"
+}
+
+function test_load_window_resets_window_variable_after_load() {
+  load_window "mywindow"
+
+  assert_empty "$window"
+}
+
+function test_load_window_resets_window_root_when_different_from_session_root() {
+  session_root="$_test_tmp_dir"
+  window_root="${_test_tmp_dir}/layouts"
+
+  # Mock the window_root function to track if it's called
+  _window_root_called=""
+  _window_root_arg=""
+  function window_root() {
+    _window_root_called="yes"
+    _window_root_arg="$1"
+  }
+
+  load_window "mywindow"
+
+  assert_same "yes" "$_window_root_called"
+  assert_same "$_test_tmp_dir" "$_window_root_arg"
+}
+
+function test_load_window_does_not_reset_window_root_when_equal_to_session_root() {
+  session_root="$_test_tmp_dir"
+  window_root="$_test_tmp_dir"
+
+  _window_root_called=""
+  function window_root() {
+    _window_root_called="yes"
+  }
+
+  load_window "mywindow"
+
+  assert_empty "$_window_root_called"
+}
+
+function test_load_window_returns_1_when_file_not_found() {
+  load_window "nonexistent" 2> /dev/null
+  local exit_code=$?
+
+  assert_same "1" "$exit_code"
+}
+
+function test_load_window_prints_error_to_stderr_when_not_found() {
+  local stderr_output
+  stderr_output=$(load_window "nonexistent" 2>&1 > /dev/null)
+
+  assert_contains "nonexistent" "$stderr_output"
+  assert_contains "not found" "$stderr_output"
+}
+
+function test_load_window_sources_file_content() {
+  cat > "${_test_layout_path}/content.window.sh" << 'EOF'
+_test_var_one="value1"
+_test_var_two="value2"
+EOF
+
+  load_window "content"
+
+  assert_same "value1" "$_test_var_one"
+  assert_same "value2" "$_test_var_two"
+}
+
+function test_load_window_prefers_direct_file_over_layout_path() {
+  # Create a file that would match both direct path and layout path lookup
+  cat > "${_test_layout_path}/conflict.window.sh" << 'EOF'
+_test_layout_sourced="from_layout_path"
+EOF
+  cat > "${_test_tmp_dir}/conflict.window.sh" << 'EOF'
+_test_layout_sourced="from_direct_path"
+EOF
+
+  # When given as direct path, should use direct file
+  load_window "${_test_tmp_dir}/conflict.window.sh"
+
+  assert_same "from_direct_path" "$_test_layout_sourced"
+}

tests/lib/layout-helpers/new_window_test.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# new_window() tests
+#
+
+function set_up() {
+  session="test-session"
+  window=""
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_new_window_calls_tmux_new_window() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+  mock __get_current_window_index echo "1"
+
+  new_window
+
+  assert_have_been_called_with tmuxifier-tmux "new-window -t test-session:"
+}
+
+function test_new_window_calls_go_to_window_or_session_path() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+  mock __get_current_window_index echo "1"
+
+  new_window
+
+  assert_have_been_called __go_to_window_or_session_path
+}
+
+function test_new_window_sets_window_variable_to_current_index() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+  mock __get_current_window_index echo "5"
+
+  new_window
+
+  assert_same "5" "$window"
+}
+
+function test_new_window_with_name_includes_n_flag() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+  mock __get_current_window_index echo "1"
+
+  new_window "mywindow"
+
+  assert_have_been_called_with tmuxifier-tmux "new-window -t test-session: -n mywindow" 1
+}
+
+function test_new_window_with_name_disables_allow_rename() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+  mock __get_current_window_index echo "1"
+
+  new_window "mywindow"
+
+  assert_have_been_called_with tmuxifier-tmux "set-option -t mywindow allow-rename off" 2
+}
+
+function test_new_window_with_name_and_command() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+  mock __get_current_window_index echo "1"
+
+  new_window "editor" "vim"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "new-window -t test-session: -n editor vim" 1
+}
+
+function test_new_window_with_only_command_via_empty_name() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+  mock __get_current_window_index echo "1"
+
+  new_window "" "htop"
+
+  assert_have_been_called_with tmuxifier-tmux "new-window -t test-session: htop"
+}
+
+function test_new_window_without_name_does_not_disable_rename() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+  mock __get_current_window_index echo "1"
+
+  new_window
+
+  # Only one call to tmuxifier-tmux (new-window), no set-option call
+  assert_have_been_called_times 1 tmuxifier-tmux
+}

tests/lib/layout-helpers/run_cmd_test.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# run_cmd() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_run_cmd_sends_command_then_enter() {
+  spy tmuxifier-tmux
+
+  run_cmd "ls -la"
+
+  assert_have_been_called_times 2 tmuxifier-tmux
+}
+
+function test_run_cmd_first_call_sends_command() {
+  spy tmuxifier-tmux
+
+  run_cmd "ls -la"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0. ls -la" 1
+}
+
+function test_run_cmd_second_call_sends_enter_key() {
+  spy tmuxifier-tmux
+
+  run_cmd "ls -la"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0. C-m" 2
+}
+
+function test_run_cmd_with_target_pane() {
+  spy tmuxifier-tmux
+
+  run_cmd "echo hello" 1
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0.1 echo hello" 1
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0.1 C-m" 2
+}
+
+function test_run_cmd_with_different_session_and_window() {
+  session="mysession"
+  window="2"
+  spy tmuxifier-tmux
+
+  run_cmd "npm start" 3
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t mysession:2.3 npm start" 1
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t mysession:2.3 C-m" 2
+}
+
+function test_run_cmd_with_complex_command() {
+  spy tmuxifier-tmux
+
+  run_cmd "cd /tmp && ls"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0. cd /tmp && ls" 1
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0. C-m" 2
+}

tests/lib/layout-helpers/select_pane_test.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# select_pane() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_select_pane_calls_tmux_select_pane() {
+  spy tmuxifier-tmux
+
+  select_pane 1
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-pane -t test-session:0.1"
+}
+
+function test_select_pane_with_pane_zero() {
+  spy tmuxifier-tmux
+
+  select_pane 0
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-pane -t test-session:0.0"
+}
+
+function test_select_pane_with_different_session_and_window() {
+  session="mysession"
+  window="2"
+  spy tmuxifier-tmux
+
+  select_pane 3
+
+  assert_have_been_called_with tmuxifier-tmux "select-pane -t mysession:2.3"
+}
+
+function test_select_pane_with_named_window() {
+  session="dev"
+  window="editor"
+  spy tmuxifier-tmux
+
+  select_pane 1
+
+  assert_have_been_called_with tmuxifier-tmux "select-pane -t dev:editor.1"
+}

tests/lib/layout-helpers/select_window_test.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# select_window() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_select_window_calls_tmux_select_window() {
+  spy tmuxifier-tmux
+  mock __get_current_window_index echo "1"
+
+  select_window 1
+
+  assert_have_been_called_with tmuxifier-tmux "select-window -t test-session:1"
+}
+
+function test_select_window_with_window_name() {
+  spy tmuxifier-tmux
+  mock __get_current_window_index echo "editor"
+
+  select_window "editor"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "select-window -t test-session:editor"
+}
+
+function test_select_window_updates_window_variable() {
+  spy tmuxifier-tmux
+  mock __get_current_window_index echo "5"
+
+  select_window 5
+
+  assert_equals "5" "$window"
+}
+
+function test_select_window_with_different_session() {
+  session="mysession"
+  spy tmuxifier-tmux
+  mock __get_current_window_index echo "2"
+
+  select_window 2
+
+  assert_have_been_called_with tmuxifier-tmux "select-window -t mysession:2"
+}

tests/lib/layout-helpers/send_keys_test.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# send_keys() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_send_keys_sends_string_to_current_pane() {
+  spy tmuxifier-tmux
+
+  send_keys "hello"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0. hello"
+}
+
+function test_send_keys_with_target_pane() {
+  spy tmuxifier-tmux
+
+  send_keys "hello" 1
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0.1 hello"
+}
+
+function test_send_keys_with_special_key() {
+  spy tmuxifier-tmux
+
+  send_keys "C-m"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0. C-m"
+}
+
+function test_send_keys_with_command_string() {
+  spy tmuxifier-tmux
+
+  send_keys "ls -la"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t test-session:0. ls -la"
+}
+
+function test_send_keys_with_different_session_and_window() {
+  session="mysession"
+  window="2"
+  spy tmuxifier-tmux
+
+  send_keys "echo test" 3
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t mysession:2.3 echo test"
+}
+
+function test_send_keys_with_named_window() {
+  session="dev"
+  window="editor"
+  spy tmuxifier-tmux
+
+  send_keys "vim ." 0
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "send-keys -t dev:editor.0 vim ."
+}

tests/lib/layout-helpers/session_root_test.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# session_root() tests
+#
+
+function set_up() {
+  # Create temp directories for testing (per-test for parallel support)
+  _test_tmp_dir=$(mktemp -d)
+  _test_valid_dir="${_test_tmp_dir}/valid"
+  mkdir -p "$_test_valid_dir"
+  _test_nonexistent_dir="${_test_tmp_dir}/nonexistent"
+
+  # Reset session_root variable before each test
+  session_root=""
+}
+
+function tear_down() {
+  unset session_root
+  rm -rf "$_test_tmp_dir"
+}
+
+function test_session_root_sets_variable_for_existing_directory() {
+  # Mock __expand_path to return the valid directory
+  mock __expand_path echo "$_test_valid_dir"
+
+  session_root "~/some/path"
+
+  assert_same "$_test_valid_dir" "$session_root"
+}
+
+function test_session_root_does_not_set_variable_for_nonexistent_directory() {
+  # Mock __expand_path to return a nonexistent directory
+  mock __expand_path echo "$_test_nonexistent_dir"
+
+  session_root "~/nonexistent"
+
+  assert_empty "$session_root"
+}
+
+function test_session_root_calls_expand_path_with_arguments() {
+  spy __expand_path
+  # Since spy doesn't return anything, the dir check will fail
+  # but we can still verify __expand_path was called
+
+  session_root "~/Projects"
+
+  assert_have_been_called_with __expand_path "~/Projects"
+}
+
+function test_session_root_passes_multiple_arguments_to_expand_path() {
+  spy __expand_path
+
+  session_root '~/$USER/path'
+
+  assert_have_been_called_with __expand_path '~/$USER/path'
+}
+
+function test_session_root_preserves_existing_value_on_invalid_path() {
+  session_root="$_test_valid_dir"
+  mock __expand_path echo "$_test_nonexistent_dir"
+
+  session_root "~/invalid"
+
+  # Original value should be preserved since new path doesn't exist
+  assert_same "$_test_valid_dir" "$session_root"
+}
+
+function test_session_root_overwrites_existing_value_on_valid_path() {
+  local new_dir="${_test_tmp_dir}/another"
+  mkdir -p "$new_dir"
+  session_root="$_test_valid_dir"
+  mock __expand_path echo "$new_dir"
+
+  session_root "~/another"
+
+  assert_same "$new_dir" "$session_root"
+}
+
+function test_session_root_handles_home_directory() {
+  # Use actual HOME which should exist
+  mock __expand_path echo "$HOME"
+
+  session_root "~"
+
+  assert_same "$HOME" "$session_root"
+}

tests/lib/layout-helpers/split_h_test.sh

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# split_h() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_split_h_calls_tmux_then_go_to_path() {
+  local calls=()
+  function tmuxifier-tmux() { calls+=("tmuxifier-tmux:$*"); }
+  function __go_to_window_or_session_path() { calls+=("go_to_path"); }
+
+  split_h
+
+  assert_equals "tmuxifier-tmux:split-window -t test-session:0. -h" "${calls[0]}"
+  assert_equals "go_to_path" "${calls[1]}"
+}
+
+#
+# Tmux 3.1+ tests (uses -l with % suffix)
+#
+
+function test_split_h_tmux_31_with_percentage_uses_l_flag() {
+  mock tmuxifier-tmux-version <<< ">"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_h 30
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t test-session:0. -h -l 30%"
+}
+
+function test_split_h_tmux_31_with_percentage_and_target_pane() {
+  session="mysession"
+  window="2"
+  mock tmuxifier-tmux-version <<< ">"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_h 50 1
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t mysession:2.1 -h -l 50%"
+}
+
+function test_split_h_tmux_31_with_only_target_pane_empty_percentage() {
+  session="test"
+  window="1"
+  mock tmuxifier-tmux-version <<< ">"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_h "" 2
+
+  assert_have_been_called_with tmuxifier-tmux "split-window -t test:1.2 -h"
+}
+
+#
+# Tmux 3.0 and earlier tests (uses -p flag)
+#
+
+function test_split_h_tmux_30_with_percentage_uses_p_flag() {
+  mock tmuxifier-tmux-version <<< "="
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_h 30
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t test-session:0. -h -p 30"
+}
+
+function test_split_h_tmux_30_with_percentage_and_target_pane() {
+  session="mysession"
+  window="2"
+  mock tmuxifier-tmux-version <<< "<"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_h 50 1
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t mysession:2.1 -h -p 50"
+}
+
+function test_split_h_tmux_30_with_only_target_pane_empty_percentage() {
+  session="test"
+  window="1"
+  mock tmuxifier-tmux-version <<< "="
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_h "" 2
+
+  assert_have_been_called_with tmuxifier-tmux "split-window -t test:1.2 -h"
+}
+
+function test_split_h_always_calls_go_to_window_or_session_path() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_h 50 1
+
+  assert_have_been_called_times 1 __go_to_window_or_session_path
+}

tests/lib/layout-helpers/split_hl_test.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# split_hl() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_split_hl_calls_tmux_then_go_to_path() {
+  local calls=()
+  function tmuxifier-tmux() { calls+=("tmuxifier-tmux:$*"); }
+  function __go_to_window_or_session_path() { calls+=("go_to_path"); }
+
+  split_hl
+
+  assert_equals "tmuxifier-tmux:split-window -t test-session:0. -h" "${calls[0]}"
+  assert_equals "go_to_path" "${calls[1]}"
+}
+
+function test_split_hl_with_column_count_includes_l_flag() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_hl 80
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t test-session:0. -h -l 80"
+}
+
+function test_split_hl_with_column_count_and_target_pane() {
+  session="mysession"
+  window="2"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_hl 40 1
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t mysession:2.1 -h -l 40"
+}
+
+function test_split_hl_with_only_target_pane_empty_count() {
+  session="test"
+  window="1"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_hl "" 2
+
+  assert_have_been_called_with tmuxifier-tmux "split-window -t test:1.2 -h"
+}
+
+function test_split_hl_always_calls_go_to_window_or_session_path() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_hl 60 1
+
+  assert_have_been_called_times 1 __go_to_window_or_session_path
+}

tests/lib/layout-helpers/split_v_test.sh

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# split_v() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_split_v_calls_tmux_then_go_to_path() {
+  local calls=()
+  function tmuxifier-tmux() { calls+=("tmuxifier-tmux:$*"); }
+  function __go_to_window_or_session_path() { calls+=("go_to_path"); }
+
+  split_v
+
+  assert_equals "tmuxifier-tmux:split-window -t test-session:0. -v" "${calls[0]}"
+  assert_equals "go_to_path" "${calls[1]}"
+}
+
+#
+# Tmux 3.1+ tests (uses -l with % suffix)
+#
+
+function test_split_v_tmux_31_with_percentage_uses_l_flag() {
+  mock tmuxifier-tmux-version <<< ">"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_v 30
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t test-session:0. -v -l 30%"
+}
+
+function test_split_v_tmux_31_with_percentage_and_target_pane() {
+  session="mysession"
+  window="2"
+  mock tmuxifier-tmux-version <<< ">"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_v 50 1
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t mysession:2.1 -v -l 50%"
+}
+
+function test_split_v_tmux_31_with_only_target_pane_empty_percentage() {
+  session="test"
+  window="1"
+  mock tmuxifier-tmux-version <<< ">"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_v "" 2
+
+  assert_have_been_called_with tmuxifier-tmux "split-window -t test:1.2 -v"
+}
+
+#
+# Tmux 3.0 and earlier tests (uses -p flag)
+#
+
+function test_split_v_tmux_30_with_percentage_uses_p_flag() {
+  mock tmuxifier-tmux-version <<< "="
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_v 30
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t test-session:0. -v -p 30"
+}
+
+function test_split_v_tmux_30_with_percentage_and_target_pane() {
+  session="mysession"
+  window="2"
+  mock tmuxifier-tmux-version <<< "<"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_v 50 1
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t mysession:2.1 -v -p 50"
+}
+
+function test_split_v_tmux_30_with_only_target_pane_empty_percentage() {
+  session="test"
+  window="1"
+  mock tmuxifier-tmux-version <<< "="
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_v "" 2
+
+  assert_have_been_called_with tmuxifier-tmux "split-window -t test:1.2 -v"
+}
+
+function test_split_v_always_calls_go_to_window_or_session_path() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_v 50 1
+
+  assert_have_been_called_times 1 __go_to_window_or_session_path
+}

tests/lib/layout-helpers/split_vl_test.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# split_vl() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_split_vl_calls_tmux_then_go_to_path() {
+  local calls=()
+  function tmuxifier-tmux() { calls+=("tmuxifier-tmux:$*"); }
+  function __go_to_window_or_session_path() { calls+=("go_to_path"); }
+
+  split_vl
+
+  assert_equals "tmuxifier-tmux:split-window -t test-session:0. -v" "${calls[0]}"
+  assert_equals "go_to_path" "${calls[1]}"
+}
+
+function test_split_vl_with_line_count_includes_l_flag() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_vl 20
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t test-session:0. -v -l 20"
+}
+
+function test_split_vl_with_line_count_and_target_pane() {
+  session="mysession"
+  window="2"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_vl 15 1
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "split-window -t mysession:2.1 -v -l 15"
+}
+
+function test_split_vl_with_only_target_pane_empty_count() {
+  session="test"
+  window="1"
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_vl "" 2
+
+  assert_have_been_called_with tmuxifier-tmux "split-window -t test:1.2 -v"
+}
+
+function test_split_vl_always_calls_go_to_window_or_session_path() {
+  spy tmuxifier-tmux
+  spy __go_to_window_or_session_path
+
+  split_vl 10 1
+
+  assert_have_been_called_times 1 __go_to_window_or_session_path
+}

tests/lib/layout-helpers/synchronize_off_test.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# synchronize_off() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_synchronize_off_uses_current_window_by_default() {
+  spy tmuxifier-tmux
+
+  synchronize_off
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "set-window-option -t test-session:0 synchronize-panes off"
+}
+
+function test_synchronize_off_with_specific_window() {
+  spy tmuxifier-tmux
+
+  synchronize_off 2
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "set-window-option -t test-session:2 synchronize-panes off"
+}
+
+function test_synchronize_off_with_window_name() {
+  spy tmuxifier-tmux
+
+  synchronize_off "editor"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "set-window-option -t test-session:editor synchronize-panes off"
+}
+
+function test_synchronize_off_with_different_session() {
+  session="mysession"
+  window="3"
+  spy tmuxifier-tmux
+
+  synchronize_off
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "set-window-option -t mysession:3 synchronize-panes off"
+}

tests/lib/layout-helpers/synchronize_on_test.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# synchronize_on() tests
+#
+
+function set_up() {
+  # Default session and window for tests
+  session="test-session"
+  window="0"
+}
+
+function tear_down() {
+  unset session window
+}
+
+function test_synchronize_on_uses_current_window_by_default() {
+  spy tmuxifier-tmux
+
+  synchronize_on
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "set-window-option -t test-session:0 synchronize-panes on"
+}
+
+function test_synchronize_on_with_specific_window() {
+  spy tmuxifier-tmux
+
+  synchronize_on 2
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "set-window-option -t test-session:2 synchronize-panes on"
+}
+
+function test_synchronize_on_with_window_name() {
+  spy tmuxifier-tmux
+
+  synchronize_on "editor"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "set-window-option -t test-session:editor synchronize-panes on"
+}
+
+function test_synchronize_on_with_different_session() {
+  session="mysession"
+  window="3"
+  spy tmuxifier-tmux
+
+  synchronize_on
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "set-window-option -t mysession:3 synchronize-panes on"
+}

tests/lib/layout-helpers/tmux_test.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# tmux() tests
+#
+
+function test_tmux_passes_single_arg_to_tmuxifier_tmux() {
+  spy tmuxifier-tmux
+
+  tmux -V
+
+  assert_have_been_called_with tmuxifier-tmux "-V"
+}
+
+function test_tmux_passes_help_flag_to_tmuxifier_tmux() {
+  spy tmuxifier-tmux
+
+  tmux --help
+
+  assert_have_been_called_with tmuxifier-tmux "--help"
+}
+
+function test_tmux_passes_multiple_args_to_tmuxifier_tmux() {
+  spy tmuxifier-tmux
+
+  tmux new -s dude
+
+  assert_have_been_called_with tmuxifier-tmux "new -s dude"
+}
+
+function test_tmux_passes_complex_args_to_tmuxifier_tmux() {
+  spy tmuxifier-tmux
+
+  tmux new-session -d -s "my-session" -n "main"
+
+  assert_have_been_called_with \
+    tmuxifier-tmux "new-session -d -s my-session -n main"
+}
+
+function test_tmux_called_multiple_times() {
+  spy tmuxifier-tmux
+
+  tmux list-sessions
+  tmux list-windows
+  tmux list-panes
+
+  assert_have_been_called_times 3 tmuxifier-tmux
+  assert_have_been_called_with tmuxifier-tmux "list-sessions" 1
+  assert_have_been_called_with tmuxifier-tmux "list-windows" 2
+  assert_have_been_called_with tmuxifier-tmux "list-panes" 3
+}

tests/lib/layout-helpers/window_root_test.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+
+# Load the layout-helpers.sh library under test
+source "${_root_dir}/lib/layout-helpers.sh"
+
+#
+# window_root() tests
+#
+
+function set_up() {
+  # Create temp directories for testing (per-test for parallel support)
+  _test_tmp_dir=$(mktemp -d)
+  _test_valid_dir="${_test_tmp_dir}/valid"
+  mkdir -p "$_test_valid_dir"
+  _test_nonexistent_dir="${_test_tmp_dir}/nonexistent"
+
+  # Reset window_root variable before each test
+  window_root=""
+}
+
+function tear_down() {
+  unset window_root
+  rm -rf "$_test_tmp_dir"
+}
+
+function test_window_root_sets_variable_for_existing_directory() {
+  # Mock __expand_path to return the valid directory
+  mock __expand_path echo "$_test_valid_dir"
+
+  window_root "~/some/path"
+
+  assert_same "$_test_valid_dir" "$window_root"
+}
+
+function test_window_root_does_not_set_variable_for_nonexistent_directory() {
+  # Mock __expand_path to return a nonexistent directory
+  mock __expand_path echo "$_test_nonexistent_dir"
+
+  window_root "~/nonexistent"
+
+  assert_empty "$window_root"
+}
+
+function test_window_root_calls_expand_path_with_arguments() {
+  spy __expand_path
+  # Since spy doesn't return anything, the dir check will fail
+  # but we can still verify __expand_path was called
+
+  window_root "~/Projects"
+
+  assert_have_been_called_with __expand_path "~/Projects"
+}
+
+function test_window_root_passes_multiple_arguments_to_expand_path() {
+  spy __expand_path
+
+  window_root '~/$USER/path'
+
+  assert_have_been_called_with __expand_path '~/$USER/path'
+}
+
+function test_window_root_preserves_existing_value_on_invalid_path() {
+  window_root="$_test_valid_dir"
+  mock __expand_path echo "$_test_nonexistent_dir"
+
+  window_root "~/invalid"
+
+  # Original value should be preserved since new path doesn't exist
+  assert_same "$_test_valid_dir" "$window_root"
+}
+
+function test_window_root_overwrites_existing_value_on_valid_path() {
+  local new_dir="${_test_tmp_dir}/another"
+  mkdir -p "$new_dir"
+  window_root="$_test_valid_dir"
+  mock __expand_path echo "$new_dir"
+
+  window_root "~/another"
+
+  assert_same "$new_dir" "$window_root"
+}
+
+function test_window_root_handles_home_directory() {
+  # Use actual HOME which should exist
+  mock __expand_path echo "$HOME"
+
+  window_root "~"
+
+  assert_same "$HOME" "$window_root"
+}

tests/lib/util/calling-complete_test.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+# Load the util.sh library under test
+source "${_root_dir}/lib/util.sh"
+
+#
+# calling-complete() tests
+#
+
+function test_calling-complete_returns_0_with_complete_flag() {
+  calling-complete --complete
+  assert_exit_code "0"
+}
+
+function test_calling-complete_returns_0_with_complete_flag_after_arg() {
+  calling-complete foo --complete
+  assert_exit_code "0"
+}
+
+function test_calling-complete_returns_0_with_complete_flag_before_arg() {
+  calling-complete --complete bar
+  assert_exit_code "0"
+}
+
+function test_calling-complete_returns_0_with_complete_flag_between_args() {
+  calling-complete foo --complete bar
+  assert_exit_code "0"
+}
+
+function test_calling-complete_returns_1_with_no_args() {
+  calling-complete
+  assert_exit_code "1"
+}
+
+function test_calling-complete_returns_1_with_unrelated_arg() {
+  calling-complete foo
+  assert_exit_code "1"
+}
+
+function test_calling-complete_returns_1_with_multiple_unrelated_args() {
+  calling-complete foo bar
+  assert_exit_code "1"
+}
+
+function test_calling-complete_returns_1_when_complete_is_not_freestanding() {
+  calling-complete --complete-me
+  assert_exit_code "1"
+}
+
+function test_calling-complete_returns_1_when_complete_is_suffix() {
+  calling-complete foo--complete
+  assert_exit_code "1"
+}

tests/lib/util/calling-help_test.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+
+# Load the util.sh library under test
+source "${_root_dir}/lib/util.sh"
+
+#
+# calling-help() tests
+#
+
+function test_calling-help_returns_0_with_help_flag() {
+  calling-help --help
+  assert_exit_code "0"
+}
+
+function test_calling-help_returns_0_with_help_flag_after_arg() {
+  calling-help foo --help
+  assert_exit_code "0"
+}
+
+function test_calling-help_returns_0_with_help_flag_before_arg() {
+  calling-help --help bar
+  assert_exit_code "0"
+}
+
+function test_calling-help_returns_0_with_help_flag_between_args() {
+  calling-help foo --help bar
+  assert_exit_code "0"
+}
+
+function test_calling-help_returns_0_with_h_flag() {
+  calling-help -h
+  assert_exit_code "0"
+}
+
+function test_calling-help_returns_0_with_h_flag_after_arg() {
+  calling-help foo -h
+  assert_exit_code "0"
+}
+
+function test_calling-help_returns_0_with_h_flag_before_arg() {
+  calling-help -h bar
+  assert_exit_code "0"
+}
+
+function test_calling-help_returns_0_with_h_flag_between_args() {
+  calling-help foo -h bar
+  assert_exit_code "0"
+}
+
+function test_calling-help_returns_1_with_no_args() {
+  calling-help
+  assert_exit_code "1"
+}
+
+function test_calling-help_returns_1_with_unrelated_arg() {
+  calling-help foo
+  assert_exit_code "1"
+}
+
+function test_calling-help_returns_1_with_multiple_unrelated_args() {
+  calling-help foo bar
+  assert_exit_code "1"
+}
+
+function test_calling-help_returns_1_when_help_is_not_freestanding() {
+  calling-help --help-me
+  assert_exit_code "1"
+}
+
+function test_calling-help_returns_1_when_help_is_suffix() {
+  calling-help foo--help
+  assert_exit_code "1"
+}
+
+function test_calling-help_returns_1_when_h_is_not_freestanding() {
+  calling-help -hj
+  assert_exit_code "1"
+}
+
+function test_calling-help_returns_1_when_h_is_embedded_in_word() {
+  calling-help welcome-home
+  assert_exit_code "1"
+}

tests/lib/util/vercomp_test.sh

@@ -0,0 +1,132 @@
+#!/usr/bin/env bash
+
+# Load the util.sh library under test
+source "${_root_dir}/lib/util.sh"
+
+#
+# vercomp() tests
+#
+# Return values:
+#   0 = versions are equal
+#   1 = first version is greater
+#   2 = first version is less
+#
+
+# Equal versions
+function test_vercomp_returns_0_for_identical_versions() {
+  vercomp "1.0.0" "1.0.0"
+  assert_exit_code "0"
+}
+
+function test_vercomp_returns_0_for_identical_two_part_versions() {
+  vercomp "1.2" "1.2"
+  assert_exit_code "0"
+}
+
+function test_vercomp_returns_0_for_identical_single_part_versions() {
+  vercomp "5" "5"
+  assert_exit_code "0"
+}
+
+function test_vercomp_returns_0_when_trailing_zeros_differ() {
+  vercomp "1.0" "1.0.0"
+  assert_exit_code "0"
+}
+
+function test_vercomp_returns_0_when_trailing_zeros_differ_reversed() {
+  vercomp "1.0.0" "1.0"
+  assert_exit_code "0"
+}
+
+function test_vercomp_returns_0_for_equal_versions_with_many_parts() {
+  vercomp "1.2.3.4.5" "1.2.3.4.5"
+  assert_exit_code "0"
+}
+
+# First version greater (returns 1)
+function test_vercomp_returns_1_when_major_is_greater() {
+  vercomp "2.0.0" "1.0.0"
+  assert_exit_code "1"
+}
+
+function test_vercomp_returns_1_when_minor_is_greater() {
+  vercomp "1.2.0" "1.1.0"
+  assert_exit_code "1"
+}
+
+function test_vercomp_returns_1_when_patch_is_greater() {
+  vercomp "1.0.2" "1.0.1"
+  assert_exit_code "1"
+}
+
+function test_vercomp_returns_1_when_first_has_more_parts_and_greater() {
+  vercomp "1.0.1" "1.0"
+  assert_exit_code "1"
+}
+
+function test_vercomp_returns_1_for_double_digit_greater() {
+  vercomp "1.10.0" "1.9.0"
+  assert_exit_code "1"
+}
+
+function test_vercomp_returns_1_for_large_version_numbers() {
+  vercomp "100.200.300" "100.200.299"
+  assert_exit_code "1"
+}
+
+# First version less (returns 2)
+function test_vercomp_returns_2_when_major_is_less() {
+  vercomp "1.0.0" "2.0.0"
+  assert_exit_code "2"
+}
+
+function test_vercomp_returns_2_when_minor_is_less() {
+  vercomp "1.1.0" "1.2.0"
+  assert_exit_code "2"
+}
+
+function test_vercomp_returns_2_when_patch_is_less() {
+  vercomp "1.0.1" "1.0.2"
+  assert_exit_code "2"
+}
+
+function test_vercomp_returns_2_when_second_has_more_parts_and_greater() {
+  vercomp "1.0" "1.0.1"
+  assert_exit_code "2"
+}
+
+function test_vercomp_returns_2_for_double_digit_less() {
+  vercomp "1.9.0" "1.10.0"
+  assert_exit_code "2"
+}
+
+function test_vercomp_returns_2_for_large_version_numbers() {
+  vercomp "100.200.299" "100.200.300"
+  assert_exit_code "2"
+}
+
+# Edge cases
+function test_vercomp_returns_0_for_empty_strings() {
+  vercomp "" ""
+  assert_exit_code "0"
+}
+
+function test_vercomp_returns_0_for_zeros() {
+  vercomp "0" "0"
+  assert_exit_code "0"
+}
+
+function test_vercomp_returns_0_for_zero_and_zero_zero() {
+  vercomp "0" "0.0"
+  assert_exit_code "0"
+}
+
+function test_vercomp_handles_leading_zeros_in_parts() {
+  vercomp "1.01" "1.1"
+  assert_exit_code "0"
+}
+
+function test_vercomp_handles_leading_zeros_comparison() {
+  vercomp "1.02" "1.1"
+  assert_exit_code "1"
+}