conpty-oxide 0.1.2

Correctness-first Windows ConPTY (pseudoconsole) library with sync and async (tokio) APIs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

// SPDX-FileCopyrightText: 2026 conpty-oxide contributors <https://github.com/P4suta/conpty-oxide/graphs/contributors>
//
// SPDX-License-Identifier: MIT OR Apache-2.0

//! Positive compile checks for the supported 0.1 surface.

use std::hash::Hash;

const fn assert_kind<T: Copy + Eq + Hash>() {}

#[test]
fn stable_root_types_compile() {
    assert_kind::<conpty_oxide::ErrorKind>();
    assert_kind::<conpty_oxide::BackendErrorKind>();

    let _: Option<conpty_oxide::Error> = None;
    let _: Option<conpty_oxide::BackendError> = None;
    let _: Option<conpty_oxide::ConPtyBackend> = None;
    let _: Option<conpty_oxide::Size> = None;
    let _: Option<conpty_oxide::ExitStatus> = None;
}

#[cfg(any(feature = "blocking", feature = "tokio"))]
const fn assert_shared_controller<T: Clone + Send + Sync>() {}

#[cfg(any(feature = "blocking", feature = "tokio"))]
#[test]
fn frontend_shared_types_compile() {
    assert_shared_controller::<conpty_oxide::PtyController>();
    let _: Option<conpty_oxide::SessionOptions> = None;
    let _: Option<conpty_oxide::SessionOutput> = None;
}

#[cfg(feature = "blocking")]
#[test]
fn blocking_surface_compiles() {
    use std::io::{Read, Write};
    use std::os::windows::io::AsHandle;

    fn command_methods(
        command: &mut conpty_oxide::blocking::Command,
        options: conpty_oxide::SessionOptions,
    ) -> conpty_oxide::Result<()> {
        command
            .arg("one")
            .args(["two"])
            .raw_arg(" three")
            .env("KEY", "VALUE")
            .envs([("OTHER", "VALUE")])
            .env_remove("KEY")
            .env_clear()
            .current_dir(".");
        let _: conpty_oxide::blocking::Session = command.spawn()?;
        let _: conpty_oxide::blocking::Session = command.spawn_with(options)?;
        Ok(())
    }

    fn collect_output(
        session: conpty_oxide::blocking::Session,
    ) -> conpty_oxide::Result<conpty_oxide::SessionOutput> {
        session.collect_output()
    }

    fn session_methods(session: &mut conpty_oxide::blocking::Session) -> conpty_oxide::Result<()> {
        let _: usize = session.read(&mut [])?;
        let _: usize = session.write(&[])?;
        let _: u32 = session.id();
        let _: Option<conpty_oxide::ExitStatus> = session.try_wait()?;
        let _: conpty_oxide::Size = session.size();
        let _: bool = session.supports_clear();
        session.resize(conpty_oxide::Size::default())?;
        let _ = session.clear();
        session.kill()
    }

    fn child_methods(child: &mut conpty_oxide::blocking::Child) -> conpty_oxide::Result<()> {
        let _ = child.as_handle();
        let _: u32 = child.id();
        let _: Option<conpty_oxide::ExitStatus> = child.try_wait()?;
        let _: conpty_oxide::ExitStatus = child.wait()?;
        child.kill()
    }

    let _ = (
        command_methods,
        collect_output,
        session_methods,
        child_methods,
    );
}

#[cfg(feature = "tokio")]
#[test]
fn tokio_surface_compiles() {
    use std::os::windows::io::AsHandle;

    fn command_methods(
        command: &mut conpty_oxide::tokio::Command,
        options: conpty_oxide::SessionOptions,
    ) -> conpty_oxide::Result<()> {
        command
            .arg("one")
            .args(["two"])
            .raw_arg(" three")
            .env("KEY", "VALUE")
            .envs([("OTHER", "VALUE")])
            .env_remove("KEY")
            .env_clear()
            .current_dir(".");
        let _: conpty_oxide::tokio::Session = command.spawn()?;
        let _: conpty_oxide::tokio::Session = command.spawn_with(options)?;
        Ok(())
    }

    fn child_methods(child: &mut conpty_oxide::tokio::Child) -> conpty_oxide::Result<()> {
        let _ = child.as_handle();
        let _: u32 = child.id();
        let _: Option<conpty_oxide::ExitStatus> = child.try_wait()?;
        child.kill()
    }

    async fn collect_output(
        session: conpty_oxide::tokio::Session,
    ) -> conpty_oxide::Result<conpty_oxide::SessionOutput> {
        session.collect_output().await
    }

    fn assert_async_io<T: ::tokio::io::AsyncRead + ::tokio::io::AsyncWrite>() {}
    assert_async_io::<conpty_oxide::tokio::Session>();
    let _ = (command_methods, collect_output, child_methods);
}