Jengamon/bevy_games - Change LOXMWV3OSAWZFCORHIBGHMCI4OTDQPNYD4CREMLLXIBO24AUI7OQC

write tests

Created by Jengamon on April 20, 2024

LOXMWV3OSAWZFCORHIBGHMCI4OTDQPNYD4CREMLLXIBO24AUI7OQC

Dependencies

[2] 57S64Z47SHSHO23K7VPUFBJETNVYBPK47BSIHJCW572KIUVF52HQC

In channels

main

Change contents

Insertion in bullet_hell/src/simple_bt/composite.rs at line 11 [2.2717]
[2.2880]
[2.2880]
```
#[allow(unused_imports)]
```
Insertion in bullet_hell/src/simple_bt/composite.rs at line 13 [2.2717]
[2.2908]
[2.2908]
```
#[allow(unused_imports)]
```
Insertion in bullet_hell/src/simple_bt/composite.rs at line 15 [2.2717]
[2.2977]
[2.2977]
```
#[allow(unused_imports)]
```
Insertion in bullet_hell/src/simple_bt/composite.rs at line 17 [2.2717]
[2.3005]
[2.3005]
```
#[allow(unused_imports)]
```
Insertion in bullet_hell/src/simple_bt/composite.rs at line 19 [2.2717]
[2.3033]
[2.3033]
```
#[allow(unused_imports)]
```

Insertion in bullet_hell/src/simple_bt/composite.rs at line 21 [2.2717]

[2.3063]


// Utilities for testing
#[cfg(test)]
mod tests {
    use crate::simple_bt::BehaviorRunner;
    pub(super) struct Context {
        pub stack: Vec<i32>,
    }
    pub(super) fn test_with_context<F>(
        init_context: F,
        mut runner: BehaviorRunner<Context>,
        running_limit: usize,
    ) -> (Option<bool>, Context)
    where
        F: FnOnce() -> Context,
    {
        let mut context = init_context();
        let mut running_count = 0;
        let mut res = None;
        while res.is_none() {
            if running_count >= running_limit {
                return (None, context);
            }
            res = runner.proceed(&mut context);
            if res.is_none() {
                running_count += 1;
            }
        }
        (res, context)
    }
}

Replacement in bullet_hell/src/simple_bt/composite/sequence.rs at line 74 [2.4262]

B:BD[2.6640] → [2.6640:6713]

        for (idx, sub) in self.seq.iter().enumerate().skip(self.index) {

[2.6640]

[2.6713]

        for (idx, sub) in self.seq.iter().enumerate().skip(self.index + 1) {

Replacement in bullet_hell/src/simple_bt/composite/sequence.rs at line 90 [2.4262]

B:BD[2.7165] → [2.7165:7207]

    use crate::simple_bt::BehaviorRunner;

[2.7165]

[2.7207]

    use crate::simple_bt::{
        composite::tests::{test_with_context, Context},
        BehaviorRunner,
    };

Insertion in bullet_hell/src/simple_bt/composite/sequence.rs at line 119 [2.4262]

[2.7927]

            }
        }
    }
    #[derive(Debug)]
    struct TwoStepPush {
        payload: i32,
        fail: bool,
        step: usize,
    }
    impl BehaviorNode<Context> for TwoStepPush {
        fn tick(&self, context: &mut Context) -> NodeResult<Context> {
            if self.step < 1 {
                NodeResult::Running(
                    Self {
                        payload: self.payload,
                        fail: self.fail,
                        step: self.step + 1,
                    }
                    .arc(),
                )
            } else {
                context.stack.push(self.payload);
                if self.fail {
                    NodeResult::Failure
                } else {
                    NodeResult::Success
                }

Insertion in bullet_hell/src/simple_bt/composite/sequence.rs at line 153 [2.4262]

[2.7970]

    fn sequence_resumes_after_tried_node() {
        let runner = BehaviorRunner::new(
            vec![
                TwoStepPush {
                    payload: 1,
                    fail: false,
                    step: 0,
                }
                .arc(),
                TwoStepPush {
                    payload: 2,
                    fail: false,
                    step: 0,
                }
                .arc(),
            ]
            .into_iter()
            .collect::<Sequence<_>>()
            .arc(),
        );
        let (res, context) = test_with_context(|| Context { stack: Vec::new() }, runner, 10);
        check!(res == Some(true));
        check!(context.stack == vec![1, 2]);
    }
    #[test]

Replacement in bullet_hell/src/simple_bt/composite/selector.rs at line 74 [2.8775]

B:BD[2.11153] → [2.11153:11226]

        for (idx, sub) in self.seq.iter().enumerate().skip(self.index) {

[2.11153]

[2.11226]

        for (idx, sub) in self.seq.iter().enumerate().skip(self.index + 1) {

Replacement in bullet_hell/src/simple_bt/composite/selector.rs at line 88 [2.8775]

B:BD[2.11613] → [2.11613:11626]

mod tests {}

[2.11613]

mod tests {
    use assert2::check;
    use super::*;
    use crate::simple_bt::{
        composite::tests::{test_with_context, Context},
        BehaviorNode, BehaviorRunner, NodeResult,
    };
    #[derive(Debug)]
    struct TwoStepPush {
        payload: i32,
        fail: bool,
        step: usize,
    }
    impl BehaviorNode<Context> for TwoStepPush {
        fn tick(&self, context: &mut Context) -> NodeResult<Context> {
            if self.step < 1 {
                NodeResult::Running(
                    Self {
                        payload: self.payload,
                        fail: self.fail,
                        step: self.step + 1,
                    }
                    .arc(),
                )
            } else {
                context.stack.push(self.payload);
                if self.fail {
                    NodeResult::Failure
                } else {
                    NodeResult::Success
                }
            }
        }
    }
    #[test]
    fn selector_skips_tried_node() {
        let runner = BehaviorRunner::new(
            vec![
                TwoStepPush {
                    payload: 1,
                    fail: true,
                    step: 0,
                }
                .arc(),
                TwoStepPush {
                    payload: 2,
                    fail: false,
                    step: 0,
                }
                .arc(),
            ]
            .into_iter()
            .collect::<Selector<_>>()
            .arc(),
        );
        let (res, context) = test_with_context(|| Context { stack: Vec::new() }, runner, 10);
        check!(res == Some(true));
        check!(context.stack == vec![1, 2]);
    }
}

Replacement in bullet_hell/src/simple_bt/composite/repeater.rs at line 31 [2.11663]

B:BD[2.12415] → [2.12415:12927]

            match resume.tick(blackboard) {
                NodeResult::Running(resume) => {
                    return NodeResult::Running(
                        Self {
                            resume: Some(resume),
                            child: self.child.clone(),
                        }
                        .arc(),
                    )
                }
                _ => {}
            }
        }
        match self.child.tick(blackboard) {
            NodeResult::Running(resume) => {

[2.12415]

[2.12927]

            if let NodeResult::Running(resume) = resume.tick(blackboard) {

Replacement in bullet_hell/src/simple_bt/composite/repeater.rs at line 38 [2.11663]
B:BD[2.13145] → [2.13145:13163]
```
                )
```
[2.13145]
[2.13163]
```
                );
```

Replacement in bullet_hell/src/simple_bt/composite/repeater.rs at line 40 [2.11663]

B:BD[2.13177] → [2.13177:13197]

            _ => {}

[2.13177]

[2.13197]

        }
        if let NodeResult::Running(resume) = self.child.tick(blackboard) {
            return NodeResult::Running(
                Self {
                    resume: Some(resume),
                    child: self.child.clone(),
                }
                .arc(),
            );

Insertion in bullet_hell/src/simple_bt/composite/repeater.rs at line 64 [2.11663]

[2.13518]

    resume: Option<BehaviorArc<B>>,
}
impl<B> LimitedRepeated<B> {
    pub fn new(limit: usize, child: BehaviorArc<B>) -> Self {
        Self {
            child,
            limit,
            completed: 0,
            resume: None,
        }
    }

Replacement in bullet_hell/src/simple_bt/composite/repeater.rs at line 88 [2.11663]
B:BD[2.13837] → [2.13837:13886]
```
impl BehaviorNode for LimitedRepeated {
```
[2.13837]
[2.13886]
```
impl<B: 'static> BehaviorNode for LimitedRepeated {
```

Replacement in bullet_hell/src/simple_bt/composite/repeater.rs at line 90 [2.11663]

B:BD[2.13944] → [2.13944:13960]

        todo!()

[2.13944]

[2.13960]

        let mut completed = self.completed;
        if completed >= self.limit {
            return NodeResult::Success;
        }
        if let Some(resume) = self.resume.as_ref() {
            match resume.tick(blackboard) {
                NodeResult::Running(resume) => {
                    return NodeResult::Running(
                        Self {
                            resume: Some(resume),
                            child: self.child.clone(),
                            limit: self.limit,
                            completed: self.completed,
                        }
                        .arc(),
                    )
                }
                _ => {
                    completed += 1;
                }
            }
        }
        match self.child.tick(blackboard) {
            NodeResult::Running(resume) => {
                return NodeResult::Running(
                    Self {
                        resume: Some(resume),
                        child: self.child.clone(),
                        limit: self.limit,
                        completed,
                    }
                    .arc(),
                )
            }
            _ => {
                completed += 1;
            }
        }
        // Restart until we've completed the repetitions
        NodeResult::Running(Arc::new(Self {
            child: self.child.clone(),
            resume: None,
            limit: self.limit,
            completed,
        }))

Insertion in bullet_hell/src/simple_bt/composite/repeater.rs at line 143 [2.11663]
[2.14050]
[2.14050]
```
 resume: Option<BehaviorArc>,
```

Insertion in bullet_hell/src/simple_bt/composite/repeater.rs at line 147 [2.11663]

[2.14080]

impl<B> RepeatedUntilFailure<B> {
    pub fn new(child: BehaviorArc<B>) -> Self {
        Self {
            child,
            resume: None,
        }
    }
}

Replacement in bullet_hell/src/simple_bt/composite/repeater.rs at line 164 [2.11663]
B:BD[2.14316] → [2.14316:14370]
```
impl BehaviorNode for RepeatedUntilFailure {
```
[2.14316]
[2.14370]
```
impl<B: 'static> BehaviorNode for RepeatedUntilFailure {
```

Replacement in bullet_hell/src/simple_bt/composite/repeater.rs at line 166 [2.11663]

B:BD[2.14428] → [2.14428:14444]

        todo!()

[2.14428]

[2.14444]

        if let Some(resume) = self.resume.as_ref() {
            match resume.tick(blackboard) {
                NodeResult::Running(resume) => {
                    return NodeResult::Running(
                        Self {
                            resume: Some(resume),
                            child: self.child.clone(),
                        }
                        .arc(),
                    );
                }
                NodeResult::Failure => return NodeResult::Success,
                _ => (),
            }
        }
        match self.child.tick(blackboard) {
            NodeResult::Running(resume) => NodeResult::Running(
                Self {
                    resume: Some(resume),
                    child: self.child.clone(),
                }
                .arc(),
            ),
            NodeResult::Success => {
                // Restart whenever we succeed
                NodeResult::Running(Arc::new(Self {
                    child: self.child.clone(),
                    resume: None,
                }))
            }
            NodeResult::Failure => {
                // We have encounted a failure, so *succeed*
                NodeResult::Success
            }
        }

Replacement in bullet_hell/src/simple_bt/composite/repeater.rs at line 205 [2.11663]

B:BD[2.14466] → [2.14466:14479]

mod tests {}

[2.14466]

mod tests {
    use crate::simple_bt::{
        composite::{
            tests::{test_with_context, Context},
            Sequence,
        },
        BehaviorRunner,
    };
    use super::*;
    use assert2::check;
    #[derive(Debug)]
    struct Push1;
    impl BehaviorNode<Context> for Push1 {
        fn tick(&self, context: &mut Context) -> NodeResult<Context> {
            context.stack.push(1);
            NodeResult::Success
        }
    }
    #[derive(Debug)]
    struct FibPush;
    impl BehaviorNode<Context> for FibPush {
        fn tick(&self, context: &mut Context) -> NodeResult<Context> {
            if context.stack.len() < 2 {
                context.stack.push(1);
            } else {
                let len = context.stack.len();
                let a = context.stack[len - 2];
                let b = context.stack[len - 1];
                context.stack.push(a + b);
            }
            NodeResult::Success
        }
    }
    #[derive(Debug)]
    struct IsCapped {
        cap: i32,
    }
    impl BehaviorNode<Context> for IsCapped {
        fn tick(&self, context: &mut Context) -> NodeResult<Context> {
            if context.stack.iter().any(|v| *v > self.cap) {
                NodeResult::Failure
            } else {
                NodeResult::Success
            }
        }
    }
    #[test]
    fn limited_repeat_repeats_to_limit() {
        let runner = BehaviorRunner::new(LimitedRepeated::new(3, Push1.arc()).arc());
        let (res, context) = test_with_context(|| Context { stack: Vec::new() }, runner, 4);
        check!(res == Some(true));
        check!(context.stack == vec![1, 1, 1]);
    }
    #[test]
    fn repeat_until_failure_stops_on_failure() {
        let runner = BehaviorRunner::new(
            RepeatedUntilFailure::new(
                vec![FibPush.arc(), IsCapped { cap: 100 }.arc()]
                    .into_iter()
                    .collect::<Sequence<_>>()
                    .arc(),
            )
            .arc(),
        );
        let (res, context) = test_with_context(|| Context { stack: Vec::new() }, runner, 12);
        check!(res == Some(true));
        check!(context.stack == vec![1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]);
    }
}

Replacement in bullet_hell/src/simple_bt/composite/inverter.rs at line 35 [2.14516]

B:BD[2.15436] → [2.15436:15449]

mod tests {}

[2.15436]

mod tests {
    use assert2::check;
    use super::*;
    use crate::simple_bt::{
        composite::{
            tests::{test_with_context, Context},
            Succeeder,
        },
        BehaviorNode, BehaviorRunner, NodeResult,
    };
    #[derive(Debug)]
    struct SucceedAfterSteps {
        steps: u32,
        step: u32,
    }
    impl SucceedAfterSteps {
        fn new(steps: u32) -> Self {
            Self { steps, step: 0 }
        }
    }
    impl BehaviorNode<Context> for SucceedAfterSteps {
        fn tick(&self, _context: &mut Context) -> crate::simple_bt::NodeResult<Context> {
            if self.step < self.steps {
                NodeResult::Running(
                    Self {
                        steps: self.steps,
                        step: self.step + 1,
                    }
                    .arc(),
                )
            } else {
                NodeResult::Success
            }
        }
    }
    #[test]
    fn inverter_inverts_properly() {
        let runner1 =
            BehaviorRunner::new(Inverter::<Context>::new(Succeeder::default().arc()).arc());
        let (res, context) = test_with_context(|| Context { stack: Vec::new() }, runner1, 1);
        check!(res == Some(false));
        check!(context.stack == Vec::<i32>::new());
        let runner2 = BehaviorRunner::new(Inverter::new(SucceedAfterSteps::new(9).arc()).arc());
        let (res, context) = test_with_context(|| Context { stack: Vec::new() }, runner2, 10);
        check!(res == Some(false));
        check!(context.stack == Vec::<i32>::new());
    }
}

write tests

Dependencies

In channels

Change contents

Insertion in bullet_hell/src/simple_bt/composite.rs at line 11 [2.2717]

Insertion in bullet_hell/src/simple_bt/composite.rs at line 13 [2.2717]

Insertion in bullet_hell/src/simple_bt/composite.rs at line 15 [2.2717]

Insertion in bullet_hell/src/simple_bt/composite.rs at line 17 [2.2717]

Insertion in bullet_hell/src/simple_bt/composite.rs at line 19 [2.2717]