microsoft/WSL
1
0
Fork 0
mirror of https://github.com/microsoft/WSL.git synced 2026-05-31 05:47:06 -05:00
Code Issues Packages Projects Releases 94 Wiki Activity
Files
master
WSL/test/windows/WslcSdkTests.cpp
Blue b4d745717a Fix race condition in SDK IO callback (#40664) 
* Fix race condition in SDK IO callback

* Apply PR feedback

* Format

* Apply suggestions from code review

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
2026-05-29 10:49:29 -07:00

2592 lines
117 KiB
C++
Raw Permalink Blame History

/*++
Copyright (c) Microsoft. All rights reserved.
Module Name:
WslcSdkTests.cpp
Abstract:
This file contains test cases for the WSLC SDK.
--*/
#include "precomp.h"
#include "Common.h"
#include "wslcsdk.h"
#include "WslcsdkPrivate.h"
#include "WSLCContainerLauncher.h"
#include "wslc_schema.h"
#include <optional>
extern std::wstring g_testDataPath;
extern bool g_fastTestRun;
using namespace std::chrono_literals;
namespace {
//
// RAII guards for opaque WSLC handle types.
//
void CloseSession(WslcSession session)
{
if (session)
{
WslcTerminateSession(session);
WslcReleaseSession(session);
}
}
using UniqueSession = wil::unique_any<WslcSession, decltype(CloseSession), CloseSession>;
void CloseContainer(WslcContainer container)
{
if (container)
{
WslcStopContainer(container, WSLC_SIGNAL_SIGKILL, 0, nullptr);
WslcDeleteContainer(container, WSLC_DELETE_CONTAINER_FLAG_NONE, nullptr);
WslcReleaseContainer(container);
}
}
using UniqueContainer = wil::unique_any<WslcContainer, decltype(CloseContainer), CloseContainer>;
void CloseProcess(WslcProcess process)
{
if (process)
{
WslcReleaseProcess(process);
}
}
using UniqueProcess = wil::unique_any<WslcProcess, decltype(CloseProcess), CloseProcess>;
struct ProcessOutput
{
std::string stdoutOutput;
std::string stderrOutput;
};
ProcessOutput WaitForProcessOutput(WslcProcess process, std::chrono::milliseconds timeout = 2min)
{
// Borrow the exit-event handle (lifetime tied to the process object; do NOT close it).
HANDLE exitEvent = nullptr;
THROW_IF_FAILED(WslcGetProcessExitEvent(process, &exitEvent));
// Acquire stdout / stderr pipe handles (caller owns these).
wil::unique_handle ownedStdout;
THROW_IF_FAILED(WslcGetProcessIOHandle(process, WSLC_PROCESS_IO_HANDLE_STDOUT, &ownedStdout));
wil::unique_handle ownedStderr;
THROW_IF_FAILED(WslcGetProcessIOHandle(process, WSLC_PROCESS_IO_HANDLE_STDERR, &ownedStderr));
// Read stdout / stderr concurrently so that full pipe buffers do not stall the process.
ProcessOutput output;
wsl::windows::common::io::MultiHandleWait io;
io.AddHandle(std::make_unique<wsl::windows::common::io::ReadHandle>(
std::move(ownedStdout), [&](const auto& buffer) { output.stdoutOutput.append(buffer.data(), buffer.size()); }));
io.AddHandle(std::make_unique<wsl::windows::common::io::ReadHandle>(
std::move(ownedStderr), [&](const auto& buffer) { output.stderrOutput.append(buffer.data(), buffer.size()); }));
auto timeoutTime = std::chrono::steady_clock::now() + timeout;
io.Run(timeout);
auto remaining = timeoutTime - std::chrono::steady_clock::now();
if (remaining < 0ns)
{
remaining = {};
}
// Check that the process exits within the timeout.
THROW_HR_IF(
HRESULT_FROM_WIN32(WAIT_TIMEOUT),
WaitForSingleObject(exitEvent, static_cast<DWORD>(std::chrono::duration_cast<std::chrono::milliseconds>(remaining).count())) != WAIT_OBJECT_0);
return output;
}
//
// Runs a container with the given argv, waits up to timeoutMs for it to exit,
// and returns the captured stdout / stderr output.
//
ProcessOutput RunContainerAndCapture(WslcSession session, const WslcContainerSettings& containerSettings, std::chrono::milliseconds timeout = 2min)
{
// Create and start the container.
UniqueContainer container;
THROW_IF_FAILED(WslcCreateContainer(session, &containerSettings, &container, nullptr));
THROW_IF_FAILED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
// Acquire the init process handle.
UniqueProcess process;
THROW_IF_FAILED(WslcGetContainerInitProcess(container.get(), &process));
return WaitForProcessOutput(process.get());
}
ProcessOutput RunContainerAndCapture(
WslcSession session,
const char* image,
const std::vector<const char*>& argv,
WslcContainerFlags flags = WSLC_CONTAINER_FLAG_NONE,
const char* name = nullptr,
std::chrono::milliseconds timeout = 2min,
std::optional<WslcContainerNetworkingMode> networkingMode = std::nullopt)
{
// Build process settings.
WslcProcessSettings procSettings;
THROW_IF_FAILED(WslcInitProcessSettings(&procSettings));
if (!argv.empty())
{
THROW_IF_FAILED(WslcSetProcessSettingsCmdLine(&procSettings, argv.data(), argv.size()));
}
// Build container settings.
WslcContainerSettings containerSettings;
THROW_IF_FAILED(WslcInitContainerSettings(image, &containerSettings));
THROW_IF_FAILED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
THROW_IF_FAILED(WslcSetContainerSettingsFlags(&containerSettings, flags));
if (name)
{
THROW_IF_FAILED(WslcSetContainerSettingsName(&containerSettings, name));
}
if (networkingMode.has_value())
{
THROW_IF_FAILED(WslcSetContainerSettingsNetworkingMode(&containerSettings, *networkingMode));
}
return RunContainerAndCapture(session, containerSettings, timeout);
}
} // namespace
class WslcSdkTests
{
WSLC_TEST_CLASS(WslcSdkTests)
WSADATA m_wsadata;
std::filesystem::path m_storagePath;
WslcSession m_defaultSession = nullptr;
static inline auto c_testSessionName = L"wslc-test";
void LoadTestImage(std::string_view imageName)
{
std::filesystem::path imagePath = GetTestImagePath(imageName);
THROW_IF_FAILED(WslcLoadSessionImageFromFile(m_defaultSession, imagePath.c_str(), nullptr, nullptr));
}
TEST_CLASS_SETUP(TestClassSetup)
{
THROW_IF_WIN32_ERROR(WSAStartup(MAKEWORD(2, 2), &m_wsadata));
// Use the same storage path as WSLC runtime tests to reduce pull overhead.
m_storagePath = std::filesystem::current_path() / "test-storage";
// Build session settings using the WSLC SDK.
WslcSessionSettings sessionSettings;
VERIFY_SUCCEEDED(WslcInitSessionSettings(c_testSessionName, m_storagePath.c_str(), &sessionSettings));
VERIFY_SUCCEEDED(WslcSetSessionSettingsCpuCount(&sessionSettings, 4));
VERIFY_SUCCEEDED(WslcSetSessionSettingsMemory(&sessionSettings, 2048));
VERIFY_SUCCEEDED(WslcSetSessionSettingsTimeout(&sessionSettings, 30 * 1000));
WslcVhdRequirements vhdReqs{};
vhdReqs.sizeBytes = 4096ull * 1024 * 1024; // 4 GB
vhdReqs.type = WSLC_VHD_TYPE_DYNAMIC;
VERIFY_SUCCEEDED(WslcSetSessionSettingsVhd(&sessionSettings, &vhdReqs));
VERIFY_SUCCEEDED(WslcCreateSession(&sessionSettings, &m_defaultSession, nullptr));
// Pull images required by the tests (no-op if already present).
for (const char* image : {"debian:latest", "python:3.12-alpine", "hello-world:latest", "wslc-registry:latest"})
{
LoadTestImage(image);
}
return true;
}
TEST_CLASS_CLEANUP(TestClassCleanup)
{
if (m_defaultSession)
{
WslcTerminateSession(m_defaultSession);
WslcReleaseSession(m_defaultSession);
m_defaultSession = nullptr;
}
// Preserve the VHD in fast-run mode so subsequent runs skip image pulling.
if (!g_fastTestRun && !m_storagePath.empty())
{
std::error_code error;
std::filesystem::remove_all(m_storagePath, error);
if (error)
{
LogError("Failed to cleanup storage path %ws: %hs", m_storagePath.c_str(), error.message().c_str());
}
}
return true;
}
// -----------------------------------------------------------------------
// Session tests
// -----------------------------------------------------------------------
WSLC_TEST_METHOD(CreateSession)
{
std::filesystem::path extraStorage = m_storagePath / "wslc-extra-session-storage";
WslcSessionSettings sessionSettings;
VERIFY_SUCCEEDED(WslcInitSessionSettings(L"wslc-extra-session", extraStorage.c_str(), &sessionSettings));
VERIFY_SUCCEEDED(WslcSetSessionSettingsCpuCount(&sessionSettings, 2));
VERIFY_SUCCEEDED(WslcSetSessionSettingsMemory(&sessionSettings, 1024));
VERIFY_SUCCEEDED(WslcSetSessionSettingsTimeout(&sessionSettings, 30 * 1000));
WslcVhdRequirements vhdReqs{};
vhdReqs.sizeBytes = 1024ull * 1024 * 1024; // 1 GB
vhdReqs.type = WSLC_VHD_TYPE_DYNAMIC;
VERIFY_SUCCEEDED(WslcSetSessionSettingsVhd(&sessionSettings, &vhdReqs));
UniqueSession session;
VERIFY_SUCCEEDED(WslcCreateSession(&sessionSettings, &session, nullptr));
VERIFY_IS_NOT_NULL(session.get());
// Null output pointer must fail.
VERIFY_ARE_EQUAL(WslcCreateSession(&sessionSettings, nullptr, nullptr), E_POINTER);
// Null settings pointer must fail.
UniqueSession session2;
VERIFY_ARE_EQUAL(WslcCreateSession(nullptr, &session2, nullptr), E_POINTER);
}
WSLC_TEST_METHOD(TerminationCallbackViaTerminate)
{
std::promise<WslcSessionTerminationReason> promise;
auto callback = [](WslcSessionTerminationReason reason, PVOID context) {
auto* p = static_cast<std::promise<WslcSessionTerminationReason>*>(context);
p->set_value(reason);
};
std::filesystem::path extraStorage = m_storagePath / "wslc-termcb-term-storage";
WslcSessionSettings sessionSettings;
VERIFY_SUCCEEDED(WslcInitSessionSettings(L"wslc-termcb-term-test", extraStorage.c_str(), &sessionSettings));
VERIFY_SUCCEEDED(WslcSetSessionSettingsTimeout(&sessionSettings, 30 * 1000));
VERIFY_SUCCEEDED(WslcSetSessionSettingsTerminationCallback(&sessionSettings, callback, &promise));
UniqueSession session;
VERIFY_SUCCEEDED(WslcCreateSession(&sessionSettings, &session, nullptr));
// Terminating the session should trigger a graceful shutdown and fire the callback.
VERIFY_SUCCEEDED(WslcTerminateSession(session.get()));
auto future = promise.get_future();
VERIFY_ARE_EQUAL(future.wait_for(std::chrono::seconds(30)), std::future_status::ready);
VERIFY_ARE_EQUAL(future.get(), WSLC_SESSION_TERMINATION_REASON_SHUTDOWN);
}
WSLC_TEST_METHOD(TerminationCallbackViaRelease)
{
std::promise<WslcSessionTerminationReason> promise;
auto callback = [](WslcSessionTerminationReason reason, PVOID context) {
auto* p = static_cast<std::promise<WslcSessionTerminationReason>*>(context);
p->set_value(reason);
};
std::filesystem::path extraStorage = m_storagePath / "wslc-termcb-release-storage";
WslcSessionSettings sessionSettings;
VERIFY_SUCCEEDED(WslcInitSessionSettings(L"wslc-termcb-release-test", extraStorage.c_str(), &sessionSettings));
VERIFY_SUCCEEDED(WslcSetSessionSettingsTimeout(&sessionSettings, 30 * 1000));
VERIFY_SUCCEEDED(WslcSetSessionSettingsTerminationCallback(&sessionSettings, callback, &promise));
UniqueSession session;
VERIFY_SUCCEEDED(WslcCreateSession(&sessionSettings, &session, nullptr));
// Releasing the session should trigger a graceful shutdown and fire the callback.
VERIFY_SUCCEEDED(WslcReleaseSession(session.get()));
// Calling WslcSessionRelease will destroy the session
session.release();
auto future = promise.get_future();
VERIFY_ARE_EQUAL(future.wait_for(std::chrono::seconds(30)), std::future_status::ready);
VERIFY_ARE_EQUAL(future.get(), WSLC_SESSION_TERMINATION_REASON_SHUTDOWN);
}
// -----------------------------------------------------------------------
// Image tests
// -----------------------------------------------------------------------
WSLC_TEST_METHOD(ImageList)
{
// Positive: session has images pre-loaded — list must return at least one entry.
{
WslcImageInfo* images = nullptr;
uint32_t count = 0;
VERIFY_SUCCEEDED(WslcListSessionImages(m_defaultSession, &images, &count));
auto cleanupImages = wil::scope_exit([images]() { CoTaskMemFree(images); });
VERIFY_IS_TRUE(count >= 1);
VERIFY_IS_NOT_NULL(images);
// At least one image must have a non-empty name.
bool foundNonEmpty = false;
for (uint32_t i = 0; i < count; ++i)
{
if (images[i].name[0] != '\0' && (images[i].sha256[0] != 0 || images[i].sha256[31] != 0) &&
images[i].sizeBytes != 0 && images[i].createdUnixTime != 0)
{
foundNonEmpty = true;
break;
}
}
VERIFY_IS_TRUE(foundNonEmpty);
}
// Negative: null images pointer must fail.
{
uint32_t count = 0;
VERIFY_ARE_EQUAL(WslcListSessionImages(m_defaultSession, nullptr, &count), E_POINTER);
}
// Negative: null count pointer must fail.
{
WslcImageInfo* images = nullptr;
VERIFY_ARE_EQUAL(WslcListSessionImages(m_defaultSession, &images, nullptr), E_POINTER);
}
}
WSLC_TEST_METHOD(LoadImage)
{
// Positive: load a saved image tar and verify the image can be run.
{
// Remove the image first (ignore failure if it wasn't present).
WslcDeleteSessionImage(m_defaultSession, "hello-world:latest", nullptr);
std::filesystem::path imageTar = GetTestImagePath("hello-world:latest");
wil::unique_handle imageTarFileHandle{
CreateFileW(imageTar.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)};
VERIFY_IS_FALSE(INVALID_HANDLE_VALUE == imageTarFileHandle.get());
LARGE_INTEGER fileSize{};
VERIFY_IS_TRUE(GetFileSizeEx(imageTarFileHandle.get(), &fileSize));
VERIFY_SUCCEEDED(WslcLoadSessionImage(
m_defaultSession, imageTarFileHandle.get(), static_cast<uint64_t>(fileSize.QuadPart), nullptr, nullptr));
// Verify the loaded image is usable.
auto output = RunContainerAndCapture(m_defaultSession, "hello-world:latest", {});
VERIFY_IS_TRUE(output.stdoutOutput.find("Hello from Docker!") != std::string::npos);
}
// Positive: load a saved image tar and verify the image can be run.
{
// Remove the image first (ignore failure if it wasn't present).
WslcDeleteSessionImage(m_defaultSession, "hello-world:latest", nullptr);
std::filesystem::path imageTar = GetTestImagePath("hello-world:latest");
VERIFY_SUCCEEDED(WslcLoadSessionImageFromFile(m_defaultSession, imageTar.c_str(), nullptr, nullptr));
// Verify the loaded image is usable.
auto output = RunContainerAndCapture(m_defaultSession, "hello-world:latest", {});
VERIFY_IS_TRUE(output.stdoutOutput.find("Hello from Docker!") != std::string::npos);
}
WslcLoadImageOptions opts{};
// Negative: null ImageHandle must fail.
VERIFY_ARE_EQUAL(WslcLoadSessionImage(m_defaultSession, nullptr, 1, &opts, nullptr), E_INVALIDARG);
// Negative: INVALID_HANDLE_VALUE must fail.
VERIFY_ARE_EQUAL(WslcLoadSessionImage(m_defaultSession, INVALID_HANDLE_VALUE, 1, &opts, nullptr), E_INVALIDARG);
// Negative: zero ContentLength must fail.
VERIFY_ARE_EQUAL(WslcLoadSessionImage(m_defaultSession, GetCurrentThreadEffectiveToken(), 0, &opts, nullptr), E_INVALIDARG);
// Negative: null path must fail.
VERIFY_ARE_EQUAL(WslcLoadSessionImageFromFile(m_defaultSession, nullptr, &opts, nullptr), E_POINTER);
}
WSLC_TEST_METHOD(ImportImage)
{
const auto exportedImageTar = std::filesystem::path{g_testDataPath} / L"HelloWorldExported.tar";
constexpr auto c_handleImportedImageName = "my-hello-world-handle:test";
constexpr auto c_pathImportedImageName = "my-hello-world-path:test";
// Positive: import an exported image tar via handle+length and verify the image can be run.
{
WslcDeleteSessionImage(m_defaultSession, c_handleImportedImageName, nullptr);
auto cleanup = wil::scope_exit(
[this]() { LOG_IF_FAILED(WslcDeleteSessionImage(m_defaultSession, c_handleImportedImageName, nullptr)); });
wil::unique_handle imageTarFileHandle{CreateFileW(
exportedImageTar.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)};
VERIFY_IS_FALSE(INVALID_HANDLE_VALUE == imageTarFileHandle.get());
LARGE_INTEGER fileSize{};
VERIFY_IS_TRUE(GetFileSizeEx(imageTarFileHandle.get(), &fileSize));
VERIFY_SUCCEEDED(WslcImportSessionImage(
m_defaultSession, c_handleImportedImageName, imageTarFileHandle.get(), static_cast<uint64_t>(fileSize.QuadPart), nullptr, nullptr));
auto output = RunContainerAndCapture(m_defaultSession, c_handleImportedImageName, {"/hello"});
VERIFY_IS_TRUE(output.stdoutOutput.find("Hello from Docker!") != std::string::npos);
}
// Positive: import an exported image tar via path and verify the image can be run.
{
WslcDeleteSessionImage(m_defaultSession, c_pathImportedImageName, nullptr);
auto cleanup = wil::scope_exit(
[this]() { LOG_IF_FAILED(WslcDeleteSessionImage(m_defaultSession, c_pathImportedImageName, nullptr)); });
VERIFY_SUCCEEDED(WslcImportSessionImageFromFile(m_defaultSession, c_pathImportedImageName, exportedImageTar.c_str(), nullptr, nullptr));
auto output = RunContainerAndCapture(m_defaultSession, c_pathImportedImageName, {"/hello"});
VERIFY_IS_TRUE(output.stdoutOutput.find("Hello from Docker!") != std::string::npos);
}
WslcImportImageOptions opts{};
// Negative: null image name must fail.
VERIFY_ARE_EQUAL(WslcImportSessionImageFromFile(m_defaultSession, nullptr, exportedImageTar.c_str(), &opts, nullptr), E_POINTER);
// Negative: missing file input must fail.
VERIFY_ARE_EQUAL(WslcImportSessionImageFromFile(m_defaultSession, "missing-file-input:test", nullptr, &opts, nullptr), E_POINTER);
// Negative: zero ContentLength must fail.
VERIFY_ARE_EQUAL(WslcImportSessionImage(m_defaultSession, "zero-length:test", GetCurrentThreadEffectiveToken(), 0, &opts, nullptr), E_INVALIDARG);
}
WSLC_TEST_METHOD(LoadImageNonTar)
{
// The load should fail but it just silently ignores the load currently.
SKIP_TEST_NOT_IMPL();
// Negative: attempt to load a non-tar file.
{
std::filesystem::path pathToSelf = wil::QueryFullProcessImageNameW<std::wstring>(GetCurrentProcess());
wil::unique_handle selfFileHandle{
CreateFileW(pathToSelf.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)};
VERIFY_IS_FALSE(INVALID_HANDLE_VALUE == selfFileHandle.get());
LARGE_INTEGER fileSize{};
VERIFY_IS_TRUE(GetFileSizeEx(selfFileHandle.get(), &fileSize));
wil::unique_cotaskmem_string errorMsg;
VERIFY_ARE_EQUAL(
WslcLoadSessionImage(m_defaultSession, selfFileHandle.get(), static_cast<uint64_t>(fileSize.QuadPart), nullptr, &errorMsg), E_FAIL);
VERIFY_IS_NOT_NULL(errorMsg.get());
}
}
WSLC_TEST_METHOD(ImportImageNonTar)
{
// Negative: attempt to load a non-tar file.
{
std::filesystem::path pathToSelf = wil::QueryFullProcessImageNameW<std::wstring>(GetCurrentProcess());
wil::unique_handle selfFileHandle{
CreateFileW(pathToSelf.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)};
VERIFY_IS_FALSE(INVALID_HANDLE_VALUE == selfFileHandle.get());
LARGE_INTEGER fileSize{};
VERIFY_IS_TRUE(GetFileSizeEx(selfFileHandle.get(), &fileSize));
wil::unique_cotaskmem_string errorMsg;
VERIFY_ARE_EQUAL(
WslcImportSessionImage(
m_defaultSession, "import-self:test", selfFileHandle.get(), static_cast<uint64_t>(fileSize.QuadPart), nullptr, &errorMsg),
E_FAIL);
VERIFY_IS_NOT_NULL(errorMsg.get());
LogInfo("Import error: %ws", errorMsg.get());
}
}
WSLC_TEST_METHOD(ImageDelete)
{
VERIFY_IS_TRUE(HasImage("hello-world:latest"));
// Positive: delete an existing image.
wil::unique_cotaskmem_string errorMsg;
VERIFY_SUCCEEDED(WslcDeleteSessionImage(m_defaultSession, "hello-world:latest", &errorMsg));
// Verify the image is no longer present in the list.
VERIFY_IS_FALSE(HasImage("hello-world:latest"));
// Reload the image for subsequent tests.
LoadTestImage("hello-world:latest");
// Negative: null name must fail.
VERIFY_ARE_EQUAL(WslcDeleteSessionImage(m_defaultSession, nullptr, nullptr), E_POINTER);
}
// -----------------------------------------------------------------------
// Container lifecycle tests
// -----------------------------------------------------------------------
WSLC_TEST_METHOD(CreateContainer)
{
// Simple echo — verify stdout is captured correctly.
{
auto output = RunContainerAndCapture(m_defaultSession, "debian:latest", {"/bin/echo", "OK"});
VERIFY_ARE_EQUAL(output.stdoutOutput, "OK\n");
VERIFY_ARE_EQUAL(output.stderrOutput, "");
}
// Verify stdout and stderr are routed independently.
{
auto output =
RunContainerAndCapture(m_defaultSession, "debian:latest", {"/bin/sh", "-c", "echo stdout && echo stderr >&2"});
VERIFY_ARE_EQUAL(output.stdoutOutput, "stdout\n");
VERIFY_ARE_EQUAL(output.stderrOutput, "stderr\n");
}
// Verify that creating a container with a non-existent image fails.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("invalid-image:notfound", &containerSettings));
WslcContainer container = nullptr;
wil::unique_cotaskmem_string errorMsg;
VERIFY_ARE_EQUAL(WslcCreateContainer(m_defaultSession, &containerSettings, &container, &errorMsg), WSLC_E_IMAGE_NOT_FOUND);
VERIFY_IS_NULL(container);
}
// Verify that a null image name is rejected.
{
WslcContainerSettings containerSettings;
VERIFY_ARE_EQUAL(WslcInitContainerSettings(nullptr, &containerSettings), E_POINTER);
}
// Verify that a null settings pointer is rejected.
{
VERIFY_ARE_EQUAL(WslcInitContainerSettings("debian:latest", nullptr), E_POINTER);
}
// Verify that a null container output pointer is rejected.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_ARE_EQUAL(WslcCreateContainer(m_defaultSession, &containerSettings, nullptr, nullptr), E_POINTER);
}
}
WSLC_TEST_METHOD(ContainerGetID)
{
UniqueContainer container;
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
// Positive: ID is returned and is the expected length of hex characters.
CHAR id[WSLC_CONTAINER_ID_BUFFER_SIZE]{};
VERIFY_SUCCEEDED(WslcGetContainerID(container.get(), id));
VERIFY_ARE_EQUAL(strnlen(id, WSLC_CONTAINER_ID_BUFFER_SIZE), static_cast<size_t>(WSLC_CONTAINER_ID_BUFFER_SIZE - 1));
// Negative: null ID buffer must fail.
VERIFY_ARE_EQUAL(WslcGetContainerID(container.get(), nullptr), E_POINTER);
VERIFY_SUCCEEDED(WslcDeleteContainer(container.get(), WSLC_DELETE_CONTAINER_FLAG_NONE, nullptr));
}
WSLC_TEST_METHOD(ContainerGetState)
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sleep", "99"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
// State after creation: CREATED.
{
WslcContainerState state{};
VERIFY_SUCCEEDED(WslcGetContainerState(container.get(), &state));
VERIFY_ARE_EQUAL(state, WSLC_CONTAINER_STATE_CREATED);
}
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
// State while running: RUNNING.
{
WslcContainerState state{};
VERIFY_SUCCEEDED(WslcGetContainerState(container.get(), &state));
VERIFY_ARE_EQUAL(state, WSLC_CONTAINER_STATE_RUNNING);
}
VERIFY_SUCCEEDED(WslcStopContainer(container.get(), WSLC_SIGNAL_SIGKILL, 0, nullptr));
// State after stop: EXITED.
{
WslcContainerState state{};
VERIFY_SUCCEEDED(WslcGetContainerState(container.get(), &state));
VERIFY_ARE_EQUAL(state, WSLC_CONTAINER_STATE_EXITED);
}
// Negative: null state pointer must fail.
VERIFY_ARE_EQUAL(WslcGetContainerState(container.get(), nullptr), E_POINTER);
VERIFY_SUCCEEDED(WslcDeleteContainer(container.get(), WSLC_DELETE_CONTAINER_FLAG_NONE, nullptr));
}
WSLC_TEST_METHOD(ContainerStopAndDelete)
{
// Build a long-running container.
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sleep", "999"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsName(&containerSettings, "wslc-stop-delete-test"));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
// Acquire and release the init process handle — we won't read its I/O.
{
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
}
// Stop the container gracefully (after the timeout).
VERIFY_SUCCEEDED(WslcStopContainer(container.get(), WSLC_SIGNAL_SIGKILL, 0, nullptr));
// Delete the stopped container.
VERIFY_SUCCEEDED(WslcDeleteContainer(container.get(), WSLC_DELETE_CONTAINER_FLAG_NONE, nullptr));
}
WSLC_TEST_METHOD(ProcessIOHandles)
{
// Verify that stdout and stderr can each be read, and are independent streams.
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sh", "-c", "printf 'stdout-line\n' ; printf 'stderr-line\n' >&2"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsFlags(&containerSettings, WSLC_CONTAINER_FLAG_NONE));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
HANDLE exitEvent = nullptr;
VERIFY_SUCCEEDED(WslcGetProcessExitEvent(process.get(), &exitEvent));
HANDLE rawStdout = nullptr;
VERIFY_SUCCEEDED(WslcGetProcessIOHandle(process.get(), WSLC_PROCESS_IO_HANDLE_STDOUT, &rawStdout));
wil::unique_handle ownedStdout(rawStdout);
HANDLE rawStderr = nullptr;
VERIFY_SUCCEEDED(WslcGetProcessIOHandle(process.get(), WSLC_PROCESS_IO_HANDLE_STDERR, &rawStderr));
wil::unique_handle ownedStderr(rawStderr);
// Verify that each handle can only be acquired once.
{
HANDLE duplicate = nullptr;
VERIFY_ARE_EQUAL(WslcGetProcessIOHandle(process.get(), WSLC_PROCESS_IO_HANDLE_STDOUT, &duplicate), HRESULT_FROM_WIN32(ERROR_INVALID_STATE));
}
VERIFY_ARE_EQUAL(WaitForSingleObject(exitEvent, 60 * 1000), WAIT_OBJECT_0);
}
WSLC_TEST_METHOD(ContainerNetworkingMode)
{
// BRIDGED: container should have an eth0 interface in sysfs.
{
auto output = RunContainerAndCapture(
m_defaultSession,
"debian:latest",
{"/bin/sh", "-c", "[ -d /sys/class/net/eth0 ] && echo 'HAS_ETH0' || echo 'NO_ETH0'"},
WSLC_CONTAINER_FLAG_NONE,
nullptr,
60s,
WSLC_CONTAINER_NETWORKING_MODE_BRIDGED);
VERIFY_ARE_EQUAL(output.stdoutOutput, "HAS_ETH0\n");
}
// NONE: container should not have an eth0 interface.
{
auto output = RunContainerAndCapture(
m_defaultSession,
"debian:latest",
{"/bin/sh", "-c", "[ -d /sys/class/net/eth0 ] && echo 'HAS_ETH0' || echo 'NO_ETH0'"},
WSLC_CONTAINER_FLAG_NONE,
nullptr,
60s,
WSLC_CONTAINER_NETWORKING_MODE_NONE);
VERIFY_ARE_EQUAL(output.stdoutOutput, "NO_ETH0\n");
}
// Invalid networking mode must fail.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_ARE_EQUAL(WslcSetContainerSettingsNetworkingMode(&containerSettings, static_cast<WslcContainerNetworkingMode>(99)), E_INVALIDARG);
}
}
WSLC_TEST_METHOD(ContainerPortMapping)
{
// Negative: null mappings with nonzero count must fail.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_ARE_EQUAL(WslcSetContainerSettingsPortMappings(&containerSettings, nullptr, 1), E_INVALIDARG);
}
// Negative: non-null pointer with zero count must fail.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
WslcContainerPortMapping portMappings[1] = {};
VERIFY_ARE_EQUAL(WslcSetContainerSettingsPortMappings(&containerSettings, portMappings, 0), E_INVALIDARG);
}
// Positive: null mappings with zero count must succeed (clears the mapping).
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsPortMappings(&containerSettings, nullptr, 0));
}
// Negative: port mappings with NONE networking must fail at container creation.
{
WslcContainerSettings containerSettings1;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings1));
VERIFY_SUCCEEDED(WslcSetContainerSettingsNetworkingMode(&containerSettings1, WSLC_CONTAINER_NETWORKING_MODE_NONE));
WslcContainerPortMapping mapping{};
mapping.windowsPort = 12342;
mapping.containerPort = 8000;
mapping.protocol = WSLC_PORT_PROTOCOL_TCP;
VERIFY_SUCCEEDED(WslcSetContainerSettingsPortMappings(&containerSettings1, &mapping, 1));
WslcContainer rawContainer = nullptr;
VERIFY_ARE_EQUAL(WslcCreateContainer(m_defaultSession, &containerSettings1, &rawContainer, nullptr), E_INVALIDARG);
VERIFY_IS_NULL(rawContainer);
}
// Functional: create a container with BRIDGED networking and a port mapping;
// verify that a TCP connection from the host reaches the container.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"python3", "-m", "http.server", "8000"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
const char* env[] = {"PYTHONUNBUFFERED=1"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsEnvVariables(&procSettings, env, ARRAYSIZE(env)));
WslcContainerSettings containerSettings2;
VERIFY_SUCCEEDED(WslcInitContainerSettings("python:3.12-alpine", &containerSettings2));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings2, &procSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsNetworkingMode(&containerSettings2, WSLC_CONTAINER_NETWORKING_MODE_BRIDGED));
WslcContainerPortMapping mapping{};
mapping.windowsPort = 12341;
mapping.containerPort = 8000;
mapping.protocol = WSLC_PORT_PROTOCOL_TCP;
VERIFY_SUCCEEDED(WslcSetContainerSettingsPortMappings(&containerSettings2, &mapping, 1));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings2, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
wil::unique_handle ownedStdout;
VERIFY_SUCCEEDED(WslcGetProcessIOHandle(process.get(), WSLC_PROCESS_IO_HANDLE_STDOUT, &ownedStdout));
WaitForOutput(std::move(ownedStdout), "Serving HTTP on", 30s);
ExpectHttpResponse(L"http://127.0.0.1:12341", 200);
}
// Functional: port mapping with explicit IPv4 windowsAddress (127.0.0.1).
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"python3", "-m", "http.server", "8000"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
const char* env[] = {"PYTHONUNBUFFERED=1"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsEnvVariables(&procSettings, env, ARRAYSIZE(env)));
WslcContainerSettings containerSettings3;
VERIFY_SUCCEEDED(WslcInitContainerSettings("python:3.12-alpine", &containerSettings3));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings3, &procSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsNetworkingMode(&containerSettings3, WSLC_CONTAINER_NETWORKING_MODE_BRIDGED));
sockaddr_storage addr4{};
auto* sin4 = reinterpret_cast<sockaddr_in*>(&addr4);
sin4->sin_family = AF_INET;
VERIFY_ARE_EQUAL(inet_pton(AF_INET, "127.0.0.1", &sin4->sin_addr), 1);
WslcContainerPortMapping mapping{};
mapping.windowsPort = 12343;
mapping.containerPort = 8000;
mapping.protocol = WSLC_PORT_PROTOCOL_TCP;
mapping.windowsAddress = &addr4;
VERIFY_SUCCEEDED(WslcSetContainerSettingsPortMappings(&containerSettings3, &mapping, 1));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings3, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
wil::unique_handle ownedStdout;
VERIFY_SUCCEEDED(WslcGetProcessIOHandle(process.get(), WSLC_PROCESS_IO_HANDLE_STDOUT, &ownedStdout));
WaitForOutput(std::move(ownedStdout), "Serving HTTP on", 30s);
ExpectHttpResponse(L"http://127.0.0.1:12343", 200);
}
// Functional: port mapping with explicit IPv6 windowsAddress (::1).
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"python3", "-m", "http.server", "8000", "--bind", "::"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
const char* env[] = {"PYTHONUNBUFFERED=1"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsEnvVariables(&procSettings, env, ARRAYSIZE(env)));
WslcContainerSettings containerSettings4;
VERIFY_SUCCEEDED(WslcInitContainerSettings("python:3.12-alpine", &containerSettings4));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings4, &procSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsNetworkingMode(&containerSettings4, WSLC_CONTAINER_NETWORKING_MODE_BRIDGED));
sockaddr_storage addr6{};
auto* sin6 = reinterpret_cast<sockaddr_in6*>(&addr6);
sin6->sin6_family = AF_INET6;
VERIFY_ARE_EQUAL(inet_pton(AF_INET6, "::1", &sin6->sin6_addr), 1);
WslcContainerPortMapping mapping{};
mapping.windowsPort = 12344;
mapping.containerPort = 8000;
mapping.protocol = WSLC_PORT_PROTOCOL_TCP;
mapping.windowsAddress = &addr6;
VERIFY_SUCCEEDED(WslcSetContainerSettingsPortMappings(&containerSettings4, &mapping, 1));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings4, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
wil::unique_handle ownedStdout;
VERIFY_SUCCEEDED(WslcGetProcessIOHandle(process.get(), WSLC_PROCESS_IO_HANDLE_STDOUT, &ownedStdout));
WaitForOutput(std::move(ownedStdout), "Serving HTTP on", 30s);
ExpectHttpResponse(L"http://[::1]:12344", 200);
}
// Negative: unsupported address family must fail when setting container portmapping values.
{
WslcContainerSettings containerSettings5;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings5));
VERIFY_SUCCEEDED(WslcSetContainerSettingsNetworkingMode(&containerSettings5, WSLC_CONTAINER_NETWORKING_MODE_BRIDGED));
sockaddr_storage badAddr{};
badAddr.ss_family = AF_UNIX; // unsupported for port mapping
WslcContainerPortMapping mapping{};
mapping.windowsPort = 12345;
mapping.containerPort = 8000;
mapping.protocol = WSLC_PORT_PROTOCOL_TCP;
mapping.windowsAddress = &badAddr;
VERIFY_ARE_EQUAL(WslcSetContainerSettingsPortMappings(&containerSettings5, &mapping, 1), E_INVALIDARG);
}
}
WSLC_TEST_METHOD(ContainerVolumeUnit)
{
// Negative: null volumes with nonzero count must fail.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_ARE_EQUAL(WslcSetContainerSettingsVolumes(&containerSettings, nullptr, 1), E_INVALIDARG);
}
// Negative: non-null pointer with zero count must fail.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
WslcContainerVolume containerVolumes[1] = {};
VERIFY_ARE_EQUAL(WslcSetContainerSettingsVolumes(&containerSettings, containerVolumes, 0), E_INVALIDARG);
}
// Negative: null paths must fail.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
WslcContainerVolume containerVolumes[1] = {nullptr, "/mnt/path"};
VERIFY_ARE_EQUAL(WslcSetContainerSettingsVolumes(&containerSettings, containerVolumes, ARRAYSIZE(containerVolumes)), E_INVALIDARG);
}
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
auto currentDirectory = std::filesystem::current_path();
WslcContainerVolume containerVolumes[1] = {currentDirectory.c_str(), nullptr};
VERIFY_ARE_EQUAL(WslcSetContainerSettingsVolumes(&containerSettings, containerVolumes, ARRAYSIZE(containerVolumes)), E_INVALIDARG);
}
// Relative paths must fail.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
WslcContainerVolume containerVolumes[1] = {L"relative", "/mnt/path"};
VERIFY_ARE_EQUAL(WslcSetContainerSettingsVolumes(&containerSettings, containerVolumes, ARRAYSIZE(containerVolumes)), E_INVALIDARG);
}
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
auto currentDirectory = std::filesystem::current_path();
WslcContainerVolume containerVolumes[1] = {currentDirectory.c_str(), "./mnt/path"};
VERIFY_ARE_EQUAL(WslcSetContainerSettingsVolumes(&containerSettings, containerVolumes, ARRAYSIZE(containerVolumes)), E_INVALIDARG);
}
// Positive: null volumes with zero count must succeed (clears volumes).
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsVolumes(&containerSettings, nullptr, 0));
}
// Absolute paths should succeed
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
auto currentDirectory = std::filesystem::current_path();
WslcContainerVolume containerVolumes[1] = {currentDirectory.c_str(), "/mnt/path"};
VERIFY_SUCCEEDED(WslcSetContainerSettingsVolumes(&containerSettings, containerVolumes, ARRAYSIZE(containerVolumes)));
}
}
WSLC_TEST_METHOD(ContainerVolumeFunctional)
{
// Functional: mount a read-write and a read-only directory into the container.
{
auto hostRwDir = std::filesystem::current_path() / "wslc-test-vol-rw";
auto hostRoDir = std::filesystem::current_path() / "wslc-test-vol-ro";
std::filesystem::create_directories(hostRwDir);
std::filesystem::create_directories(hostRoDir);
auto cleanup = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, [&]() {
std::error_code ec;
std::filesystem::remove_all(hostRwDir, ec);
std::filesystem::remove_all(hostRoDir, ec);
});
// Write sentinel files into both host directories.
{
std::ofstream rwSentinel(hostRwDir / "hello.txt");
rwSentinel << "hello-rw";
}
{
std::ofstream roSentinel(hostRoDir / "hello.txt");
roSentinel << "hello-ro";
}
WslcContainerVolume volumes[2]{};
volumes[0].windowsPath = hostRwDir.c_str();
volumes[0].containerPath = "/mnt/rw";
volumes[0].readOnly = FALSE;
volumes[1].windowsPath = hostRoDir.c_str();
volumes[1].containerPath = "/mnt/ro";
volumes[1].readOnly = TRUE;
// Container script:
// 1. Read from the rw mount.
// 2. Read from the ro mount.
// 3. Write a file to the rw mount; print WRITE_OK on success.
// 4. Try to write to the ro mount; print RO_WRITE_BLOCKED if correctly rejected.
const char* script =
"cat /mnt/rw/hello.txt && "
"cat /mnt/ro/hello.txt && "
"echo 'container-write' > /mnt/rw/written.txt && echo 'WRITE_OK' && "
"if touch /mnt/ro/probe 2>/dev/null; then echo 'RO_WRITE_ALLOWED'; else echo 'RO_WRITE_BLOCKED'; fi";
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sh", "-c", script};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsVolumes(&containerSettings, volumes, 2));
ProcessOutput output = RunContainerAndCapture(m_defaultSession, containerSettings);
// Verify all four outcomes.
VERIFY_IS_TRUE(output.stdoutOutput.find("hello-rw") != std::string::npos);
VERIFY_IS_TRUE(output.stdoutOutput.find("hello-ro") != std::string::npos);
VERIFY_IS_TRUE(output.stdoutOutput.find("WRITE_OK") != std::string::npos);
VERIFY_IS_TRUE(output.stdoutOutput.find("RO_WRITE_BLOCKED") != std::string::npos);
VERIFY_IS_TRUE(output.stdoutOutput.find("RO_WRITE_ALLOWED") == std::string::npos);
// Verify the file written by the container is visible on the host.
std::ifstream written(hostRwDir / "written.txt");
VERIFY_IS_TRUE(written.is_open());
std::string writtenContent((std::istreambuf_iterator<char>(written)), std::istreambuf_iterator<char>());
VERIFY_ARE_EQUAL(writtenContent, "container-write\n");
}
}
WSLC_TEST_METHOD(ContainerInspect)
{
UniqueContainer container;
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
wil::unique_cotaskmem_ansistring inspectData;
VERIFY_SUCCEEDED(WslcInspectContainer(container.get(), &inspectData));
VERIFY_IS_NOT_NULL(inspectData);
auto inspectObject = wsl::shared::FromJson<wsl::windows::common::wslc_schema::InspectContainer>(inspectData.get());
CHAR containerId[WSLC_CONTAINER_ID_BUFFER_SIZE];
VERIFY_SUCCEEDED(WslcGetContainerID(container.get(), containerId));
VERIFY_ARE_EQUAL(containerId, inspectObject.Id);
}
WSLC_TEST_METHOD(ContainerExec)
{
// Start a long-running container so we can exec into it.
WslcProcessSettings initProcSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&initProcSettings));
const char* initArgv[] = {"/bin/sleep", "99"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&initProcSettings, initArgv, ARRAYSIZE(initArgv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &initProcSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
// Positive: exec an echo command and verify its output.
{
WslcProcessSettings execProcSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&execProcSettings));
const char* execArgv[] = {"/bin/echo", "exec-hello"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&execProcSettings, execArgv, ARRAYSIZE(execArgv)));
UniqueProcess execProcess;
VERIFY_SUCCEEDED(WslcCreateContainerProcess(container.get(), &execProcSettings, &execProcess, nullptr));
auto output = WaitForProcessOutput(execProcess.get());
VERIFY_ARE_EQUAL(output.stdoutOutput, "exec-hello\n");
}
// Negative: process settings with no command line must fail.
{
WslcProcessSettings emptyProcSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&emptyProcSettings));
WslcProcess newProcess = nullptr;
VERIFY_ARE_EQUAL(WslcCreateContainerProcess(container.get(), &emptyProcSettings, &newProcess, nullptr), E_INVALIDARG);
VERIFY_IS_NULL(newProcess);
}
// Negative: null newProcess output pointer must fail.
{
WslcProcessSettings execProcSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&execProcSettings));
const char* execArgv[] = {"/bin/echo", "x"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&execProcSettings, execArgv, ARRAYSIZE(execArgv)));
VERIFY_ARE_EQUAL(WslcCreateContainerProcess(container.get(), &execProcSettings, nullptr, nullptr), E_POINTER);
}
}
WSLC_TEST_METHOD(ContainerHostName)
{
// Unit: setting a hostname succeeds.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsHostName(&containerSettings, "test-host"));
}
// Functional: container process should see the configured hostname.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/hostname"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsHostName(&containerSettings, "my-test-host"));
auto output = RunContainerAndCapture(m_defaultSession, containerSettings);
VERIFY_ARE_EQUAL(output.stdoutOutput, "my-test-host\n");
}
}
WSLC_TEST_METHOD(ContainerDomainName)
{
// Unit: setting a domain name succeeds.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsDomainName(&containerSettings, "my.domain"));
}
// Functional: container should see the configured domain name.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sh", "-c", "echo $(domainname)"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsDomainName(&containerSettings, "test.local"));
auto output = RunContainerAndCapture(m_defaultSession, containerSettings);
VERIFY_ARE_EQUAL(output.stdoutOutput, "test.local\n");
}
}
WSLC_TEST_METHOD(ProcessEnvVariables)
{
// Negative: null pointer with nonzero count must fail.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
VERIFY_ARE_EQUAL(WslcSetProcessSettingsEnvVariables(&procSettings, nullptr, 1), E_INVALIDARG);
}
// Negative: non-null pointer with zero count must fail.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* envVars[] = {"FOO=bar"};
VERIFY_ARE_EQUAL(WslcSetProcessSettingsEnvVariables(&procSettings, envVars, 0), E_INVALIDARG);
}
// Positive: null pointer with zero count must succeed (clears env vars).
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
VERIFY_SUCCEEDED(WslcSetProcessSettingsEnvVariables(&procSettings, nullptr, 0));
}
// Functional: set an env var and verify it is visible inside the container.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sh", "-c", "echo $MY_TEST_VAR"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
const char* envVars[] = {"MY_TEST_VAR=hello-from-test"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsEnvVariables(&procSettings, envVars, ARRAYSIZE(envVars)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
auto output = RunContainerAndCapture(m_defaultSession, containerSettings);
VERIFY_ARE_EQUAL(output.stdoutOutput, "hello-from-test\n");
}
}
WSLC_TEST_METHOD(ProcessSignal)
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sleep", "99"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
HANDLE exitEvent = nullptr;
VERIFY_SUCCEEDED(WslcGetProcessExitEvent(process.get(), &exitEvent));
// Positive: SIGKILL the running process.
VERIFY_SUCCEEDED(WslcSignalProcess(process.get(), WSLC_SIGNAL_SIGKILL));
// The process exit event should fire after the signal.
VERIFY_ARE_EQUAL(WaitForSingleObject(exitEvent, 30 * 1000), static_cast<DWORD>(WAIT_OBJECT_0));
// Negative: null process handle must return an error.
VERIFY_ARE_EQUAL(WslcSignalProcess(nullptr, WSLC_SIGNAL_SIGKILL), E_POINTER);
}
WSLC_TEST_METHOD(ProcessGetPid)
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sleep", "99"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
// Positive: PID of a running process must be non-zero.
uint32_t pid = 0;
VERIFY_SUCCEEDED(WslcGetProcessPid(process.get(), &pid));
VERIFY_IS_TRUE(pid > 0);
// Negative: null pid pointer must fail.
VERIFY_ARE_EQUAL(WslcGetProcessPid(process.get(), nullptr), E_POINTER);
// Negative: null process handle must return an error.
WslcProcess nullProcess = nullptr;
VERIFY_ARE_EQUAL(WslcGetProcessPid(nullProcess, &pid), E_POINTER);
}
WSLC_TEST_METHOD(ProcessGetExitCode)
{
auto RunAndGetProcess = [&](int exitCodeArg) -> UniqueProcess {
std::string script = "exit " + std::to_string(exitCodeArg);
const char* argv[] = {"/bin/sh", "-c", script.c_str()};
WslcProcessSettings procSettings;
THROW_IF_FAILED(WslcInitProcessSettings(&procSettings));
THROW_IF_FAILED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
THROW_IF_FAILED(WslcInitContainerSettings("debian:latest", &containerSettings));
THROW_IF_FAILED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
THROW_IF_FAILED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
THROW_IF_FAILED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
THROW_IF_FAILED(WslcGetContainerInitProcess(container.get(), &process));
HANDLE exitEvent = nullptr;
THROW_IF_FAILED(WslcGetProcessExitEvent(process.get(), &exitEvent));
THROW_HR_IF(HRESULT_FROM_WIN32(WAIT_TIMEOUT), WaitForSingleObject(exitEvent, 30 * 1000) != WAIT_OBJECT_0);
return process;
};
auto RunAndGetExitCode = [&](int exitCodeArg) -> INT32 {
UniqueProcess process = RunAndGetProcess(exitCodeArg);
INT32 code = -1;
THROW_IF_FAILED(WslcGetProcessExitCode(process.get(), &code));
return code;
};
// Positive: verify exit 0 and exit 42 are reported correctly.
VERIFY_ARE_EQUAL(RunAndGetExitCode(0), 0);
VERIFY_ARE_EQUAL(RunAndGetExitCode(42), 42);
// Negative: null exit code pointer must fail.
{
auto process = RunAndGetProcess(0);
VERIFY_ARE_EQUAL(WslcGetProcessExitCode(process.get(), nullptr), E_POINTER);
}
// Negative: null process handle must return an error.
{
WslcProcess nullProcess = nullptr;
INT32 code = 0;
VERIFY_ARE_EQUAL(WslcGetProcessExitCode(nullProcess, &code), E_POINTER);
}
}
WSLC_TEST_METHOD(ProcessGetState)
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sleep", "99"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
HANDLE exitEvent = nullptr;
VERIFY_SUCCEEDED(WslcGetProcessExitEvent(process.get(), &exitEvent));
// State while running: RUNNING.
{
WslcProcessState state{};
VERIFY_SUCCEEDED(WslcGetProcessState(process.get(), &state));
VERIFY_ARE_EQUAL(state, WSLC_PROCESS_STATE_RUNNING);
}
// Bonus test for exit code while running
{
INT32 exitCode{};
VERIFY_ARE_EQUAL(WslcGetProcessExitCode(process.get(), &exitCode), HRESULT_FROM_WIN32(ERROR_INVALID_STATE));
VERIFY_ARE_EQUAL(exitCode, -1);
}
// Kill the process and wait for the exit event.
VERIFY_SUCCEEDED(WslcSignalProcess(process.get(), WSLC_SIGNAL_SIGKILL));
VERIFY_ARE_EQUAL(WaitForSingleObject(exitEvent, 30 * 1000), static_cast<DWORD>(WAIT_OBJECT_0));
// State after kill: SIGNALLED or EXITED.
{
WslcProcessState state{};
VERIFY_SUCCEEDED(WslcGetProcessState(process.get(), &state));
VERIFY_IS_TRUE(state == WSLC_PROCESS_STATE_SIGNALLED || state == WSLC_PROCESS_STATE_EXITED);
}
// Negative: null state pointer must fail.
VERIFY_ARE_EQUAL(WslcGetProcessState(process.get(), nullptr), E_POINTER);
// Negative: null process handle must return an error.
{
WslcProcess nullProcess = nullptr;
WslcProcessState state{};
VERIFY_ARE_EQUAL(WslcGetProcessState(nullProcess, &state), E_POINTER);
}
}
WSLC_TEST_METHOD(ProcessWorkingDirectory)
{
// Unit: setting a working directory returns S_OK.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
VERIFY_SUCCEEDED(WslcSetProcessSettingsWorkingDirectory(&procSettings, "/tmp"));
}
// Negative: null processSettings must fail.
VERIFY_ARE_EQUAL(WslcSetProcessSettingsWorkingDirectory(nullptr, "/tmp"), E_POINTER);
// Functional: verify pwd reports the configured working directory.
{
auto output = RunContainerAndCapture(m_defaultSession, "debian:latest", {"/bin/pwd"});
// Default working directory baseline — just verify pwd succeeds.
VERIFY_IS_FALSE(output.stdoutOutput.empty());
}
// Functional: set working directory to /tmp and verify pwd output.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/pwd"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
VERIFY_SUCCEEDED(WslcSetProcessSettingsWorkingDirectory(&procSettings, "/tmp"));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
auto output = RunContainerAndCapture(m_defaultSession, containerSettings);
VERIFY_ARE_EQUAL(output.stdoutOutput, "/tmp\n");
}
}
WSLC_TEST_METHOD(GetVersion)
{
// Positive: returns S_OK and fills in a non-zero version.
{
WslcVersion version{};
VERIFY_SUCCEEDED(WslcGetVersion(&version));
VERIFY_IS_TRUE(version.major > 0 || version.minor > 0 || version.revision > 0);
}
// Negative: null pointer must fail.
VERIFY_ARE_EQUAL(WslcGetVersion(nullptr), E_POINTER);
}
WSLC_TEST_METHOD(GetMissingComponents)
{
WslcComponentFlags missing{};
VERIFY_SUCCEEDED(WslcGetMissingComponents(&missing));
// Presumably anywhere that we run the tests we should get these results.
// The levels of OS state modification required to test beyond this are beyond the scope of these tests.
VERIFY_ARE_EQUAL(missing, WSLC_COMPONENT_FLAG_NONE);
}
// -----------------------------------------------------------------------
// WslcSetProcessSettingsCallbacks tests
// -----------------------------------------------------------------------
WSLC_TEST_METHOD(ProcessIoCallbackUnit)
{
auto noopIoCb = [](WslcProcessIOHandle, const BYTE*, uint32_t, PVOID) {};
auto noopExitCb = [](INT32, PVOID) {};
// Negative: null processSettings must fail.
{
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = noopIoCb;
VERIFY_ARE_EQUAL(WslcSetProcessSettingsCallbacks(nullptr, &callbacks, nullptr), E_POINTER);
}
// Negative: null callbacks pointer with non-null context must fail.
{
int ctx = 0;
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
VERIFY_ARE_EQUAL(WslcSetProcessSettingsCallbacks(&procSettings, nullptr, &ctx), E_INVALIDARG);
}
// Positive: null callbacks pointer with null context clears all callbacks.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, nullptr, nullptr));
}
// Positive: set onStdOut only.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = noopIoCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, nullptr));
}
// Positive: set onStdErr only.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
WslcProcessCallbacks callbacks{};
callbacks.onStdErr = noopIoCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, nullptr));
}
// Positive: set onExit only.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
WslcProcessCallbacks callbacks{};
callbacks.onExit = noopExitCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, nullptr));
}
// Positive: set all three callbacks with a context.
{
int ctx = 0;
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = noopIoCb;
callbacks.onStdErr = noopIoCb;
callbacks.onExit = noopExitCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, &ctx));
}
// Negative: StartContainer without ATTACH fails when callbacks are registered.
// The ATTACH flag is required so the IOCallback can claim the init process pipe handles.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sleep", "1"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = noopIoCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, nullptr));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_ARE_EQUAL(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr), E_INVALIDARG);
}
}
WSLC_TEST_METHOD(ProcessIoCallbackInitProcess)
{
struct IOContext
{
std::string stdoutData;
std::string stderrData;
} ioContext;
// Both streams share one callback; ioHandle distinguishes which accumulator to use.
auto ioCb = [](WslcProcessIOHandle ioHandle, const BYTE* data, uint32_t size, PVOID ctx) {
auto* c = static_cast<IOContext*>(ctx);
auto& target = (ioHandle == WSLC_PROCESS_IO_HANDLE_STDOUT) ? c->stdoutData : c->stderrData;
target.append(reinterpret_cast<const char*>(data), size);
};
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sh", "-c", "echo STDOUT && echo STDERR >&2"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = ioCb;
callbacks.onStdErr = ioCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, &ioContext));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
HANDLE exitEvent = nullptr;
VERIFY_SUCCEEDED(WslcGetProcessExitEvent(process.get(), &exitEvent));
VERIFY_ARE_EQUAL(WaitForSingleObject(exitEvent, 30 * 1000), static_cast<DWORD>(WAIT_OBJECT_0));
// Release the process handle first, then the container handle.
// Releasing the container destroys the WslcContainerImpl which joins the IOCallback
// thread, guaranteeing all bytes have been delivered before the assertions below.
process.reset();
container.reset();
VERIFY_ARE_EQUAL(ioContext.stdoutData, "STDOUT\n");
VERIFY_ARE_EQUAL(ioContext.stderrData, "STDERR\n");
}
WSLC_TEST_METHOD(ProcessIoCallbackExecProcess)
{
// Start a long-running container so we can exec into it.
WslcProcessSettings initProcSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&initProcSettings));
const char* initArgv[] = {"/bin/sleep", "99"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&initProcSettings, initArgv, ARRAYSIZE(initArgv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &initProcSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
struct IOContext
{
std::string stdoutData;
std::string stderrData;
} ioContext;
auto ioCb = [](WslcProcessIOHandle ioHandle, const BYTE* data, uint32_t size, PVOID ctx) {
auto* c = static_cast<IOContext*>(ctx);
auto& target = (ioHandle == WSLC_PROCESS_IO_HANDLE_STDOUT) ? c->stdoutData : c->stderrData;
target.append(reinterpret_cast<const char*>(data), size);
};
WslcProcessSettings execProcSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&execProcSettings));
const char* execArgv[] = {"/bin/sh", "-c", "echo EXEC_OUT && echo EXEC_ERR >&2"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&execProcSettings, execArgv, ARRAYSIZE(execArgv)));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = ioCb;
callbacks.onStdErr = ioCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&execProcSettings, &callbacks, &ioContext));
UniqueProcess execProcess;
VERIFY_SUCCEEDED(WslcCreateContainerProcess(container.get(), &execProcSettings, &execProcess, nullptr));
HANDLE exitEvent = nullptr;
VERIFY_SUCCEEDED(WslcGetProcessExitEvent(execProcess.get(), &exitEvent));
VERIFY_ARE_EQUAL(WaitForSingleObject(exitEvent, 30 * 1000), static_cast<DWORD>(WAIT_OBJECT_0));
// Releasing the exec process handle destroys WslcProcessImpl and joins its IOCallback
// thread, ensuring all bytes are delivered before assertions.
execProcess.reset();
VERIFY_ARE_EQUAL(ioContext.stdoutData, "EXEC_OUT\n");
VERIFY_ARE_EQUAL(ioContext.stderrData, "EXEC_ERR\n");
}
WSLC_TEST_METHOD(ProcessIoCallbackHandleExclusion)
{
// Register a stdout callback only. IOCallback always acquires ALL pipe handles
// (draining uncallbacked streams to prevent deadlock), so both stdout and stderr
// handles are consumed and neither can be obtained via WslcGetProcessIOHandle.
auto noopIoCb = [](WslcProcessIOHandle, const BYTE*, uint32_t, PVOID) {};
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sleep", "99"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = noopIoCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, nullptr));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
// stdout handle was consumed by the IOCallback — must not be obtainable.
{
HANDLE h = nullptr;
VERIFY_ARE_EQUAL(WslcGetProcessIOHandle(process.get(), WSLC_PROCESS_IO_HANDLE_STDOUT, &h), HRESULT_FROM_WIN32(ERROR_INVALID_STATE));
}
// stderr handle was also consumed in order to drain it despite not being given a callback.
{
HANDLE h = nullptr;
VERIFY_ARE_EQUAL(WslcGetProcessIOHandle(process.get(), WSLC_PROCESS_IO_HANDLE_STDERR, &h), HRESULT_FROM_WIN32(ERROR_INVALID_STATE));
}
}
WSLC_TEST_METHOD(ProcessIoCallbackExitCallback)
{
// Verify the onExit callback fires with the correct exit code after IO has been flushed.
// We test both exit 0 and a non-zero exit code.
auto RunAndCaptureExit = [&](int exitCodeArg) -> std::pair<INT32, std::string> {
std::string stdoutData;
std::atomic<INT32> capturedExitCode{-999};
struct Context
{
std::string* stdoutData;
std::atomic<INT32>* capturedExitCode;
wil::unique_event exitEvent{wil::EventOptions::ManualReset};
} ctx{&stdoutData, &capturedExitCode};
auto ioCb = [](WslcProcessIOHandle, const BYTE* data, uint32_t size, PVOID c) {
static_cast<Context*>(c)->stdoutData->append(reinterpret_cast<const char*>(data), size);
};
auto exitCb = [](INT32 code, PVOID c) {
static_cast<Context*>(c)->capturedExitCode->store(code);
static_cast<Context*>(c)->exitEvent.SetEvent();
};
std::string script = "echo HELLO && exit " + std::to_string(exitCodeArg);
const char* argv[] = {"/bin/sh", "-c", script.c_str()};
WslcProcessSettings procSettings;
THROW_IF_FAILED(WslcInitProcessSettings(&procSettings));
THROW_IF_FAILED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = ioCb;
callbacks.onExit = exitCb;
THROW_IF_FAILED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, &ctx));
WslcContainerSettings containerSettings;
THROW_IF_FAILED(WslcInitContainerSettings("debian:latest", &containerSettings));
THROW_IF_FAILED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
THROW_IF_FAILED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
THROW_IF_FAILED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
THROW_IF_FAILED(WslcGetContainerInitProcess(container.get(), &process));
THROW_HR_IF(HRESULT_FROM_WIN32(WAIT_TIMEOUT), WaitForSingleObject(ctx.exitEvent.get(), 60 * 1000) != WAIT_OBJECT_0);
return {capturedExitCode.load(), stdoutData};
};
// Exit 0: onExit must fire with code 0; IO must have been delivered first.
{
auto [exitCode, output] = RunAndCaptureExit(0);
VERIFY_ARE_EQUAL(exitCode, 0);
VERIFY_ARE_EQUAL(output, "HELLO\n");
}
// Non-zero exit: onExit must report the correct code.
{
auto [exitCode, output] = RunAndCaptureExit(42);
VERIFY_ARE_EQUAL(exitCode, 42);
VERIFY_ARE_EQUAL(output, "HELLO\n");
}
}
WSLC_TEST_METHOD(ProcessIoCallbackCancelOnRelease)
{
// Verify that releasing the process handle while an exec'd process is still running
// and writing IO cancels the IOCallback pump:
// - No IO callbacks arrive after the handle is released.
// - onExit is never invoked (cancellation returns runResult=false, suppressing it).
//
// A secondary (exec'd) process is used so that the long-lived init process keeps the
// container alive, allowing UniqueContainer to clean up normally at scope exit.
// Start a long-running init process to keep the container alive.
WslcProcessSettings initProcSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&initProcSettings));
const char* initArgv[] = {"/bin/sleep", "999"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&initProcSettings, initArgv, ARRAYSIZE(initArgv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &initProcSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
struct Context
{
std::atomic<int> callbackCount{0};
std::atomic<bool> exitFired{false};
} ctx;
auto ioCb = [](WslcProcessIOHandle, const BYTE*, uint32_t, PVOID c) {
static_cast<Context*>(c)->callbackCount.fetch_add(1);
};
auto exitCb = [](INT32, PVOID c) { static_cast<Context*>(c)->exitFired.store(true); };
// Continuous writer: emits one line every 50 ms indefinitely.
WslcProcessSettings execProcSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&execProcSettings));
const char* execArgv[] = {"/bin/sh", "-c", "while true; do echo LINE; sleep 0.05; done"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&execProcSettings, execArgv, ARRAYSIZE(execArgv)));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = ioCb;
callbacks.onExit = exitCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&execProcSettings, &callbacks, &ctx));
UniqueProcess execProcess;
VERIFY_SUCCEEDED(WslcCreateContainerProcess(container.get(), &execProcSettings, &execProcess, nullptr));
// Wait long enough for at least several callbacks to arrive.
Sleep(500);
VERIFY_IS_TRUE(ctx.callbackCount.load() > 0);
// Release the exec process handle while the process is still running and writing.
// This destructs WslcProcessImpl → cancels the IOCallback → joins its thread.
// By the time execProcess.reset() returns, the pump thread has exited.
execProcess.reset();
// Snapshot the count now that the thread is confirmed stopped.
int countAtRelease = ctx.callbackCount.load();
// onExit must not have fired: cancellation sets runResult=false, suppressing the call.
VERIFY_IS_FALSE(ctx.exitFired.load());
// Wait another interval — no further callbacks can arrive after the thread has joined.
Sleep(200);
VERIFY_ARE_EQUAL(ctx.callbackCount.load(), countAtRelease);
VERIFY_IS_FALSE(ctx.exitFired.load());
}
WSLC_TEST_METHOD(ProcessIoCallbackLargeOutput)
{
// Generate ~1 MiB of stdout via: dd if=/dev/zero bs=1024 count=1024 | base64
// 1,048,576 zero bytes → base64 output is 1,398,104 bytes (ceil(1048576/3)*4).
static constexpr size_t c_expectedBytes = 1'398'104;
std::string stdoutData;
stdoutData.reserve(c_expectedBytes + 4096);
auto ioCb = [](WslcProcessIOHandle, const BYTE* data, uint32_t size, PVOID ctx) {
static_cast<std::string*>(ctx)->append(reinterpret_cast<const char*>(data), size);
};
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sh", "-c", "dd if=/dev/zero bs=1024 count=1024 2>/dev/null | base64 -w 0"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = ioCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, &stdoutData));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
HANDLE exitEvent = nullptr;
VERIFY_SUCCEEDED(WslcGetProcessExitEvent(process.get(), &exitEvent));
VERIFY_ARE_EQUAL(WaitForSingleObject(exitEvent, 60 * 1000), static_cast<DWORD>(WAIT_OBJECT_0));
// Join the IOCallback thread before inspecting the accumulator.
process.reset();
container.reset();
VERIFY_ARE_EQUAL(stdoutData.size(), c_expectedBytes);
}
WSLC_TEST_METHOD(ReleaseFromIOCallbackFails)
{
struct Context
{
std::atomic<WslcProcess> process{nullptr};
std::atomic<WslcContainer> container{nullptr};
std::atomic<HRESULT> releaseProcessHr{S_OK};
std::atomic<HRESULT> releaseContainerHr{S_OK};
std::atomic<bool> captured{false};
wil::unique_event done{wil::EventOptions::ManualReset};
} ctx;
auto ioCb = [](WslcProcessIOHandle, const BYTE*, uint32_t, PVOID c) {
auto* cx = static_cast<Context*>(c);
// Wait until the test thread has published both handles before sampling.
auto process = cx->process.load(std::memory_order_acquire);
auto container = cx->container.load(std::memory_order_acquire);
if (!process || !container)
{
return;
}
// Only capture on the first eligible callback; later callbacks no-op.
bool expected = false;
if (!cx->captured.compare_exchange_strong(expected, true))
{
return;
}
// Both calls should fail with ERROR_INVALID_HANDLE_STATE without consuming the handles.
cx->releaseProcessHr.store(WslcReleaseProcess(process));
cx->releaseContainerHr.store(WslcReleaseContainer(container));
cx->done.SetEvent();
};
// Continuous writer for the init process so onStdOut fires repeatedly.
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sh", "-c", "while true; do echo LINE; sleep 0.05; done"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcProcessCallbacks callbacks{};
callbacks.onStdOut = ioCb;
VERIFY_SUCCEEDED(WslcSetProcessSettingsCallbacks(&procSettings, &callbacks, &ctx));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
UniqueContainer container;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
UniqueProcess process;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &process));
// Publish handles to the callback now that both are valid.
ctx.container.store(container.get(), std::memory_order_release);
ctx.process.store(process.get(), std::memory_order_release);
VERIFY_ARE_EQUAL(WaitForSingleObject(ctx.done.get(), 30 * 1000), static_cast<DWORD>(WAIT_OBJECT_0));
VERIFY_ARE_EQUAL(ctx.releaseProcessHr.load(), HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE_STATE));
VERIFY_ARE_EQUAL(ctx.releaseContainerHr.load(), HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE_STATE));
}
// -----------------------------------------------------------------------
// Storage tests
// -----------------------------------------------------------------------
WSLC_TEST_METHOD(SessionCreateVhd)
{
constexpr auto c_volumeName = "wslc-test-data-vol";
constexpr auto c_vhdSizeBytes = _1GB;
std::filesystem::path vhdSessionStorage = m_storagePath / "wslc-vhd-test-storage";
auto removeStorage = wil::scope_exit([&]() {
std::error_code error;
std::filesystem::remove_all(vhdSessionStorage, error);
if (error)
{
LogError("Failed to remove VHD test storage %ws: %hs", vhdSessionStorage.c_str(), error.message().c_str());
}
});
// Create a dedicated session so that volume creation does not affect the shared default session.
WslcSessionSettings sessionSettings;
VERIFY_SUCCEEDED(WslcInitSessionSettings(L"wslc-vhd-test", vhdSessionStorage.c_str(), &sessionSettings));
WslcVhdRequirements sessionVhd{};
sessionVhd.sizeBytes = 4 * _1GB;
sessionVhd.type = WSLC_VHD_TYPE_DYNAMIC;
VERIFY_SUCCEEDED(WslcSetSessionSettingsVhd(&sessionSettings, &sessionVhd));
UniqueSession session;
VERIFY_SUCCEEDED(WslcCreateSession(&sessionSettings, &session, nullptr));
// Load debian so we have a container image to work with.
std::filesystem::path debianTar = GetTestImagePath("debian:latest");
VERIFY_SUCCEEDED(WslcLoadSessionImageFromFile(session.get(), debianTar.c_str(), nullptr, nullptr));
// Positive: create a named VHD volume in the session.
{
WslcVhdRequirements vhd{};
vhd.name = c_volumeName;
vhd.sizeBytes = c_vhdSizeBytes;
vhd.type = WSLC_VHD_TYPE_DYNAMIC;
wil::unique_cotaskmem_string errorMsg;
VERIFY_SUCCEEDED(WslcCreateSessionVhdVolume(session.get(), &vhd, &errorMsg));
// The backing VHD file must exist on disk.
std::filesystem::path expectedVhdPath = vhdSessionStorage / "volumes" / (std::string(c_volumeName) + ".vhdx");
VERIFY_IS_TRUE(std::filesystem::exists(expectedVhdPath));
}
// Positive: write a marker via a container that mounts the named volume.
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sh", "-c", "echo wslc-vhd-test > /data/marker.txt"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
WslcContainerNamedVolume namedVol{};
namedVol.name = c_volumeName;
namedVol.containerPath = "/data";
namedVol.readOnly = FALSE;
VERIFY_SUCCEEDED(WslcSetContainerSettingsNamedVolumes(&containerSettings, &namedVol, 1));
auto output = RunContainerAndCapture(session.get(), containerSettings);
VERIFY_IS_TRUE(output.stderrOutput.empty());
}
// Positive: read back the marker in a second container (read-only mount).
{
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/bin/sh", "-c", "cat /data/marker.txt"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
WslcContainerNamedVolume namedVol{};
namedVol.name = c_volumeName;
namedVol.containerPath = "/data";
namedVol.readOnly = TRUE;
VERIFY_SUCCEEDED(WslcSetContainerSettingsNamedVolumes(&containerSettings, &namedVol, 1));
auto output = RunContainerAndCapture(session.get(), containerSettings);
VERIFY_ARE_EQUAL(output.stdoutOutput, "wslc-vhd-test\n");
}
// Positive: delete the volume.
{
wil::unique_cotaskmem_string errorMsg;
VERIFY_SUCCEEDED(WslcDeleteSessionVhdVolume(session.get(), c_volumeName, &errorMsg));
// The backing VHD file must not exist on disk.
std::filesystem::path expectedVhdPath = vhdSessionStorage / "volumes" / (std::string(c_volumeName) + ".vhdx");
VERIFY_IS_FALSE(std::filesystem::exists(expectedVhdPath));
}
// Negative: null options pointer must fail.
VERIFY_ARE_EQUAL(WslcCreateSessionVhdVolume(session.get(), nullptr, nullptr), E_POINTER);
// Negative: null name must fail.
{
WslcVhdRequirements vhd{};
vhd.name = nullptr;
vhd.sizeBytes = c_vhdSizeBytes;
vhd.type = WSLC_VHD_TYPE_DYNAMIC;
VERIFY_ARE_EQUAL(WslcCreateSessionVhdVolume(session.get(), &vhd, nullptr), E_INVALIDARG);
}
// Negative: zero sizeInBytes must fail.
{
WslcVhdRequirements vhd{};
vhd.name = c_volumeName;
vhd.sizeBytes = 0;
vhd.type = WSLC_VHD_TYPE_DYNAMIC;
VERIFY_ARE_EQUAL(WslcCreateSessionVhdVolume(session.get(), &vhd, nullptr), E_INVALIDARG);
}
// Negative: invalid VHD type must fail.
{
WslcVhdRequirements vhd{};
vhd.name = c_volumeName;
vhd.sizeBytes = c_vhdSizeBytes;
vhd.type = static_cast<WslcVhdType>(42);
VERIFY_ARE_EQUAL(WslcCreateSessionVhdVolume(session.get(), &vhd, nullptr), E_INVALIDARG);
}
// Positive: fixed-allocation VHD; on-disk file size must be >= SizeBytes.
{
constexpr auto c_fixedVolumeName = "wslc-sdk-vhd-fixed";
constexpr auto c_fixedSizeBytes = 64ull * _1MB;
WslcVhdRequirements vhd{};
vhd.name = c_fixedVolumeName;
vhd.sizeBytes = c_fixedSizeBytes;
vhd.type = WSLC_VHD_TYPE_FIXED;
wil::unique_cotaskmem_string errorMsg;
VERIFY_SUCCEEDED(WslcCreateSessionVhdVolume(session.get(), &vhd, &errorMsg));
auto deleteVolume =
wil::scope_exit([&]() { LOG_IF_FAILED(WslcDeleteSessionVhdVolume(session.get(), c_fixedVolumeName, nullptr)); });
std::filesystem::path expectedVhdPath = vhdSessionStorage / "volumes" / (std::string(c_fixedVolumeName) + ".vhdx");
VERIFY_IS_TRUE(std::filesystem::exists(expectedVhdPath));
VERIFY_IS_GREATER_THAN_OR_EQUAL(std::filesystem::file_size(expectedVhdPath), c_fixedSizeBytes);
}
// Positive: owner flags are honored — uid/gid baked into the volume root
// inode at mkfs time. Verify by stat-ing the mount inside a container.
{
constexpr auto c_ownedVolumeName = "wslc-sdk-vhd-owned";
WslcVhdRequirements vhd{};
vhd.name = c_ownedVolumeName;
vhd.sizeBytes = c_vhdSizeBytes;
vhd.type = WSLC_VHD_TYPE_DYNAMIC;
vhd.flags = WSLC_VHD_REQ_FLAG_OWNER;
vhd.uid = 65534; // nobody
vhd.gid = 65534; // nogroup
wil::unique_cotaskmem_string errorMsg;
VERIFY_SUCCEEDED(WslcCreateSessionVhdVolume(session.get(), &vhd, &errorMsg));
auto deleteVolume =
wil::scope_exit([&]() { LOG_IF_FAILED(WslcDeleteSessionVhdVolume(session.get(), c_ownedVolumeName, nullptr)); });
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
const char* argv[] = {"/usr/bin/stat", "-c", "%u %g", "/data"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
WslcContainerNamedVolume namedVol{};
namedVol.name = c_ownedVolumeName;
namedVol.containerPath = "/data";
namedVol.readOnly = FALSE;
VERIFY_SUCCEEDED(WslcSetContainerSettingsNamedVolumes(&containerSettings, &namedVol, 1));
auto output = RunContainerAndCapture(session.get(), containerSettings);
VERIFY_ARE_EQUAL(output.stdoutOutput, "65534 65534\n");
}
// Negative: unknown flag bits are rejected.
{
WslcVhdRequirements vhd{};
vhd.name = c_volumeName;
vhd.sizeBytes = c_vhdSizeBytes;
vhd.type = WSLC_VHD_TYPE_DYNAMIC;
vhd.flags = static_cast<WslcVhdRequirementsFlags>(0x80000000);
VERIFY_ARE_EQUAL(WslcCreateSessionVhdVolume(session.get(), &vhd, nullptr), E_INVALIDARG);
}
// Positive: flags=NONE silently ignores uid/gid (volume defaults to root:root).
{
constexpr auto c_unflaggedVolumeName = "wslc-sdk-vhd-unflagged";
WslcVhdRequirements vhd{};
vhd.name = c_unflaggedVolumeName;
vhd.sizeBytes = c_vhdSizeBytes;
vhd.type = WSLC_VHD_TYPE_DYNAMIC;
vhd.flags = WSLC_VHD_REQ_FLAG_NONE;
vhd.uid = 1000;
vhd.gid = 1000;
wil::unique_cotaskmem_string errorMsg;
VERIFY_SUCCEEDED(WslcCreateSessionVhdVolume(session.get(), &vhd, &errorMsg));
wil::unique_cotaskmem_string deleteErr;
VERIFY_SUCCEEDED(WslcDeleteSessionVhdVolume(session.get(), c_unflaggedVolumeName, &deleteErr));
}
}
// -----------------------------------------------------------------------
// Authentication helpers
// -----------------------------------------------------------------------
// Starts a local registry container with host-mode networking and returns [container, registryAddress].
// Uses the COM API (via GetInternalType) with WSLCContainerLauncher to get host-mode networking,
// which the SDK doesn't expose. Host networking shares the VM's network namespace, so the registry
// is reachable at 127.0.0.1:<port> from both dockerd (inside the VM) and the host.
std::pair<wsl::windows::common::RunningWSLCContainer, std::string> StartLocalRegistry(
const std::string& username = {}, const std::string& password = {}, uint16_t port = 5000)
{
VERIFY_IS_TRUE(HasImage("wslc-registry:latest"));
std::vector<std::string> env = {std::format("REGISTRY_HTTP_ADDR=0.0.0.0:{}", port)};
if (!username.empty())
{
env.push_back(std::format("USERNAME={}", username));
env.push_back(std::format("PASSWORD={}", password));
}
wsl::windows::common::WSLCContainerLauncher launcher("wslc-registry:latest", {}, {}, env);
launcher.SetEntrypoint({"/entrypoint.sh"});
launcher.AddPort(port, port, AF_INET);
// Get the IWSLCSession COM object from the SDK session handle.
auto& session = *reinterpret_cast<WslcSessionImpl*>(m_defaultSession)->session;
auto container = launcher.Launch(session, WSLCContainerStartFlagsNone);
auto registryAddress = std::format("127.0.0.1:{}", port);
// Wait for the registry to be ready by probing from the host.
auto hostUrl = std::format(L"http://{}", registryAddress);
ExpectHttpResponse(hostUrl.c_str(), 200, true);
return {std::move(container), registryAddress};
}
// Tags and pushes an image to a local registry via the SDK APIs.
void PushImageToRegistry(const std::string& repo, const std::string& tag, const std::string& registryAddress, const std::string& registryAuth)
{
auto imageName = std::format("{}:{}", repo, tag);
auto registryImage = std::format("{}/{}:{}", registryAddress, repo, tag);
auto registryRepo = std::format("{}/{}", registryAddress, repo);
VERIFY_IS_TRUE(HasImage(imageName));
// Tag the image with the registry address so it can be pushed.
WslcTagImageOptions tagOptions{};
tagOptions.image = imageName.c_str();
tagOptions.repo = registryRepo.c_str();
tagOptions.tag = tag.c_str();
VERIFY_SUCCEEDED(WslcTagSessionImage(m_defaultSession, &tagOptions, nullptr));
// Ensures the registry-prefixed tag is removed after the push.
auto cleanup = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, [&]() {
LOG_IF_FAILED(WslcDeleteSessionImage(m_defaultSession, registryImage.c_str(), nullptr));
});
WslcPushImageOptions pushOptions{};
pushOptions.image = registryImage.c_str();
pushOptions.registryAuth = registryAuth.c_str();
VERIFY_SUCCEEDED(WslcPushSessionImage(m_defaultSession, &pushOptions, nullptr));
}
bool HasImage(const std::string& imageName)
{
wil::unique_cotaskmem_array_ptr<WslcImageInfo> images;
VERIFY_SUCCEEDED(WslcListSessionImages(m_defaultSession, images.addressof(), images.size_address<uint32_t>()));
for (const auto& image : images)
{
if (image.name == imageName)
{
return true;
}
}
return false;
}
// -----------------------------------------------------------------------
// Authentication tests
// -----------------------------------------------------------------------
WSLC_TEST_METHOD(AuthenticateTests)
{
constexpr auto c_username = "wslctest";
constexpr auto c_password = "password";
auto [registryContainer, registryAddress] = StartLocalRegistry(c_username, c_password);
// Negative: wrong password must fail.
{
wil::unique_cotaskmem_ansistring token;
wil::unique_cotaskmem_string errorMsg;
VERIFY_ARE_EQUAL(
WslcSessionAuthenticate(m_defaultSession, registryAddress.c_str(), c_username, "wrong-password", &token, &errorMsg), E_FAIL);
VERIFY_IS_NOT_NULL(errorMsg.get());
}
// Positive: correct credentials must succeed and return a non-null token.
{
wil::unique_cotaskmem_ansistring token;
wil::unique_cotaskmem_string errorMsg;
VERIFY_SUCCEEDED(WslcSessionAuthenticate(m_defaultSession, registryAddress.c_str(), c_username, c_password, &token, &errorMsg));
VERIFY_IS_NOT_NULL(token.get());
}
auto xRegistryAuth = wsl::windows::common::wslutil::BuildRegistryAuthHeader(c_username, c_password);
PushImageToRegistry("hello-world", "latest", registryAddress, xRegistryAuth);
auto image = std::format("{}/hello-world:latest", registryAddress);
// Pulling with credentials should succeed.
{
WslcPullImageOptions opts{};
opts.uri = image.c_str();
opts.registryAuth = xRegistryAuth.c_str();
VERIFY_SUCCEEDED(WslcPullSessionImage(m_defaultSession, &opts, nullptr));
VERIFY_IS_TRUE(HasImage(image));
}
// Negative: Pulling without credentials should fail.
{
WslcPullImageOptions opts{};
opts.uri = image.c_str();
wil::unique_cotaskmem_string errorMsg;
VERIFY_ARE_EQUAL(WslcPullSessionImage(m_defaultSession, &opts, &errorMsg), E_FAIL);
VERIFY_IS_NOT_NULL(errorMsg.get());
}
// Negative: Pulling with bad credentials should fail.
{
auto badAuth = wsl::windows::common::wslutil::BuildRegistryAuthHeader(c_username, "wrong");
WslcPullImageOptions opts{};
opts.uri = image.c_str();
opts.registryAuth = badAuth.c_str();
wil::unique_cotaskmem_string errorMsg;
VERIFY_ARE_EQUAL(WslcPullSessionImage(m_defaultSession, &opts, &errorMsg), E_FAIL);
VERIFY_IS_NOT_NULL(errorMsg.get());
}
// Negative: null parameters must fail.
{
wil::unique_cotaskmem_ansistring token;
VERIFY_ARE_EQUAL(WslcSessionAuthenticate(m_defaultSession, nullptr, c_username, c_password, &token, nullptr), E_POINTER);
VERIFY_ARE_EQUAL(WslcSessionAuthenticate(m_defaultSession, registryAddress.c_str(), nullptr, c_password, &token, nullptr), E_POINTER);
VERIFY_ARE_EQUAL(WslcSessionAuthenticate(m_defaultSession, registryAddress.c_str(), c_username, nullptr, &token, nullptr), E_POINTER);
VERIFY_ARE_EQUAL(WslcSessionAuthenticate(m_defaultSession, registryAddress.c_str(), c_username, c_password, nullptr, nullptr), E_POINTER);
}
}
WSLC_TEST_METHOD(PullImage)
{
// Start a local registry without auth to avoid Docker Hub rate limits.
auto [registryContainer, registryAddress] = StartLocalRegistry();
auto xRegistryAuth = wsl::windows::common::wslutil::BuildRegistryAuthHeader("", "");
{
// Push hello-world:latest to the local registry.
PushImageToRegistry("hello-world", "latest", registryAddress, xRegistryAuth);
auto image = std::format("{}/hello-world:latest", registryAddress);
// Delete the image locally so the pull is a real pull.
WslcDeleteSessionImage(m_defaultSession, image.c_str(), nullptr);
// Pull from the local registry.
{
WslcPullImageOptions opts{};
opts.uri = image.c_str();
VERIFY_SUCCEEDED(WslcPullSessionImage(m_defaultSession, &opts, nullptr));
}
// Verify the pulled image is in the image list.
VERIFY_IS_TRUE(HasImage(image));
// Verify the image is usable by running a container from it.
auto output = RunContainerAndCapture(m_defaultSession, image.c_str(), {});
VERIFY_IS_TRUE(output.stdoutOutput.find("Hello from Docker!") != std::string::npos);
}
// Negative: pull an image that does not exist.
{
auto image = std::format("{}/does-not-exist", registryAddress);
WslcPullImageOptions opts{};
opts.uri = image.c_str();
opts.registryAuth = xRegistryAuth.c_str();
wil::unique_cotaskmem_string errorMsg;
VERIFY_ARE_EQUAL(WslcPullSessionImage(m_defaultSession, &opts, &errorMsg), WSLC_E_IMAGE_NOT_FOUND);
}
// Negative: null URI inside options must fail.
{
WslcPullImageOptions opts{};
opts.uri = nullptr;
wil::unique_cotaskmem_string errorMsg;
VERIFY_ARE_EQUAL(WslcPullSessionImage(m_defaultSession, &opts, &errorMsg), E_INVALIDARG);
}
}
WSLC_TEST_METHOD(PushImage)
{
auto emptyRegistryAuth = wsl::windows::common::wslutil::BuildRegistryAuthHeader("", "");
// Negative: pushing a non-existent image must fail.
{
WslcPushImageOptions opts{};
opts.image = "does-not-exist";
opts.registryAuth = emptyRegistryAuth.c_str();
wil::unique_cotaskmem_string errorMsg;
VERIFY_ARE_EQUAL(WslcPushSessionImage(m_defaultSession, &opts, &errorMsg), E_FAIL);
VERIFY_IS_NOT_NULL(errorMsg.get());
}
// Negative: null options must fail.
VERIFY_ARE_EQUAL(WslcPushSessionImage(m_defaultSession, nullptr, nullptr), E_POINTER);
// Negative: null image inside options must fail.
{
WslcPushImageOptions opts{};
opts.image = nullptr;
opts.registryAuth = emptyRegistryAuth.c_str();
VERIFY_ARE_EQUAL(WslcPushSessionImage(m_defaultSession, &opts, nullptr), E_INVALIDARG);
}
}
WSLC_TEST_METHOD(TagImage)
{
// Positive: tag an existing image.
{
WslcTagImageOptions opts{};
opts.image = "debian:latest";
opts.repo = "debian";
opts.tag = "sdk-test-tag";
VERIFY_SUCCEEDED(WslcTagSessionImage(m_defaultSession, &opts, nullptr));
// Verify the tag is present.
VERIFY_IS_TRUE(HasImage("debian:sdk-test-tag"));
// Cleanup: delete the tag.
WslcDeleteSessionImage(m_defaultSession, "debian:sdk-test-tag", nullptr);
}
// Negative: null options must fail.
VERIFY_ARE_EQUAL(WslcTagSessionImage(m_defaultSession, nullptr, nullptr), E_POINTER);
// Negative: null fields must fail.
{
WslcTagImageOptions opts{};
opts.image = nullptr;
opts.repo = "debian";
opts.tag = "test";
VERIFY_ARE_EQUAL(WslcTagSessionImage(m_defaultSession, &opts, nullptr), E_INVALIDARG);
}
{
WslcTagImageOptions opts{};
opts.image = "debian:latest";
opts.repo = nullptr;
opts.tag = "test";
VERIFY_ARE_EQUAL(WslcTagSessionImage(m_defaultSession, &opts, nullptr), E_INVALIDARG);
}
{
WslcTagImageOptions opts{};
opts.image = "debian:latest";
opts.repo = "debian";
opts.tag = nullptr;
VERIFY_ARE_EQUAL(WslcTagSessionImage(m_defaultSession, &opts, nullptr), E_INVALIDARG);
}
}
// Negative tests: handle lifecycle and invalid state transitions
WSLC_TEST_METHOD(ReleaseNullSessionHandle)
{
VERIFY_ARE_EQUAL(WslcReleaseSession(nullptr), E_POINTER);
}
WSLC_TEST_METHOD(TerminateNullSessionHandle)
{
VERIFY_ARE_EQUAL(WslcTerminateSession(nullptr), E_POINTER);
}
WSLC_TEST_METHOD(ReleaseNullContainerHandle)
{
VERIFY_ARE_EQUAL(WslcReleaseContainer(nullptr), E_POINTER);
}
WSLC_TEST_METHOD(ReleaseNullProcessHandle)
{
VERIFY_ARE_EQUAL(WslcReleaseProcess(nullptr), E_POINTER);
}
WSLC_TEST_METHOD(CreateContainerWithNullSession)
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
WslcContainer container = nullptr;
VERIFY_ARE_EQUAL(WslcCreateContainer(nullptr, &containerSettings, &container, nullptr), E_POINTER);
}
WSLC_TEST_METHOD(StopContainerWithInvalidSignal)
{
UniqueContainer container;
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
PCSTR argv[] = {"/bin/sleep", "10"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_ATTACH, nullptr));
// Wait for the short-lived init process to exit
UniqueProcess initProcess;
VERIFY_SUCCEEDED(WslcGetContainerInitProcess(container.get(), &initProcess));
HANDLE exitEvent = nullptr;
VERIFY_SUCCEEDED(WslcGetProcessExitEvent(initProcess.get(), &exitEvent));
VERIFY_ARE_EQUAL(WAIT_OBJECT_0, WaitForSingleObject(exitEvent, 30000));
// Attempting to exec on a stopped container should fail
WslcProcessSettings execSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&execSettings));
PCSTR execArgv[] = {"/bin/echo", "should-fail"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&execSettings, execArgv, ARRAYSIZE(execArgv)));
UniqueProcess execProcess;
VERIFY_ARE_EQUAL(WslcCreateContainerProcess(container.get(), &execSettings, &execProcess, nullptr), WSLC_E_CONTAINER_NOT_RUNNING);
}
WSLC_TEST_METHOD(DuplicateContainerName)
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
PCSTR argv[] = {"/bin/sleep", "10"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsName(&containerSettings, "duplicate-name-test"));
UniqueContainer container1;
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container1, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container1.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
// Creating a second container with the same name should fail
UniqueContainer container2;
VERIFY_ARE_EQUAL(WslcCreateContainer(m_defaultSession, &containerSettings, &container2, nullptr), static_cast<HRESULT>(0x800700b7)); // ERROR_ALREADY_EXISTS
}
WSLC_TEST_METHOD(DeleteRunningContainerWithoutForce)
{
UniqueContainer container;
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
WslcProcessSettings procSettings;
VERIFY_SUCCEEDED(WslcInitProcessSettings(&procSettings));
PCSTR argv[] = {"/bin/sleep", "10"};
VERIFY_SUCCEEDED(WslcSetProcessSettingsCmdLine(&procSettings, argv, ARRAYSIZE(argv)));
VERIFY_SUCCEEDED(WslcSetContainerSettingsInitProcess(&containerSettings, &procSettings));
VERIFY_SUCCEEDED(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr));
VERIFY_SUCCEEDED(WslcStartContainer(container.get(), WSLC_CONTAINER_START_FLAG_NONE, nullptr));
// Deleting a running container without force flag should fail
VERIFY_ARE_EQUAL(WslcDeleteContainer(container.get(), WSLC_DELETE_CONTAINER_FLAG_NONE, nullptr), WSLC_E_CONTAINER_IS_RUNNING);
}
WSLC_TEST_METHOD(DeleteNonExistentImage)
{
VERIFY_ARE_EQUAL(WslcDeleteSessionImage(m_defaultSession, "nonexistent-image:this-tag-does-not-exist", nullptr), WSLC_E_IMAGE_NOT_FOUND);
}
WSLC_TEST_METHOD(PullInvalidImageUri)
{
WslcPullImageOptions pullOptions = {};
pullOptions.uri = "///invalid-registry-url///";
VERIFY_ARE_EQUAL(WslcPullSessionImage(m_defaultSession, &pullOptions, nullptr), E_INVALIDARG);
}
WSLC_TEST_METHOD(ContainerGpu)
{
// Validate that creating a GPU container on a session without GPU support fails.
{
WslcContainerSettings containerSettings;
VERIFY_SUCCEEDED(WslcInitContainerSettings("debian:latest", &containerSettings));
VERIFY_SUCCEEDED(WslcSetContainerSettingsFlags(&containerSettings, WSLC_CONTAINER_FLAG_ENABLE_GPU));
UniqueContainer container;
VERIFY_ARE_EQUAL(WslcCreateContainer(m_defaultSession, &containerSettings, &container, nullptr), HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED));
}
// Create a GPU-enabled session.
std::filesystem::path gpuStorage = m_storagePath / "wslc-gpu-session-storage";
auto cleanupStorage = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, [&] {
std::error_code error;
std::filesystem::remove_all(gpuStorage, error);
});
WslcSessionSettings sessionSettings;
VERIFY_SUCCEEDED(WslcInitSessionSettings(L"wslc-gpu-test", gpuStorage.c_str(), &sessionSettings));
VERIFY_SUCCEEDED(WslcSetSessionSettingsFeatureFlags(&sessionSettings, WSLC_SESSION_FEATURE_FLAG_ENABLE_GPU));
WslcVhdRequirements vhdReqs{};
vhdReqs.sizeBytes = 4096ull * 1024 * 1024;
vhdReqs.type = WSLC_VHD_TYPE_DYNAMIC;
VERIFY_SUCCEEDED(WslcSetSessionSettingsVhd(&sessionSettings, &vhdReqs));
UniqueSession gpuSession;
VERIFY_SUCCEEDED(WslcCreateSession(&sessionSettings, &gpuSession, nullptr));
THROW_IF_FAILED(WslcLoadSessionImageFromFile(gpuSession.get(), GetTestImagePath("debian:latest").c_str(), nullptr, nullptr));
// Validate /dev/dxg is available and the dynamic linker is configured to resolve the WSL
// GPU libraries.
{
const char* initArgv[] = {
"/bin/sh", "-c", "test -c /dev/dxg && test -r /dev/dxg && test -w /dev/dxg && cat /etc/ld.so.conf.d/ld.wsl.conf"};
auto output = RunContainerAndCapture(
gpuSession.get(), "debian:latest", {initArgv[0], initArgv[1], initArgv[2]}, WSLC_CONTAINER_FLAG_ENABLE_GPU);
VERIFY_ARE_EQUAL(output.stdoutOutput, "/usr/lib/wsl/lib\n");
}
}
};
Reference in New Issue View Git Blame Copy Permalink