{

WSL_TEST_CLASS(UnitTests)

TEST_CLASS_SETUP(TestClassSetup)

{

VERIFY_ARE_EQUAL(LxsstuInitialize(FALSE), TRUE);

// Build the unit tests on the Linux side

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(LXSST_TESTS_INSTALL_COMMAND_LINE), (DWORD)0);

return true;

}

TEST_CLASS_CLEANUP(TestClassCleanup)

{

LxsstuLaunchWsl(LXSST_LXFS_CLEANUP_COMMAND_LINE);

LxsstuUninitialize(FALSE);

return true;

}

TEST_METHOD_CLEANUP(MethodCleanup)

{

LxssLogKernelOutput();

return true;

}

// Note: This test should run first since other test cases create files extended attributes, which causes bdstar to emit warnings during export.

TEST_METHOD(ExportDistro)

{

constexpr auto tarPath = L"exported-test-distro.tar";

constexpr auto vhdPath = L"exported-test-distro.vhdx";

auto cleanup = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, []() {

LOG_IF_WIN32_BOOL_FALSE(DeleteFile(tarPath));

LOG_IF_WIN32_BOOL_FALSE(DeleteFile(vhdPath));

});

{

auto [out, err] = LxsstuLaunchWslAndCaptureOutput(std::format(L"--export {} {}", LXSS_DISTRO_NAME_TEST_L, tarPath));

VERIFY_ARE_EQUAL(out, L"The operation completed successfully. \r\n");

VERIFY_ARE_EQUAL(err, L"");

}

// Validate that the file is a valid tar

{

auto [out, err] = LxsstuLaunchWslAndCaptureOutput(std::format(L"bash -c 'tar tf {} | grep -iF /root/.bashrc'", tarPath));

VERIFY_ARE_EQUAL(out, L"./root/.bashrc\n");

VERIFY_ARE_EQUAL(err, L"");

}

// Validate that gzip compression works

{

auto [out, err] =

LxsstuLaunchWslAndCaptureOutput(std::format(L"--export {} {} --format tar.gz", LXSS_DISTRO_NAME_TEST_L, tarPath));

VERIFY_ARE_EQUAL(out, L"The operation completed successfully. \r\n");

VERIFY_ARE_EQUAL(err, L"");

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(std::format(L"gzip -t {}", tarPath)), 0L);

}

// Verify that xzip compression works

{

auto [out, err] =

LxsstuLaunchWslAndCaptureOutput(std::format(L"--export {} {} --format tar.xz", LXSS_DISTRO_NAME_TEST_L, tarPath));

VERIFY_ARE_EQUAL(out, L"The operation completed successfully. \r\n");

VERIFY_ARE_EQUAL(err, L"");

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(std::format(L"xz -t {}", tarPath)), 0L);

}

// Validate that exporting as vhd works

if (LxsstuVmMode())

{

WslShutdown(); // TODO: detach disk when distribution is stopped to remove this requirement.

auto [out, err] =

LxsstuLaunchWslAndCaptureOutput(std::format(L"--export {} {} --format vhd", LXSS_DISTRO_NAME_TEST_L, vhdPath));

VERIFY_ARE_EQUAL(out, L"The operation completed successfully. \r\n");

VERIFY_ARE_EQUAL(err, L"");

auto [vhdType, _] = LxsstuLaunchPowershellAndCaptureOutput(std::format(L"(Get-VHD '{}').VhdType", vhdPath));

VERIFY_ARE_EQUAL(vhdType, L"Dynamic\r\n");

}

else

{

auto [out, err] =

LxsstuLaunchWslAndCaptureOutput(std::format(L"--export {} {} --format vhd", LXSS_DISTRO_NAME_TEST_L, vhdPath), -1);

VERIFY_ARE_EQUAL(out, L"This operation is only supported by WSL2.\r\nError code: Wsl/Service/WSL_E_WSL2_NEEDED\r\n");

VERIFY_ARE_EQUAL(err, L"");

}

}

TEST_METHOD(SystemdSafeMode)

{

WSL2_TEST_ONLY();

SKIP_TEST_UNSTABLE(); // TODO: Re-enable when this issue is solved in main.

auto revert = EnableSystemd();

// generate a new test config with safe mode enabled

WslConfigChange config(LxssGenerateTestConfig({.safeMode = true}));

// verify that even though systemd is enabled, safe mode prevents it from executing

VERIFY_IS_FALSE(IsSystemdRunning(L"--system", 1));

config.Update(L"");

// disable safe mode and verify that it systemd runs

VERIFY_IS_TRUE(IsSystemdRunning(L"--system"));

}

TEST_METHOD(SystemdDisabled)

{

WSL2_TEST_ONLY();

// tests that systemd does not run without the wsl.conf option enabled

// run and check the output of systemctl --system

VERIFY_IS_FALSE(IsSystemdRunning(L"--system", 1));

}

TEST_METHOD(SystemdSystem)

{

WSL2_TEST_ONLY();

SKIP_TEST_UNSTABLE(); // TODO: Re-enable when this issue is solved in main.

auto cleanup = wil::scope_exit([] {

// clean up wsl.conf file

const std::wstring disableSystemdCmd(LXSST_REMOVE_DISTRO_CONF_COMMAND_LINE);

LxsstuLaunchWsl(disableSystemdCmd);

TerminateDistribution();

});

auto revert = EnableSystemd();

VERIFY_IS_TRUE(IsSystemdRunning(L"--system"));

}

TEST_METHOD(SystemdUser)

{

WSL2_TEST_ONLY();

SKIP_TEST_UNSTABLE(); // TODO: Re-enable when this issue is solved in main.

// enable systemd before creating the user.

// if not called first, the runtime directories needed for --user will not have been created

auto cleanup = EnableSystemd();

// create test user and run test as that user

ULONG TestUid;

ULONG TestGid;

CreateUser(LXSST_TEST_USERNAME, &TestUid, &TestGid);

auto userCleanup = wil::scope_exit([]() { LxsstuLaunchWsl(L"userdel " LXSST_TEST_USERNAME); });

// verify that the user service is running

const std::wstring isServiceActiveCmd = std::format(L"-u {} systemctl is-active user@{}.service", LXSST_TEST_USERNAME, TestUid);

std::wstring out;

std::wstring err;

try

{

std::tie(out, err) = LxsstuLaunchWslAndCaptureOutput(isServiceActiveCmd.data());

}

CATCH_LOG();

Trim(out);

if (out.compare(L"active") != 0)

{

LogError("Unexpected output from systemd: %ls. Stderr: %ls, cmd: %ls", out.c_str(), err.c_str(), isServiceActiveCmd.c_str());

VERIFY_FAIL();

}

// Verify that /run/user/<uid> is a writable tmpfs mount visible in both mount namespaces.

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"touch /run/user/" + std::to_wstring(TestUid) + L"/dummy-test-file"), 0u);

auto command = L"mount | grep -iF 'tmpfs on /run/user/" + std::to_wstring(TestUid) + L" type tmpfs (rw'";

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(command), 0u);

const auto nonElevatedToken = GetNonElevatedToken();

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(command, nullptr, nullptr, nullptr, nonElevatedToken.get()), 0u);

}

static bool IsSystemdRunning(const std::wstring& SystemdScope, int ExpectedExitCode = 0)

{

// run and check the output of systemctl --system

const std::wstring systemctlCmd(L"systemctl " + SystemdScope + L" is-system-running");

std::wstring out;

std::wstring error;

// capture the output of systemctl and trim for good measure

try

{

std::tie(out, error) = LxsstuLaunchWslAndCaptureOutput(systemctlCmd.data(), ExpectedExitCode);

}

CATCH_LOG()

Trim(out);

// ensure that systemd is either running in a degraded or running state

if ((out.compare(L"degraded") == 0) || (out.compare(L"running") == 0))

{

return true;

}

LogInfo(

"Error when checking if systemd is running: %ls (scope: %ls, stderr: %ls)", out.c_str(), SystemdScope.c_str(), error.c_str());

return false;

}

TEST_METHOD(SystemdNoClearTmpUnit)

{

WSL2_TEST_ONLY();

// ensures that we don't leave state on exit

auto cleanup = EnableSystemd("initTimeout=0");

// Wait for systemd to be started

VERIFY_NO_THROW(wsl::shared::retry::RetryWithTimeout<void>(

[&]() { THROW_HR_IF(E_UNEXPECTED, !IsSystemdRunning(L"--system")); }, std::chrono::seconds(1), std::chrono::minutes(1)));

// Validate that the X11 socket has not been deleted

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"test -d /tmp/.X11-unix"), 0L);

}

TEST_METHOD(SystemdBinfmtIsRestored)

{

WSL2_TEST_ONLY();

// Override WSL's binfmt interpreter

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"echo ':WSLInterop:M::MZ::/bin/echo:PF' > /usr/lib/binfmt.d/dummy.conf"), 0L);

auto cleanupBinfmt = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, []() {

LxsstuLaunchWsl(L"rm /usr/lib/binfmt.d/dummy.conf");

WslShutdown(); // Required since this test registers a custom binfmt interpreter.

});

{

// Enable systemd (restarts distro).

auto cleanupSystemd = EnableSystemd();

auto validateBinfmt = []() {

// Validate that WSL's binfmt interpreter is still in place.

auto [cmdOutput, _] = LxsstuLaunchWslAndCaptureOutput(L"cmd.exe /c echo ok");

VERIFY_ARE_EQUAL(cmdOutput, L"ok\r\n");

};

validateBinfmt();

// Validate that this still works after restarting the distribution.

TerminateDistribution();

validateBinfmt();

// Validate that stopping or restarting systemd-binfmt doesn't break interop.

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"systemctl stop systemd-binfmt.service"), 0u);

validateBinfmt();

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"systemctl restart systemd-binfmt.service"), 0u);

validateBinfmt();

// Validate that the unit is regenerated after a daemon-reload.

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"systemctl daemon-reload && systemctl restart systemd-binfmt.service"), 0u);

validateBinfmt();

}

{

// Enable systemd (restarts distro).

auto cleanupSystemd = EnableSystemd("protectBinfmt=false");

// Validate that WSL's binfmt interpreter is overriden

auto [output, _] = LxsstuLaunchWslAndCaptureOutput(L"cmd.exe /c echo ok");

VERIFY_IS_TRUE(wsl::shared::string::IsEqual(output, L"/mnt/c/Windows/system32/cmd.exe cmd.exe /c echo ok\n", true));

}

}

TEST_METHOD(Dup)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests dup", L"Dup"));

}

TEST_METHOD(Epoll)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests epoll", L"Epoll"));

}

TEST_METHOD(EventFd)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests eventfd", L"EventFd"));

}

TEST_METHOD(Flock)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests flock", L"Flock"));

}

TEST_METHOD(Fork)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests fork", L"Fork"));

}

TEST_METHOD(FsCommonLxFs)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests fscommon", L"fscommon_lxfs"));

}

TEST_METHOD(GetSetId)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests get_set_id", L"get_set_id"));

}

TEST_METHOD(Inotify)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests inotify", L"INOTIFY"));

}

#if !defined(_ARM64_)

TEST_METHOD(ResourceLimits)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests resourcelimits", L"resourcelimits"));

}

TEST_METHOD(Select)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests select", L"Select"));

}

#endif

TEST_METHOD(Madvise)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests madvise", L"madvise"));

}

TEST_METHOD(Mprotect)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests mprotect", L"mprotect"));

}

TEST_METHOD(Pipe)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests pipe", L"Pipe"));

}

TEST_METHOD(Sched)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests sched", L"sched"));

}

TEST_METHOD(SocketNonblocking)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests socket_nonblock", L"socket_nonblocking"));

}

TEST_METHOD(Splice)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests splice", L"Splice"));

}

TEST_METHOD(Sysfs)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests sysfs", L"SysFs"));

}

TEST_METHOD(Tty)

{

WSL1_TEST_ONLY();

auto OriginalHandles = UseOriginalStdHandles();

auto Restore = wil::scope_exit([&OriginalHandles]() { RestoreTestStdHandles(OriginalHandles); });

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests tty", L"tty"));

}

TEST_METHOD(Utimensat)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests utimensat", L"Utimensat"));

}

TEST_METHOD(WaitPid)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests waitpid", L"WaitPid"));

}

TEST_METHOD(Brk)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests brk", L"brk"));

}

TEST_METHOD(Mremap)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests mremap", L"mremap"));

}

TEST_METHOD(VfsAccess)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests vfsaccess", L"vfsaccess"));

}

TEST_METHOD(DevPt)

{

WSL1_TEST_ONLY();

auto OriginalHandles = UseOriginalStdHandles();

auto Restore = wil::scope_exit([&OriginalHandles]() { RestoreTestStdHandles(OriginalHandles); });

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests dev_pt", L"dev_pt"));

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests dev_pt_2", L"dev_pt_2"));

}

TEST_METHOD(Timer)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests timer", L"timer"));

}

TEST_METHOD(SysInfo)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests sysinfo", L"Sysinfo"));

}

TEST_METHOD(TimerFd)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests timerfd", L"timerfd"));

}

TEST_METHOD(Ioprio)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests ioprio", L"Ioprio"));

}

TEST_METHOD(Interop)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests interop", L"interop"));

//

// Run wsl.exe with a very long command line. This ensures that the buffer

// resizing logic that is used by the WSL init daemon is able to correctly

// handle very long messages.

//

// N.B. /bin/true ignores all arguments and always returns 0.

//

std::wstring Command{L"/bin/true "};

Command += std::wstring(0x1000, L'x');

VERIFY_IS_TRUE(LxsstuLaunchWsl(Command.c_str()) == 0);

// Validate that windows executable can run from the linux filesystem. See: https://github.com/microsoft/WSL/issues/10812

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"cp /mnt/c/Program\\ Files/WSL/wsl.exe /tmp"), 0L);

auto [out, _] =

LxsstuLaunchWslAndCaptureOutput(L"WSLENV=WSL_UTF8 WSL_UTF8=1 WSL_INTEROP=/run/WSL/1_interop /tmp/wsl.exe --version");

VERIFY_IS_TRUE(out.find(TEXT(WSL_PACKAGE_VERSION)) != std::string::npos);

}

static std::wstring FormUserCommandLine(_In_ const std::wstring& Username, _In_ ULONG Uid, _In_ ULONG Gid)

{

return std::format(L"/data/test/wsl_unit_tests user {} {} {}", Username, Uid, Gid);

}

TEST_METHOD(User)

{

//

// Create a test user and run the test as that user.

//

ULONG TestUid;

ULONG TestGid;

CreateUser(LXSST_TEST_USERNAME, &TestUid, &TestGid);

std::wstring CommandLine = FormUserCommandLine(LXSST_TEST_USERNAME, TestUid, TestGid);

LogInfo("Running test as user %s", LXSST_TEST_USERNAME);

VERIFY_NO_THROW(LxsstuRunTest(CommandLine.c_str(), L"user", LXSST_TEST_USERNAME));

//

// Add the user to 64 more groups to make sure > 32 groups is supported.

//

{

DistroFileChange groups(L"/etc/group", true);

CommandLine = std::format(L"-- for i in $(seq 1 64); do groupadd group$i; usermod -a -G group$i {}; done", LXSST_TEST_USERNAME);

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(CommandLine), (DWORD)0);

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(std::format(L"{} {} {}", WSL_USER_ARG_LONG, LXSST_TEST_USERNAME, "echo success")), (DWORD)0);

}

//

// Run the test as root.

//

ULONG RootUid;

ULONG RootGid;

CreateUser(LXSST_USERNAME_ROOT, &RootUid, &RootGid);

CommandLine = FormUserCommandLine(LXSST_USERNAME_ROOT, LXSST_UID_ROOT, LXSST_GID_ROOT);

LogInfo("Running test as user %s", LXSST_USERNAME_ROOT);

VERIFY_NO_THROW(LxsstuRunTest(CommandLine.c_str(), L"user", LXSST_USERNAME_ROOT));

//

// Set the default user to the newly created user.

//

// N.B. Modifying the default UID should cause the instance to be recreated and the plan9 server launched as the default user.

//

const auto wslSupport =

wil::CoCreateInstance<LxssUserSession, IWslSupport>(CLSCTX_LOCAL_SERVER | CLSCTX_ENABLE_CLOAKING | CLSCTX_ENABLE_AAA);

ULONG Version;

ULONG DefaultUid;

wil::unique_cotaskmem_array_ptr<wil::unique_cotaskmem_ansistring> DefaultEnvironment{};

ULONG WslFlags;

VERIFY_SUCCEEDED(wslSupport->GetDistributionConfiguration(

LXSS_DISTRO_NAME_TEST_L, &Version, &DefaultUid, DefaultEnvironment.size_address<ULONG>(), &DefaultEnvironment, &WslFlags));

VERIFY_SUCCEEDED(wslSupport->SetDistributionConfiguration(LXSS_DISTRO_NAME_TEST_L, TestUid, WslFlags));

auto cleanup = wil::scope_exit([&] {

try

{

VERIFY_SUCCEEDED(wslSupport->SetDistributionConfiguration(LXSS_DISTRO_NAME_TEST_L, DefaultUid, WslFlags));

}

catch (...)

{

LogError("Error while restoring default user");

}

});

//

// Create a new file using the 9p server.

//

const std::wstring Path = L"\\\\wsl.localhost\\" LXSS_DISTRO_NAME_TEST_L L"\\data\\test\\default_user_test";

const wil::unique_hfile File(CreateFile(

Path.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL));

if (!File)

{

LogError("Failed to create file, error=%lu", GetLastError());

VERIFY_FAIL();

}

//

// Ensure the new file was created with the correct uid.

//

VERIFY_ARE_EQUAL(

LxsstuLaunchWsl(L"stat -c %U /data/test/default_user_test | grep -iF kerneltest", nullptr, nullptr, nullptr, nullptr), 0u);

}

TEST_METHOD(Execve)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests execve", L"Execve"));

}

TEST_METHOD(Xattr)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests xattr", L"xattr"));

}

TEST_METHOD(Namespace)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests namespace", L"Namespace"));

}

TEST_METHOD(BinFmt)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests binfmt", L"BinFmt"));

//

// Perform a shutdown since the binfmt test modifies the binfmt config.

//

WslShutdown();

}

TEST_METHOD(Cgroup)

{

//

// For WSL1, run the cgroup unit test. For WSL2, ensure the cgroupv2 filesystem is mounted in the expected location.

//

if (!LxsstuVmMode())

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests cgroup", L"cgroup"));

}

else

{

VERIFY_ARE_EQUAL(

LxsstuLaunchWsl(

L"mount | grep -iF 'cgroup2 on /sys/fs/cgroup type cgroup2 (rw,nosuid,nodev,noexec,relatime,nsdelegate)'", nullptr, nullptr, nullptr, nullptr),

0u);

}

}

TEST_METHOD(Netlink)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests netlink", L"Netlink"));

}

TEST_METHOD(Random)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests random", L"random"));

}

TEST_METHOD(Keymgmt)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests keymgmt", L"Keymgmt"));

}

TEST_METHOD(Shm)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests shm", L"shm"));

}

TEST_METHOD(Sem)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests sem", L"sem"));

}

TEST_METHOD(Ttys)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests ttys", L"Ttys"));

}

TEST_METHOD(OverlayFs)

{

WSL1_TEST_ONLY();

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests overlayfs", L"OverlayFs"));

}

TEST_METHOD(Auxv)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests auxv", L"auxv"));

}

TEST_METHOD(WslInfo)

{

if (LxsstuVmMode())

{

// Ensure the `-n` option to not print newline works by validating newline counts.

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"wslinfo --networking-mode | wc -l | grep 1"), 0u);

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"wslinfo --networking-mode -n | wc -l | grep 0"), 0u);

// Ensure various wslinfo functionaly works as expected.

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"wslinfo --networking-mode | grep -iF 'nat'"), 0u);

WslConfigChange config(LxssGenerateTestConfig({.networkingMode = wsl::core::NetworkingMode::None}));

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"wslinfo --networking-mode | grep -iF 'none'"), 0u);

if (AreExperimentalNetworkingFeaturesSupported() && IsHyperVFirewallSupported())

{

config.Update(LxssGenerateTestConfig({.networkingMode = wsl::core::NetworkingMode::Mirrored}));

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"wslinfo --networking-mode | grep -iF 'mirrored'"), 0u);

}

for (const auto enabled : {true, false})

{

config.Update(LxssGenerateTestConfig({.guiApplications = enabled}));

#ifdef WSL_DEV_INSTALL_PATH

VERIFY_ARE_EQUAL(

LxsstuLaunchWsl(std::format(L"wslinfo --msal-proxy-path | grep -iF $(wslpath '{}')", TEXT(WSL_DEV_INSTALL_PATH))), 0u);

#else

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"wslinfo --msal-proxy-path | grep -iF '/mnt/c/Program Files/WSL/msal.wsl.proxy.exe'"), 0u);

#endif

}

}

else

{

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"wslinfo --networking-mode | grep -iF 'wsl1'"), 0u);

}

{

auto [out, err] = LxsstuLaunchWslAndCaptureOutput(L"wslinfo --version");

VERIFY_ARE_EQUAL(out, std::format(L"{}\n", WSL_PACKAGE_VERSION));

VERIFY_ARE_EQUAL(err, L"");

}

{

// Ensure the old version query command still works.

const auto [out, err] = LxsstuLaunchWslAndCaptureOutput(L"wslinfo --wsl-version");

VERIFY_ARE_EQUAL(out, std::format(L"{}\n", WSL_PACKAGE_VERSION));

VERIFY_ARE_EQUAL(err, L"");

}

{

auto [out, err] = LxsstuLaunchWslAndCaptureOutput(L"wslinfo --invalid", 1);

VERIFY_ARE_EQUAL(out, L"");

VERIFY_ARE_EQUAL(

err,

L"Invalid command line argument: --invalid\nPlease use 'wslinfo --help' to get a list of supported arguments.\n");

}

}

TEST_METHOD(WslPath)

{

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests wslpath", L"wslpath"));

}

TEST_METHOD(FsTab)

{

//

// Revert the fstab file and restart the instance so everything is back in

// the default state after this test.

//

auto cleanup = wil::scope_exit([&] {

try

{

LxsstuLaunchWsl(LXSST_FSTAB_CLEANUP_COMMAND_LINE);

TerminateDistribution();

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"/bin/true"), 0u);

}

catch (...)

{

LogError("Error while cleaning up the fstab");

}

});

//

// Create an entry in the /etc/fstab file to explicitly mount C:.

//

VERIFY_ARE_EQUAL(0u, LxsstuLaunchWsl(LXSST_FSTAB_BACKUP_COMMAND_LINE));

VERIFY_ARE_EQUAL(0u, LxsstuLaunchWsl(LXSST_FSTAB_SETUP_COMMAND_LINE));

TerminateDistribution();

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"/bin/true"), 0u);

//

// The test will make sure /mnt/c is mounted with the options specified in

// /etc/fstab, and that it's mounted only once.

//

VERIFY_NO_THROW(LxsstuRunTest(L"/data/test/wsl_unit_tests fstab", L"fstab"));

}

TEST_METHOD(X11SocketOverTmpMount)

{

if (!LxsstuVmMode())

{

return;

}

auto cleanup = wil::scope_exit([&] {

try

{

LxsstuLaunchWsl(LXSST_FSTAB_CLEANUP_COMMAND_LINE);

TerminateDistribution();

}

catch (...)

{

LogError("Error while cleaning up the fstab");

}

});

WslConfigChange configChange(LxssGenerateTestConfig({.guiApplications = true}));

//

// Create an entry in the /etc/fstab file to add a tmpfs over /tmp.

//

VERIFY_ARE_EQUAL(0u, LxsstuLaunchWsl(LXSST_FSTAB_BACKUP_COMMAND_LINE));

VERIFY_ARE_EQUAL(0u, LxsstuLaunchWsl(L"echo 'tmpfs /tmp tmpfs rw,nodev,nosuid,size=50M 0 0' > /etc/fstab"));

TerminateDistribution();

auto ValidateBindMount = [](HANDLE Token) {

//

// Validate that the bind mount is present.

//

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L" mount | grep -iF 'none on /tmp/.X11-unix type tmpfs'", nullptr, nullptr, nullptr, Token), 0u);

};

//

// Verify that /tmp is mounted in both namespaces.

//

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"mount | grep -iF 'tmpfs on /tmp type tmpfs'", nullptr, nullptr, nullptr, nullptr), 0u);

const auto nonElevatedToken = GetNonElevatedToken();

VERIFY_ARE_EQUAL(

LxsstuLaunchWsl(L"mount | grep -iF 'tmpfs on /tmp type tmpfs'", nullptr, nullptr, nullptr, nonElevatedToken.get()), 0u);

//

// Validate that the X11 bind mount is present and valid in both namespaces.

//

ValidateBindMount(nullptr);

ValidateBindMount(nonElevatedToken.get());

}

TEST_METHOD(ImportDistro)

{

const auto tarFileName = LXSST_IMPORT_DISTRO_TEST_DIR L"test.tar";

const auto rootfsDirectoryName = LXSST_IMPORT_DISTRO_TEST_DIR L"rootfs";

const auto vhdFileName = LXSST_IMPORT_DISTRO_TEST_DIR L"ext4.vhdx";

auto cleanup = wil::scope_exit([&] {

try

{

VERIFY_IS_TRUE(DeleteFileW(tarFileName));

VERIFY_IS_TRUE(RemoveDirectoryW(rootfsDirectoryName));

VERIFY_IS_TRUE(DeleteFileW(vhdFileName));

VERIFY_IS_TRUE(RemoveDirectoryW(LXSST_IMPORT_DISTRO_TEST_DIR));

}

catch (...)

{

LogError("Error during cleanup")

}

});

//

// Create a dummy tar file, rootfs folder, and vhdx. These will be used

// to ensure that the user cannot import a distribution over an existing one

// even if distro registration registry keys are not present.

//

VERIFY_IS_TRUE(CreateDirectoryW(LXSST_IMPORT_DISTRO_TEST_DIR, NULL));

VERIFY_IS_TRUE(CreateDirectoryW(rootfsDirectoryName, NULL));

{

const wil::unique_hfile tarFile{CreateFileW(

tarFileName, GENERIC_WRITE, (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE), NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL)};

VERIFY_IS_FALSE(!tarFile);

const wil::unique_hfile vhdFile{CreateFileW(

vhdFileName, GENERIC_WRITE, (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE), NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL)};

VERIFY_IS_FALSE(!vhdFile);

}

auto validateOutput = [](LPCWSTR commandLine, LPCWSTR expectedOutput, DWORD expectedExitCode = -1) {

auto [out, err] = LxsstuLaunchWslAndCaptureOutput(commandLine, expectedExitCode);

VERIFY_ARE_EQUAL(expectedOutput, out);

VERIFY_ARE_EQUAL(L"", err);

};

auto version = LxsstuVmMode() ? 2 : 1;

auto commandLine = std::format(L"--import dummy {} {} --version {}", LXSST_IMPORT_DISTRO_TEST_DIR, tarFileName, version);

validateOutput(

commandLine.c_str(),

L"The supplied install location is already in use.\r\n"

L"Error code: Wsl/Service/RegisterDistro/ERROR_FILE_EXISTS\r\n");

commandLine = std::format(L"--import dummy {} {} --version {}", LXSST_IMPORT_DISTRO_TEST_DIR, vhdFileName, version);

validateOutput(commandLine.c_str(), L"This looks like a VHDX file. Use --vhd to import a VHDX instead of a tar.\r\n");

if (!LxsstuVmMode())

{

commandLine = std::format(L"--import dummy {} {} --vhd --version 1", LXSST_IMPORT_DISTRO_TEST_DIR, vhdFileName);

validateOutput(

commandLine.c_str(),

L"This operation is only supported by WSL2.\r\n"

L"Error code: Wsl/Service/RegisterDistro/WSL_E_WSL2_NEEDED\r\n");

}

//

// Create and import a new distro that where /bin/sh is an absolute symlink.

//

auto newDistroName = L"symlink_distro";

auto newDistroTar = L"symlink_distro.tar";

validateOutput(

std::format(L"--export {} {}", LXSS_DISTRO_NAME_TEST_L, newDistroTar).c_str(),

L"The operation completed successfully. \r\n",

0);

auto deleteNewDistro = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, [&]() {

VERIFY_IS_TRUE(DeleteFileW(newDistroTar));

LxsstuLaunchWsl(std::format(L"--unregister {}", newDistroName));

});

validateOutput(

std::format(L"--import {} . {} --version {}", newDistroName, newDistroTar, version).c_str(),

L"The operation completed successfully. \r\n",

0);

validateOutput(std::format(L"-d {} -- ln -f -s /bin/bash /bin/sh", newDistroName).c_str(), L"", 0);

validateOutput(

std::format(L"--export {} {}", newDistroName, newDistroTar).c_str(), L"The operation completed successfully. \r\n", 0);