brigadier usages

12 files changed, 372 insertions, 43 deletions

diff --git a/azalea-brigadier/tests/arguments/mod.rs b/azalea-brigadier/tests/arguments/mod.rs
new file mode 100644
index 00000000..29d656d1
--- /dev/null
+++ b/azalea-brigadier/tests/arguments/mod.rs
@@ -0,0 +1,6 @@
+mod bool_argument_type_test;
+mod double_argument_type_test;
+mod float_argument_type_test;
+mod integer_argument_type_test;
+mod long_argument_type_test;
+mod string_argument_type_test;
diff --git a/azalea-brigadier/tests/builder/argument_builder_test.rs b/azalea-brigadier/tests/builder/argument_builder_test.rs
index ee44f5e6..d5f940dd 100755
--- a/azalea-brigadier/tests/builder/argument_builder_test.rs
+++ b/azalea-brigadier/tests/builder/argument_builder_test.rs
@@ -1,41 +1,17 @@
 use std::rc::Rc;
 
-use crate::{
-    arguments::integer_argument_type::integer,
-    builder::{literal_argument_builder::literal, required_argument_builder::argument},
-};
-
-use super::ArgumentBuilder;
-
-// public class ArgumentBuilderTest {
-//     private TestableArgumentBuilder<Object> builder;
-
-//     @Before
-//     public void setUp() throws Exception {
-//         builder = new TestableArgumentBuilder<>();
-//     }
-
-//     @Test
-//     public void testArguments() throws Exception {
-//         final RequiredArgumentBuilder<Object, ?> argument = argument("bar",
-// integer());
-
-//         builder.then(argument);
-
-//         assertThat(builder.getArguments(), hasSize(1));
-//         assertThat(builder.getArguments(), hasItem((CommandNode<Object>)
-// argument.build()));     }
+use azalea_brigadier::{builder::argument_builder::ArgumentBuilder, prelude::*};
 
 #[test]
 fn test_arguments() {
-    let mut builder: ArgumentBuilder<()> = literal("foo");
+    let builder: ArgumentBuilder<()> = literal("foo");
 
     let argument: ArgumentBuilder<()> = argument("bar", integer());
-    builder.then(argument.clone());
-    assert_eq!(builder.arguments.children.len(), 1);
+    let builder = builder.then(argument.clone());
+    assert_eq!(builder.arguments().children.len(), 1);
     let built_argument = Rc::new(argument.build());
     assert!(builder
-        .arguments
+        .arguments()
         .children
         .values()
         .any(|e| *e.read() == *built_argument));
diff --git a/azalea-brigadier/tests/builder/mod.rs b/azalea-brigadier/tests/builder/mod.rs
new file mode 100644
index 00000000..21944c68
--- /dev/null
+++ b/azalea-brigadier/tests/builder/mod.rs
@@ -0,0 +1,3 @@
+mod argument_builder_test;
+mod literal_argument_builder_test;
+mod required_argument_builder_test;
diff --git a/azalea-brigadier/tests/command_dispatcher_usages_test.rs b/azalea-brigadier/tests/command_dispatcher_usages_test.rs
index 8b137891..d7baff89 100755
--- a/azalea-brigadier/tests/command_dispatcher_usages_test.rs
+++ b/azalea-brigadier/tests/command_dispatcher_usages_test.rs
@@ -1 +1,143 @@
+use std::{collections::HashSet, sync::Arc};
 
+use azalea_brigadier::{prelude::*, tree::CommandNode};
+use parking_lot::RwLock;
+
+fn setup() -> CommandDispatcher<()> {
+    let command = |_: &CommandContext<()>| 0;
+
+    let mut subject = CommandDispatcher::new();
+    subject.register(
+        literal("a")
+            .then(
+                literal("1")
+                    .then(literal("i").executes(command))
+                    .then(literal("ii").executes(command)),
+            )
+            .then(
+                literal("2")
+                    .then(literal("i").executes(command))
+                    .then(literal("ii").executes(command)),
+            ),
+    );
+    subject.register(literal("b").then(literal("1").executes(command)));
+    subject.register(literal("c").executes(command));
+    subject.register(literal("d").requires(|_| false).executes(command));
+    subject.register(
+        literal("e").executes(command).then(
+            literal("1")
+                .executes(command)
+                .then(literal("i").executes(command))
+                .then(literal("ii").executes(command)),
+        ),
+    );
+    subject.register(
+        literal("f")
+            .then(
+                literal("1")
+                    .then(literal("i").executes(command))
+                    .then(literal("ii").executes(command).requires(|_| false)),
+            )
+            .then(
+                literal("2")
+                    .then(literal("i").executes(command).requires(|_| false))
+                    .then(literal("ii").executes(command)),
+            ),
+    );
+    subject.register(
+        literal("g")
+            .executes(command)
+            .then(literal("1").then(literal("i").executes(command))),
+    );
+    subject.register(
+        literal("h")
+            .executes(command)
+            .then(literal("1").then(literal("i").executes(command)))
+            .then(literal("2").then(literal("i").then(literal("ii").executes(command))))
+            .then(literal("3").executes(command)),
+    );
+    subject.register(
+        literal("i")
+            .executes(command)
+            .then(literal("1").executes(command))
+            .then(literal("2").executes(command)),
+    );
+    subject.register(literal("j").redirect(subject.root.clone()));
+    subject.register(literal("k").redirect(get(&subject, "h")));
+    subject
+}
+
+fn get(subject: &CommandDispatcher<()>, command: &str) -> Arc<RwLock<CommandNode<()>>> {
+    subject
+        .parse(command.into(), ())
+        .context
+        .nodes
+        .last()
+        .unwrap()
+        .node
+        .clone()
+}
+
+#[test]
+fn test_all_usage_no_commands() {
+    let subject = CommandDispatcher::<()>::new();
+    let results = subject.get_all_usage(&subject.root.read(), Arc::new(()), true);
+    assert!(results.is_empty());
+}
+
+#[test]
+fn test_smart_usage_no_commands() {
+    let subject = CommandDispatcher::<()>::new();
+    let results = subject.get_smart_usage(&subject.root.read(), Arc::new(()));
+    assert!(results.is_empty());
+}
+
+#[test]
+fn test_all_usage_root() {
+    let subject = setup();
+    let results = subject.get_all_usage(&subject.root.read(), Arc::new(()), true);
+
+    let actual = results.into_iter().collect::<HashSet<_>>();
+    let expected = vec![
+        "a 1 i", "a 1 ii", "a 2 i", "a 2 ii", "b 1", "c", "e", "e 1", "e 1 i", "e 1 ii", "f 1 i",
+        "f 2 ii", "g", "g 1 i", "h", "h 1 i", "h 2 i ii", "h 3", "i", "i 1", "i 2", "j ...",
+        "k -> h",
+    ]
+    .into_iter()
+    .map(|s| s.to_owned())
+    .collect::<HashSet<_>>();
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn test_smart_usage_root() {
+    let subject = setup();
+    let results = subject.get_smart_usage(&subject.root.read(), Arc::new(()));
+
+    let actual = results
+        .into_iter()
+        .map(|(k, v)| (k.read().name().to_owned(), v))
+        .collect::<HashSet<_>>();
+
+    let expected = vec![
+        (get(&subject, "a"), "a (1|2)"),
+        (get(&subject, "b"), "b 1"),
+        (get(&subject, "c"), "c"),
+        (get(&subject, "e"), "e [1]"),
+        (get(&subject, "f"), "f (1|2)"),
+        (get(&subject, "g"), "g [1]"),
+        (get(&subject, "h"), "h [1|2|3]"),
+        (get(&subject, "i"), "i [1|2]"),
+        (get(&subject, "j"), "j ..."),
+        (get(&subject, "k"), "k -> h"),
+    ];
+
+    println!("-");
+
+    let expected = expected
+        .into_iter()
+        .map(|(k, v)| (k.read().name().to_owned(), v.to_owned()))
+        .collect::<HashSet<_>>();
+
+    assert_eq!(actual, expected);
+}
diff --git a/azalea-brigadier/tests/context/mod.rs b/azalea-brigadier/tests/context/mod.rs
new file mode 100644
index 00000000..e74dce59
--- /dev/null
+++ b/azalea-brigadier/tests/context/mod.rs
@@ -0,0 +1,2 @@
+mod command_context_test;
+mod parsed_argument_test;
diff --git a/azalea-brigadier/tests/exceptions/mod.rs b/azalea-brigadier/tests/exceptions/mod.rs
new file mode 100644
index 00000000..72292c4d
--- /dev/null
+++ b/azalea-brigadier/tests/exceptions/mod.rs
@@ -0,0 +1,2 @@
+mod dynamic_command_syntax_exception_type_test;
+mod simple_command_syntax_exception_type_test;
diff --git a/azalea-brigadier/tests/mod.rs b/azalea-brigadier/tests/mod.rs
new file mode 100644
index 00000000..14c99a24
--- /dev/null
+++ b/azalea-brigadier/tests/mod.rs
@@ -0,0 +1,6 @@
+mod arguments;
+mod builder;
+mod context;
+mod exceptions;
+mod suggestion;
+mod tree;
diff --git a/azalea-brigadier/tests/suggestion/mod.rs b/azalea-brigadier/tests/suggestion/mod.rs
new file mode 100644
index 00000000..7b96af2b
--- /dev/null
+++ b/azalea-brigadier/tests/suggestion/mod.rs
@@ -0,0 +1,3 @@
+mod suggestion_test;
+mod suggestions_builder_test;
+mod suggestions_test;
\ No newline at end of file
diff --git a/azalea-brigadier/tests/suggestion/suggestion_test.rs b/azalea-brigadier/tests/suggestion/suggestion_test.rs
index 9ba95807..e3c70c25 100755
--- a/azalea-brigadier/tests/suggestion/suggestion_test.rs
+++ b/azalea-brigadier/tests/suggestion/suggestion_test.rs
@@ -1,7 +1,12 @@
+use azalea_brigadier::{context::StringRange, suggestion::Suggestion};
+
 #[test]
 fn apply_insertation_start() {
     let suggestion = Suggestion::new(StringRange::at(0), "And so I said: ");
-    assert_eq!(suggestion.apply("Hello world!"), "And so I said: Hello world!");
+    assert_eq!(
+        suggestion.apply("Hello world!"),
+        "And so I said: Hello world!"
+    );
 }
 
 #[test]
@@ -49,23 +54,35 @@ fn expand_unchanged() {
 #[test]
 fn expand_left() {
     let suggestion = Suggestion::new(StringRange::at(1), "oo");
-    assert_eq!(suggestion.expand("f", StringRange::between(0, 1)), Suggestion::new(StringRange::between(0, 1), "foo"));
+    assert_eq!(
+        suggestion.expand("f", StringRange::between(0, 1)),
+        Suggestion::new(StringRange::between(0, 1), "foo")
+    );
 }
 
 #[test]
 fn expand_right() {
     let suggestion = Suggestion::new(StringRange::at(0), "minecraft:");
-    assert_eq!(suggestion.expand("fish", StringRange::between(0, 4)), Suggestion::new(StringRange::between(0, 4), "minecraft:fish"));
+    assert_eq!(
+        suggestion.expand("fish", StringRange::between(0, 4)),
+        Suggestion::new(StringRange::between(0, 4), "minecraft:fish")
+    );
 }
 
 #[test]
 fn expand_both() {
     let suggestion = Suggestion::new(StringRange::at(11), "minecraft:");
-    assert_eq!(suggestion.expand("give Steve fish_block", StringRange::between(5, 21)), Suggestion::new(StringRange::between(5, 21), "Steve minecraft:fish_block"));
+    assert_eq!(
+        suggestion.expand("give Steve fish_block", StringRange::between(5, 21)),
+        Suggestion::new(StringRange::between(5, 21), "Steve minecraft:fish_block")
+    );
 }
 
 #[test]
 fn expand_replacement() {
     let suggestion = Suggestion::new(StringRange::between(6, 11), "strangers");
-    assert_eq!(suggestion.expand("Hello world!", StringRange::between(0, 12)), Suggestion::new(StringRange::between(0, 12), "Hello strangers!"));
-}
\ No newline at end of file
+    assert_eq!(
+        suggestion.expand("Hello world!", StringRange::between(0, 12)),
+        Suggestion::new(StringRange::between(0, 12), "Hello strangers!")
+    );
+}
diff --git a/azalea-brigadier/tests/suggestion/suggestions_builder_test.rs b/azalea-brigadier/tests/suggestion/suggestions_builder_test.rs
index e69de29b..08ce65d4 100755
--- a/azalea-brigadier/tests/suggestion/suggestions_builder_test.rs
+++ b/azalea-brigadier/tests/suggestion/suggestions_builder_test.rs
@@ -0,0 +1,133 @@
+use std::collections::HashSet;
+
+use azalea_brigadier::{
+    context::StringRange,
+    suggestion::{Suggestion, SuggestionsBuilder},
+};
+
+#[test]
+fn suggest_appends() {
+    let builder = SuggestionsBuilder::new("Hello w", 6);
+    let result = builder.suggest("orld!").build();
+    assert_eq!(
+        result.list(),
+        vec![Suggestion::new(StringRange::between(6, 7), "orld!")]
+    );
+    assert_eq!(result.range(), StringRange::between(6, 7));
+    assert!(!result.is_empty());
+}
+
+#[test]
+fn suggest_replaces() {
+    let builder = SuggestionsBuilder::new("Hello w", 6);
+    let result = builder.suggest("everybody").build();
+    assert_eq!(
+        result.list(),
+        vec![Suggestion::new(StringRange::between(6, 7), "everybody")]
+    );
+    assert_eq!(result.range(), StringRange::between(6, 7));
+    assert!(!result.is_empty());
+}
+
+#[test]
+fn suggest_noop() {
+    let builder = SuggestionsBuilder::new("Hello w", 6);
+    let result = builder.suggest("w").build();
+    assert_eq!(result.list(), vec![]);
+    assert!(result.is_empty());
+}
+
+#[test]
+fn suggest_multiple() {
+    let builder = SuggestionsBuilder::new("Hello w", 6);
+    let result = builder
+        .suggest("world!")
+        .suggest("everybody")
+        .suggest("weekend")
+        .build();
+    assert_eq!(
+        result.list(),
+        vec![
+            Suggestion::new(StringRange::between(6, 7), "everybody"),
+            Suggestion::new(StringRange::between(6, 7), "weekend"),
+            Suggestion::new(StringRange::between(6, 7), "world!"),
+        ]
+    );
+    assert_eq!(result.range(), StringRange::between(6, 7));
+    assert!(!result.is_empty());
+}
+
+#[test]
+fn restart() {
+    let builder = SuggestionsBuilder::new("Hello w", 6);
+    let builder = builder.suggest("won't be included in restart");
+    let other = builder.restart();
+    assert_ne!(other, builder);
+    assert_eq!(other.input(), builder.input());
+    assert_eq!(other.start(), builder.start());
+    assert_eq!(other.remaining(), builder.remaining());
+}
+
+#[test]
+fn sort_alphabetical() {
+    let builder = SuggestionsBuilder::new("Hello w", 6);
+    let result = builder
+        .suggest("2")
+        .suggest("4")
+        .suggest("6")
+        .suggest("8")
+        .suggest("30")
+        .suggest("32")
+        .build();
+    let actual = result.list().iter().map(|s| s.text()).collect::<Vec<_>>();
+    assert_eq!(actual, vec!["2", "30", "32", "4", "6", "8"]);
+}
+
+#[test]
+fn sort_numerical() {
+    let builder = SuggestionsBuilder::new("Hello w", 6);
+    let result = builder
+        .suggest_integer(2)
+        .suggest_integer(4)
+        .suggest_integer(6)
+        .suggest_integer(8)
+        .suggest_integer(30)
+        .suggest_integer(32)
+        .build();
+    let actual = result.list().iter().map(|s| s.text()).collect::<Vec<_>>();
+    assert_eq!(actual, vec!["2", "4", "6", "8", "30", "32"]);
+}
+
+#[test]
+fn sort_mixed() {
+    let builder = SuggestionsBuilder::new("Hello w", 6);
+    let result = builder
+        .suggest("11")
+        .suggest("22")
+        .suggest("33")
+        .suggest("a")
+        .suggest("b")
+        .suggest("c")
+        .suggest_integer(2)
+        .suggest_integer(4)
+        .suggest_integer(6)
+        .suggest_integer(8)
+        .suggest_integer(30)
+        .suggest_integer(32)
+        .suggest("3a")
+        .suggest("a3")
+        .build();
+    let actual = result
+        .list()
+        .iter()
+        .map(|s| s.text())
+        .collect::<HashSet<_>>();
+    // mojang please
+    let expected = vec![
+        "11", "2", "22", "33", "3a", "4", "6", "8", "30", "32", "a", "a3", "b", "c",
+    ]
+    .into_iter()
+    .map(|s| s.to_string())
+    .collect::<HashSet<_>>();
+    assert_eq!(actual, expected);
+}
diff --git a/azalea-brigadier/tests/suggestion/suggestions_test.rs b/azalea-brigadier/tests/suggestion/suggestions_test.rs
index 28a8266d..12a2c73b 100755
--- a/azalea-brigadier/tests/suggestion/suggestions_test.rs
+++ b/azalea-brigadier/tests/suggestion/suggestions_test.rs
@@ -1,20 +1,58 @@
+use std::collections::HashSet;
+
+use azalea_brigadier::{
+    context::StringRange,
+    suggestion::{Suggestion, Suggestions},
+};
+
 #[test]
 fn merge_empty() {
-    let merged = Suggestions::merge("foo b", vec![]);
+    let merged = Suggestions::<()>::merge("foo b", &[]);
     assert!(merged.is_empty());
 }
 
 #[test]
 fn merge_single() {
-    let suggestions = Suggestions::new(StringRange::at(5), vec![Suggestion::new(StringRange::at(5), "ar")]);
-    let merged = Suggestions::merge("foo b", vec![suggestions]);
+    let suggestions = Suggestions::new(
+        StringRange::at(5),
+        vec![Suggestion::new(StringRange::at(5), "ar")],
+    );
+    let merged = Suggestions::merge("foo b", &[suggestions.clone()]);
     assert_eq!(merged, suggestions);
 }
 
 #[test]
 fn merge_multiple() {
-    let a = Suggestions::new(StringRange::at(5), vec![Suggestion::new(StringRange::at(5), "ar"), Suggestion::new(StringRange::at(5), "az"), Suggestion::new(StringRange::at(5), "Az")]);
-    let b = Suggestions::new(StringRange::between(4, 5), vec![Suggestion::new(StringRange::between(4, 5), "foo"), Suggestion::new(StringRange::between(4, 5), "qux"), Suggestion::new(StringRange::between(4, 5), "apple"), Suggestion::new(StringRange::between(4, 5), "Bar")]);
-    let merged = Suggestions::merge("foo b", vec![a, b]);
-    assert_eq!(merged.get_list(), vec![Suggestion::new(StringRange::between(4, 5), "apple"), Suggestion::new(StringRange::between(4, 5), "ar"), Suggestion::new(StringRange::between(4, 5), "Az"), Suggestion::new(StringRange::between(4, 5), "bar"), Suggestion::new(StringRange::between(4, 5), "Bar"), Suggestion::new(StringRange::between(4, 5), "baz"), Suggestion::new(StringRange::between(4, 5), "bAz"), Suggestion::new(StringRange::between(4, 5), "foo"), Suggestion::new(StringRange::between(4, 5), "qux")]);
-}
\ No newline at end of file
+    let a = Suggestions::new(
+        StringRange::at(5),
+        vec![
+            Suggestion::new(StringRange::at(5), "ar"),
+            Suggestion::new(StringRange::at(5), "az"),
+            Suggestion::new(StringRange::at(5), "Az"),
+        ],
+    );
+    let b = Suggestions::new(
+        StringRange::between(4, 5),
+        vec![
+            Suggestion::new(StringRange::between(4, 5), "foo"),
+            Suggestion::new(StringRange::between(4, 5), "qux"),
+            Suggestion::new(StringRange::between(4, 5), "apple"),
+            Suggestion::new(StringRange::between(4, 5), "Bar"),
+        ],
+    );
+    let merged = Suggestions::merge("foo b", &[a, b]);
+
+    let actual = merged.list().iter().cloned().collect::<HashSet<_>>();
+    let expected = vec![
+        Suggestion::new(StringRange::between(4, 5), "apple"),
+        Suggestion::new(StringRange::between(4, 5), "bar"),
+        Suggestion::new(StringRange::between(4, 5), "Bar"),
+        Suggestion::new(StringRange::between(4, 5), "baz"),
+        Suggestion::new(StringRange::between(4, 5), "bAz"),
+        Suggestion::new(StringRange::between(4, 5), "foo"),
+        Suggestion::new(StringRange::between(4, 5), "qux"),
+    ]
+    .into_iter()
+    .collect::<HashSet<_>>();
+    assert_eq!(actual, expected);
+}
diff --git a/azalea-brigadier/tests/tree/mod.rs b/azalea-brigadier/tests/tree/mod.rs
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/azalea-brigadier/tests/tree/mod.rs
@@ -0,0 +1 @@
+