Draft integration tests for Ark by lionel- · Pull Request #542 · posit-dev/ark

lionel- · 2024-09-23T13:56:40Z

Export Amalthea client harness as DummyFrontend.
Export start_r so it can be used in unit tests. Moved from main.rs to start.rs (I took the opportunity to move things around in main.rs for clarity but no changes to the code).
Draft kernel protocol tests in ark/tests/kernel.rs.

TODO: Flesh out tests so that we can be confident we don't break anything in #536

DavisVaughan · 2024-09-23T18:33:54Z

@@ -42,4 +42,4 @@ jobs:
      - name: Run Unit Tests


Candidate integration test #536 (comment)

quote( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa )

It should error after processing the 2nd line

DavisVaughan · 2024-09-24T18:24:08Z

@@ -19,7 +19,10 @@ jobs:
          - { rust: 'nightly' }


Candidate integration test #536 (comment)

It should error when processing the extremely long arbitrary user input

readline("hi") hi # provide the text below as the reply aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

lionel- · 2024-09-25T11:33:58Z

The dummy kernel is now a singleton object. Call the lock() method to initialize it if needed, and lock access to the singleton in a test thread.

When the lock guard goes out of scope, it checks that all sockets have no incoming data. This way we don't forget to assert replies from the backend and we make sure the tests are (mostly) independent, which is important since they share the same R and kernel instances.
DummyFrontend in Amalthea gains many more methods to receive and assert specific messages. The goal is to allow very terse tests that are easy to write.
I've moved start_r() to RMain::start().
New RMain::wait_r_initialized() method. This is a thread-safe method that resolves when R has finished starting up. Used in the dummy kernel.
RMain::initialized() has been reworked so it's thread-safe. That was not necessary here but it seems like a good principle for all static methods to be callable from another thread.
We now detect R_HOME from the PATH via R RHOME. This helps with unit tests. Following this change we no longer hard-code R_HOME into installed kernel specs, which allows users to control which version of R to run by manipulating their PATH. While I was in there I also set RUST_LOG to "error" to address Ark: Jupyter: Verbose logging makes jupyter-console unusable positron#2098.
We now implement the Suicide frontend method so that we get an error message an a backtrace when R fails to start up. (Done as part of debugging CI failures)
@DavisVaughan determined yesterday that CI was failing because cfg() doesn't run in integration tests (tests in crate/tests as opposed to crate/src). To fix this, we now use a global variable aliased to the presence of a testing feature flag in the harp crate to decide whether to set unlimited stack space (needed in unit tests since they access R from different threads).

Here is the motivation for this unusual setup:
- Unfortunately we can't use cfg(test) in integration tests because they
  are treated as an external crate.
- Unfortunately we cannot move some of our integration tests to src/
  because they must be run in their own process (e.g. because they are
  running R).
- Unfortunately we can't use the workaround described in
  Activating features for tests/benchmarks rust-lang/cargo#2911 (comment)
  to enable a test-only feature in a self dependency in the dev-deps section
  of the manifest file because Rust-Analyzer doesn't support such
  circular dependencies: dev-dependencies on workspace member cause cyclic dependency issues rust-lang/rust-analyzer#14167.
  So instead we use the same trick with harp rather than ark, so that there
  is no circular dependency, which fixes the issue with Rust-Analyzer.
- Unfortunately we can't query the features enabled in a dependency with cfg.
  So instead we define a global variable here that can then be checked at
  runtime in Ark.

lionel- · 2024-09-25T12:41:34Z

It's probably worth merging in this state because I'm encountering protocol issues when trying to make a test for errors.

DavisVaughan · 2024-09-25T12:48:07Z

Would you mind using the new testing global to get rid of the true argument of modules::initialize(true)? I think that would be useful / more consistent if that is possible

lionel- · 2024-09-25T13:01:55Z

Good idea, done!

DavisVaughan · 2024-09-26T14:31:08Z


 [dev-dependencies]
 insta = { version = "1.39.0" }
+harp = { path = "../harp", features = ["testing"]}


So a dev-dependency takes priority over a normal dependency?

In tests dev-deps are taken into account. Then, IIUC, feature unification (https://doc.rust-lang.org/cargo/reference/features.html#feature-unification) causes the testing flag to be added.

Now if we were able to set that path to something completely different without causing a conflict, then I guess the normal dep is overridden by the dev-dep as you suggest.

https://doc.rust-lang.org/cargo/reference/resolver.html#feature-resolver-version-2 suggests that it's indeed a matter of unification. And for this to work correctly (no unification with dev-deps when not building tests), we need the version 2 of the resolver, which we were already using.

I've now documented our new reliance on that version:

# Was necessary after switching to dev tree-sitter to fix this warning: # > some crates are on edition 2021 which defaults to `resolver = "2"`, but # > virtual workspaces default to `resolver = "1"`. # # Also necessary to enable the `testing` feature of harp only when testing # (i.e. when building downstream packages like Ark with Harp's `testing` # feature set in `dev-dependencies`). resolver = "2"

DavisVaughan · 2024-09-26T14:47:31Z

+        // Get `R_HOME`, set by Positron / CI / kernel specification
+        let r_home = match std::env::var("R_HOME") {
+            Ok(home) => PathBuf::from(home),
+            Err(_) => {
+                // Get `R_HOME` from `PATH`, via R
+                let Ok(result) = std::process::Command::new("R").arg("RHOME").output() else {
+                    panic!("Can't find R or `R_HOME`");
+                };
+                let r_home = String::from_utf8(result.stdout).unwrap();
+                let r_home = r_home.trim();
+                std::env::set_var("R_HOME", r_home);
+                PathBuf::from(r_home)
+            },
+        };


Addresses posit-dev/positron#2111?

DavisVaughan · 2024-09-26T15:00:25Z

+            // Internal initialisation flag, should only be used on the R thread
            self.initializing = false;
+
+            // Used as thread-safe initialisation flag
+            R_INIT.set(()).unwrap();


Should we get rid of initializing and add a is_r_initialized() helper that we use in the 2 places we check self.initializing?

That would make sense but we'd get into naming conflicts with the static methods so probably not worth changing.

This is only used in WriteConsole so I've decided we don't need to worry about synchronisation overhead here, and we now use the thread-safe RMain::is_r_initialized() instead of the boolean flag to make things simpler.

DavisVaughan · 2024-09-26T15:01:40Z

+    /// Wait for `RMain` singleton initialization
+    ///
+    /// Note that R might still not have finished starting up.
+    /// See `wait_r_initialized()`.
+    ///
+    /// Thread-safe. But note you can only get access to the singleton on the R
+    /// thread.
+    pub fn wait_initialized() {
+        R_MAIN_INIT.wait();
+    }


I am noting that currently we don't use this

I added it for #506, though we eventually determined we could just assume R and RMain are both initialized. I think it makes sense to keep it in the API.

After writing this documentation:

/// Thread-safe, but note: /// - Shouldn't be called from the R thread. If you're on the R thread, it /// means that either R is initialized, or something is very wrong and waiting /// would cause a deadlock anyway. /// - You can wait for `RMAIN` to be initialized in another thread, but you /// can only get access to the singleton on the R thread.

I decided to remove it from the API 🤣

Checks for crumbs on drop

Let Ark detect it from the search path via `R RHOME`

And rename `RMain::initialized()` to `RMain::is_initialized()` and make it thread-safe. It seems safer for static methods of `RMain` should be made thread-safe.

And use `RMain::is_r_initialized()` instead

lionel- force-pushed the feature/client-tests branch from c141f24 to acba1cb Compare September 23, 2024 14:09

DavisVaughan reviewed Sep 23, 2024

View reviewed changes

lionel- force-pushed the feature/client-tests branch 5 times, most recently from 0f1e2f7 to 5729312 Compare September 24, 2024 13:29

DavisVaughan reviewed Sep 24, 2024

View reviewed changes

lionel- force-pushed the feature/client-tests branch 3 times, most recently from f33d1c3 to ea8dda0 Compare September 25, 2024 11:18

lionel- changed the title ~~WIP: Integration tests for Ark~~ Draft integration tests for Ark Sep 25, 2024

lionel- requested a review from DavisVaughan September 25, 2024 12:40

lionel- mentioned this pull request Sep 26, 2024

Reticulate support #506

Merged

lionel- force-pushed the feature/client-tests branch from 3129047 to 1ab75fe Compare September 26, 2024 11:28

lionel- mentioned this pull request Sep 26, 2024

Add integration test for R errors #547

Merged

DavisVaughan approved these changes Sep 26, 2024

View reviewed changes

lionel- added 9 commits September 27, 2024 09:46

Rename Frontend to DummyFrontend

6ef1332

Export DummyFrontend from Amalthea

6ecf5a9

Rename shell_tx to iopub_tx

843f7cc

Export start_kernel() for tests

7392c20

Add scaffholding for protocol tests

8457652

Fix R arguments

001850f

Implement suicide hook

7210e8a

Wrap dummy Ark frontend in singleton

8500112

Checks for crumbs on drop

Export DummyArkFrontend from Ark

4441514

lionel- added 25 commits September 27, 2024 09:46

Add more wrapper methods

788b0ca

Rename receive_ prefix to recv_

7f024e9

Rename test/test.rs to test/utils.rs

e5c2ea4

Don't set R_HOME in kernel spec

0288a3b

Let Ark detect it from the search path via `R RHOME`

Set RUST_LOG in kernel spec

3f469a8

Move start_r() to RMain::start()

6c6866f

Add RMain::wait_r_initialized()

13fc7e6

And rename `RMain::initialized()` to `RMain::is_initialized()` and make it thread-safe. It seems safer for static methods of `RMain` should be made thread-safe.

Set unlimited stack size in unit tests

c7a4adc

Enable test-only features for integration tests

242359d

Set stack size after initializing R

51fdd2d

Set Suicide on Windows

beb5ff1

Use IS_TESTING in modules::initialize()

ba22890

Add RMain::wait_initialized()

b1847e9

Provide debug information about incoming data

ff4ef91

Comment on use of once_cell::Lazy

1353cf8

Use OnceLock instead of once_cell::Lazy

4945eba

Move test fixtures to src/fixtures

3229efb

Reuse socket receivers

a50b20e

Fix typo in .complete_initialization()

dd5240a

Include review suggestions

0e927ee

Remove wait_initialized()

a62db57

Use IS_TESTING instead of RMain::is_initialized()

755a0e9

Use RMain::is_initialized() after all

47af0ad

Panic if RMain::start() is called more than once

fafbd8c

Remove RMain::initializing flag

1f5753d

And use `RMain::is_r_initialized()` instead

lionel- force-pushed the feature/client-tests branch from 0196e97 to 1f5753d Compare September 27, 2024 09:11

Document reliance on resolver's version 2

5af6ba6

lionel- merged commit 6705951 into main Sep 27, 2024

lionel- deleted the feature/client-tests branch September 27, 2024 09:23

github-actions Bot locked and limited conversation to collaborators Sep 27, 2024

Conversation

lionel- commented Sep 23, 2024

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

lionel- commented Sep 25, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

lionel- commented Sep 25, 2024

Uh oh!

DavisVaughan commented Sep 25, 2024

Uh oh!

lionel- commented Sep 25, 2024

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

lionel- commented Sep 25, 2024 •

edited

Loading