diff --git a/packages/utils/src/lib.rs b/packages/utils/src/lib.rs
index 4b6d15b..0e04d3d 100644
--- a/packages/utils/src/lib.rs
+++ b/packages/utils/src/lib.rs
@@ -712,7 +712,7 @@ pub fn get_opposite_axis_placements(
         .map(|side| get_placement(side, alignment))
         .collect();
 
-    if flip_alignment {
+    if flip_alignment && alignment.is_some() {
         let mut opposite_list: Vec<Placement> = list
             .clone()
             .into_iter()
@@ -762,3 +762,369 @@ pub fn rect_to_client_rect(rect: Rect) -> ClientRectObject {
         left: rect.x,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{Alignment, Placement, get_opposite_axis_placements};
+
+    #[test]
+    fn side_top() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Top, true, Some(Alignment::Start), None),
+            vec![Placement::Left, Placement::Right]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Top, true, Some(Alignment::End), None),
+            vec![Placement::Right, Placement::Left]
+        );
+    }
+
+    #[test]
+    fn side_bottom() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Bottom, true, Some(Alignment::Start), None),
+            vec![Placement::Left, Placement::Right]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Bottom, true, Some(Alignment::End), None),
+            vec![Placement::Right, Placement::Left]
+        );
+    }
+
+    #[test]
+    fn side_left() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Left, true, Some(Alignment::Start), None),
+            vec![Placement::Top, Placement::Bottom]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Left, true, Some(Alignment::End), None),
+            vec![Placement::Bottom, Placement::Top]
+        );
+    }
+
+    #[test]
+    fn side_right() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Right, true, Some(Alignment::Start), None),
+            vec![Placement::Top, Placement::Bottom]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Right, true, Some(Alignment::End), None),
+            vec![Placement::Bottom, Placement::Top]
+        );
+    }
+
+    #[test]
+    fn start_top_start() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::TopStart, false, Some(Alignment::Start), None),
+            vec![Placement::LeftStart, Placement::RightStart]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::TopStart, false, Some(Alignment::End), None),
+            vec![Placement::RightStart, Placement::LeftStart]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::TopStart, true, Some(Alignment::Start), None),
+            vec![
+                Placement::LeftStart,
+                Placement::RightStart,
+                Placement::LeftEnd,
+                Placement::RightEnd
+            ]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::TopStart, true, Some(Alignment::End), None),
+            vec![
+                Placement::RightStart,
+                Placement::LeftStart,
+                Placement::RightEnd,
+                Placement::LeftEnd
+            ]
+        );
+    }
+
+    #[test]
+    fn start_bottom_start() {
+        assert_eq!(
+            get_opposite_axis_placements(
+                Placement::BottomStart,
+                false,
+                Some(Alignment::Start),
+                None
+            ),
+            vec![Placement::LeftStart, Placement::RightStart]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::BottomStart, false, Some(Alignment::End), None),
+            vec![Placement::RightStart, Placement::LeftStart]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(
+                Placement::BottomStart,
+                true,
+                Some(Alignment::Start),
+                None
+            ),
+            vec![
+                Placement::LeftStart,
+                Placement::RightStart,
+                Placement::LeftEnd,
+                Placement::RightEnd
+            ]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::BottomStart, true, Some(Alignment::End), None),
+            vec![
+                Placement::RightStart,
+                Placement::LeftStart,
+                Placement::RightEnd,
+                Placement::LeftEnd
+            ]
+        );
+    }
+
+    #[test]
+    fn start_left_start() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::LeftStart, false, Some(Alignment::Start), None),
+            vec![Placement::TopStart, Placement::BottomStart]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::LeftStart, false, Some(Alignment::End), None),
+            vec![Placement::BottomStart, Placement::TopStart]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::LeftStart, true, Some(Alignment::Start), None),
+            vec![
+                Placement::TopStart,
+                Placement::BottomStart,
+                Placement::TopEnd,
+                Placement::BottomEnd
+            ]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::LeftStart, true, Some(Alignment::End), None),
+            vec![
+                Placement::BottomStart,
+                Placement::TopStart,
+                Placement::BottomEnd,
+                Placement::TopEnd
+            ]
+        );
+    }
+
+    #[test]
+    fn start_right_start() {
+        assert_eq!(
+            get_opposite_axis_placements(
+                Placement::RightStart,
+                false,
+                Some(Alignment::Start),
+                None
+            ),
+            vec![Placement::TopStart, Placement::BottomStart]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::RightStart, false, Some(Alignment::End), None),
+            vec![Placement::BottomStart, Placement::TopStart]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::RightStart, true, Some(Alignment::Start), None),
+            vec![
+                Placement::TopStart,
+                Placement::BottomStart,
+                Placement::TopEnd,
+                Placement::BottomEnd
+            ]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::RightStart, true, Some(Alignment::End), None),
+            vec![
+                Placement::BottomStart,
+                Placement::TopStart,
+                Placement::BottomEnd,
+                Placement::TopEnd
+            ]
+        );
+    }
+
+    #[test]
+    fn end_top_end() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::TopEnd, false, Some(Alignment::Start), None),
+            vec![Placement::LeftEnd, Placement::RightEnd]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::TopEnd, false, Some(Alignment::End), None),
+            vec![Placement::RightEnd, Placement::LeftEnd]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::TopEnd, true, Some(Alignment::Start), None),
+            vec![
+                Placement::LeftEnd,
+                Placement::RightEnd,
+                Placement::LeftStart,
+                Placement::RightStart
+            ]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::TopEnd, true, Some(Alignment::End), None),
+            vec![
+                Placement::RightEnd,
+                Placement::LeftEnd,
+                Placement::RightStart,
+                Placement::LeftStart
+            ]
+        );
+    }
+
+    #[test]
+    fn end_bottom_end() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::BottomEnd, false, Some(Alignment::Start), None),
+            vec![Placement::LeftEnd, Placement::RightEnd]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::BottomEnd, false, Some(Alignment::End), None),
+            vec![Placement::RightEnd, Placement::LeftEnd]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::BottomEnd, true, Some(Alignment::Start), None),
+            vec![
+                Placement::LeftEnd,
+                Placement::RightEnd,
+                Placement::LeftStart,
+                Placement::RightStart
+            ]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::BottomEnd, true, Some(Alignment::End), None),
+            vec![
+                Placement::RightEnd,
+                Placement::LeftEnd,
+                Placement::RightStart,
+                Placement::LeftStart
+            ]
+        );
+    }
+
+    #[test]
+    fn end_left_end() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::LeftEnd, false, Some(Alignment::Start), None),
+            vec![Placement::TopEnd, Placement::BottomEnd]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::LeftEnd, false, Some(Alignment::End), None),
+            vec![Placement::BottomEnd, Placement::TopEnd]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::LeftStart, true, Some(Alignment::Start), None),
+            vec![
+                Placement::TopStart,
+                Placement::BottomStart,
+                Placement::TopEnd,
+                Placement::BottomEnd
+            ]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::LeftStart, true, Some(Alignment::End), None),
+            vec![
+                Placement::BottomStart,
+                Placement::TopStart,
+                Placement::BottomEnd,
+                Placement::TopEnd
+            ]
+        );
+    }
+
+    #[test]
+    fn end_right_end() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::RightEnd, false, Some(Alignment::Start), None),
+            vec![Placement::TopEnd, Placement::BottomEnd]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::RightEnd, false, Some(Alignment::End), None),
+            vec![Placement::BottomEnd, Placement::TopEnd]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::RightEnd, true, Some(Alignment::Start), None),
+            vec![
+                Placement::TopEnd,
+                Placement::BottomEnd,
+                Placement::TopStart,
+                Placement::BottomStart
+            ]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::RightEnd, true, Some(Alignment::End), None),
+            vec![
+                Placement::BottomEnd,
+                Placement::TopEnd,
+                Placement::BottomStart,
+                Placement::TopStart
+            ]
+        );
+    }
+
+    #[test]
+    fn rtl_top() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Top, true, Some(Alignment::Start), Some(true)),
+            vec![Placement::Right, Placement::Left]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Top, true, Some(Alignment::End), Some(true)),
+            vec![Placement::Left, Placement::Right]
+        );
+    }
+
+    #[test]
+    fn rtl_bottom() {
+        assert_eq!(
+            get_opposite_axis_placements(
+                Placement::Bottom,
+                true,
+                Some(Alignment::Start),
+                Some(true)
+            ),
+            vec![Placement::Right, Placement::Left]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Bottom, true, Some(Alignment::End), Some(true)),
+            vec![Placement::Left, Placement::Right]
+        );
+    }
+
+    #[test]
+    fn rtl_left() {
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Left, true, Some(Alignment::Start), Some(true)),
+            vec![Placement::Top, Placement::Bottom]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Left, true, Some(Alignment::End), Some(true)),
+            vec![Placement::Bottom, Placement::Top]
+        );
+    }
+
+    #[test]
+    fn rtl_right() {
+        assert_eq!(
+            get_opposite_axis_placements(
+                Placement::Right,
+                true,
+                Some(Alignment::Start),
+                Some(true)
+            ),
+            vec![Placement::Top, Placement::Bottom]
+        );
+        assert_eq!(
+            get_opposite_axis_placements(Placement::Right, true, Some(Alignment::End), Some(true)),
+            vec![Placement::Bottom, Placement::Top]
+        );
+    }
+}