slight changes MY ass

cargo fmt, cargo clippy --fix or something idfk

tests/test.rs

@@ -0,0 +1,156 @@
+//! test for lib.rs  
+//! very good
+//!
+//! copilot chat teach me how to do stuff (all code made by copilot chat)
+
+use ansi_colors::Color;
+use ansi_colors_2::{
+    ansi_color_interface::ColorContext as Color2Context,
+    // AnsiColor as AnsiColor2,
+    Color as Color2,
+    // CustomColor as CustomColor2,
+};
+use ansi_styles::Style as AnsiStyle;
+use lda_ansi::{ansi_colors, ansi_colors_2, ansi_styles};
+use std::collections::HashSet;
+
+// use ansi_colors_2::ansi_color_interface::ColorContext as _;
+
+use ansi_colors::color_error::ColorError;
+// use super::*;
+
+#[derive(Debug)]
+struct CodeError;
+
+impl std::fmt::Display for CodeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Invalid ANSI code sequence")
+    }
+}
+
+impl std::error::Error for CodeError {} // ooh
+
+#[allow(dead_code)]
+fn process_codes(codes: &[u8]) -> Result<(HashSet<u8>, HashSet<Vec<u8>>), CodeError> {
+    let mut set = HashSet::new();
+    let mut groups = HashSet::new();
+    let mut i = 0;
+
+    while i < codes.len() {
+        match codes[i] {
+            38 | 48 => {
+                if i + 1 < codes.len() {
+                    match codes[i + 1] {
+                        2 => {
+                            if i + 4 < codes.len() {
+                                groups.insert(vec![
+                                    codes[i],
+                                    codes[i + 1],
+                                    codes[i + 2],
+                                    codes[i + 3],
+                                    codes[i + 4],
+                                ]);
+                                i += 5;
+                            } else {
+                                return Err(CodeError);
+                            }
+                        }
+                        5 => {
+                            if i + 2 < codes.len() {
+                                groups.insert(vec![codes[i], codes[i + 1], codes[i + 2]]);
+                                i += 3;
+                            } else {
+                                return Err(CodeError);
+                            }
+                        }
+                        _ => return Err(CodeError),
+                    }
+                } else {
+                    return Err(CodeError);
+                }
+            }
+            _ => {
+                set.insert(codes[i]);
+                i += 1;
+            }
+        }
+    }
+
+    Ok((set, groups))
+}
+
+fn process_codes2(codes: &[u8]) -> Result<(HashSet<u8>, HashSet<Vec<u8>>), ColorError> {
+    let mut set = HashSet::new();
+    let mut groups = HashSet::new();
+
+    let mut enumerate_codes = codes.iter().enumerate();
+    while let Some((i, c)) = enumerate_codes.next() {
+        match c {
+            38 | 48 => {
+                let mut this = vec![*c];
+                if let Some((ind, colop)) = enumerate_codes.next() {
+                    debug_assert!(ind == i + 1);
+                    this.push(*colop);
+                    match colop {
+                        2 => {
+                            let group: Vec<_> =
+                                enumerate_codes.by_ref().take(3).map(|(_, &v)| v).collect(); // by ref is big
+                            if group.len() == 3 {
+                                this.extend(group);
+                            } else {
+                                return Err(ColorError::InvalidMode);
+                            }
+                        }
+                        5 => {
+                            if let Some((_, &v)) = enumerate_codes.next() {
+                                this.push(v);
+                            } else {
+                                return Err(ColorError::InvalidMode);
+                            }
+                        }
+                        _ => return Err(ColorError::InvalidMode),
+                    }
+                } else {
+                    return Err(ColorError::InvalidMode);
+                }
+                groups.insert(this);
+            }
+            _ => {
+                set.insert(*c);
+            }
+        }
+    }
+
+    Ok((set, groups))
+}
+
+/// if checked code beforehand (use [`ansi_colors::Color::codes()`] or [`Vec<u8>::from<AnsiColor>()`]) probably never fails
+pub fn compare_ansi_codes(actual: &[u8], expected: &[u8]) -> Result<bool, ColorError> {
+    let (actual_set, actual_groups) = process_codes2(actual)?;
+    let (expected_set, expected_groups) = process_codes2(expected)?;
+
+    Ok(actual_set == expected_set && actual_groups == expected_groups)
+}
+#[test]
+fn test_normal_use() {
+    // what kinda shit
+
+    let mut builder = lda_ansi::AnsiStyles::init("what is going on here");
+    let mut error_style = lda_ansi::ansi_backbone::StyleConstruct::new();
+    error_style
+        .color(Color2::Red.fg().bright()) // 91
+        .color(Color::custom_256(232).bg()) // 48;5;232
+        .style(AnsiStyle::Bold) // 1
+        .style(AnsiStyle::BlinkFast); // 6
+    builder.add_style(&error_style);
+    //mut
+    let reset_style = lda_ansi::ansi_backbone::StyleConstruct::new()
+        .style(AnsiStyle::Reset)
+        .to_owned();
+    println!("{builder}{reset_style}"); // good so far
+    let error_estimate: Vec<u8> = vec![6, 1, 91, 48, 5, 232]; // 48, 5, 232 sticks together in a clump
+    let reset_estimate: Vec<u8> = vec![0];
+
+    assert!(compare_ansi_codes(&error_style.clone().into_inner(), &error_estimate).unwrap());
+    assert!(compare_ansi_codes(&reset_style.clone().into_inner(), &reset_estimate).unwrap());
+}