Function test_run_after_break_starts_from_beginning

std/src/program.rs:998–1055

()

    #[test]
    fn test_run_after_break_starts_from_beginning() {
        let console = Rc::from(RefCell::from(MockConsole::default()));
        let program = Rc::from(RefCell::from(RecordedProgram::default()));
        program.borrow_mut().load(None, r#"PRINT "begin": SLEEP 0: PRINT "done""#);

        let (signals_tx, signals_rx) = async_channel::unbounded();
        let signal_sent = Rc::from(RefCell::from(false));
        let sleep_tx = signals_tx.clone();
        let sleep_signal_sent = signal_sent.clone();
        let datetime = Rc::from(MockDateTime::default());
        datetime.set_sleep_fn(Box::new(
            move |_d: Duration| -> futures_lite::future::BoxedLocal<Result<(), String>> {
                let sleep_tx = sleep_tx.clone();
                let sleep_signal_sent = sleep_signal_sent.clone();
                async move {
                    if !*sleep_signal_sent.borrow() {
                        *sleep_signal_sent.borrow_mut() = true;
                        sleep_tx.send(Signal::Break).await.unwrap();
                    }
                    Ok(())
                }
                .boxed_local()
            },
        ));

        let storage = Rc::from(RefCell::from(Storage::default()));
        let mut machine = MachineBuilder::default()
            .with_console(console.clone())
            .with_signals_chan((signals_tx, signals_rx))
            .with_datetime(datetime)
            .make_interactive()
            .with_program(program)
            .with_storage(storage)
            .build();

        machine.compile(&mut "RUN".as_bytes()).unwrap();
        match block_on(machine.exec()) {
            Err(crate::Error::Break) => (),
            r => panic!("Expected Break but got {:?}", r),
        }

        machine.compile(&mut "RUN".as_bytes()).unwrap();
        match block_on(machine.exec()) {
            Ok(None) => (),
            r => panic!("Expected successful completion but got {:?}", r),
        }

        let prints: Vec<String> = console
            .borrow_mut()
            .take_captured_out()
            .into_iter()
            .filter_map(|out| match out {
                CapturedOut::Print(text) => Some(text),
                _ => None,
            })
            .collect();
        assert_eq!(vec!["begin", "begin", "done"], prints);
    }