From a6837e6e934589d14308813394c54d79f3576e56 Mon Sep 17 00:00:00 2001
From: Louis Pilfold <louis@lpil.uk>
Date: Wed, 10 Feb 2021 20:40:17 +0000
Subject: Remove extra qualification

---
 test/gleam/order_test.gleam | 54 ++++++++++++++++++++++-----------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

(limited to 'test')

diff --git a/test/gleam/order_test.gleam b/test/gleam/order_test.gleam
index 92bf405..2517f9c 100644
--- a/test/gleam/order_test.gleam
+++ b/test/gleam/order_test.gleam
@@ -5,8 +5,8 @@ pub fn reverse_test() {
   order.reverse(Lt)
   |> should.equal(Gt)
 
-  order.reverse(order.Eq)
-  |> should.equal(order.Eq)
+  order.reverse(Eq)
+  |> should.equal(Eq)
 
   order.reverse(Gt)
   |> should.equal(Lt)
@@ -16,7 +16,7 @@ pub fn to_int_test() {
   order.to_int(Lt)
   |> should.equal(-1)
 
-  order.to_int(order.Eq)
+  order.to_int(Eq)
   |> should.equal(0)
 
   order.to_int(Gt)
@@ -25,56 +25,56 @@ pub fn to_int_test() {
 
 pub fn compare_test() {
   order.compare(Lt, Lt)
-  |> should.equal(order.Eq)
+  |> should.equal(Eq)
 
-  order.compare(Lt, order.Eq)
+  order.compare(Lt, Eq)
   |> should.equal(Lt)
 
   order.compare(Lt, Gt)
   |> should.equal(Lt)
 
-  order.compare(order.Eq, Lt)
+  order.compare(Eq, Lt)
   |> should.equal(Gt)
 
-  order.compare(order.Eq, order.Eq)
-  |> should.equal(order.Eq)
+  order.compare(Eq, Eq)
+  |> should.equal(Eq)
 
-  order.compare(order.Eq, Gt)
+  order.compare(Eq, Gt)
   |> should.equal(Lt)
 
   order.compare(Gt, Lt)
   |> should.equal(Gt)
 
-  order.compare(Gt, order.Eq)
+  order.compare(Gt, Eq)
   |> should.equal(Gt)
 
   order.compare(Gt, Gt)
-  |> should.equal(order.Eq)
+  |> should.equal(Eq)
 }
 
 pub fn max_test() {
   order.max(Lt, Lt)
   |> should.equal(Lt)
 
-  order.max(Lt, order.Eq)
-  |> should.equal(order.Eq)
+  order.max(Lt, Eq)
+  |> should.equal(Eq)
 
   order.max(Lt, Gt)
   |> should.equal(Gt)
 
-  order.max(order.Eq, Lt)
-  |> should.equal(order.Eq)
+  order.max(Eq, Lt)
+  |> should.equal(Eq)
 
-  order.max(order.Eq, order.Eq)
-  |> should.equal(order.Eq)
+  order.max(Eq, Eq)
+  |> should.equal(Eq)
 
-  order.max(order.Eq, Gt)
+  order.max(Eq, Gt)
   |> should.equal(Gt)
 
   order.max(Gt, Lt)
   |> should.equal(Gt)
 
-  order.max(Gt, order.Eq)
+  order.max(Gt, Eq)
   |> should.equal(Gt)
 
   order.max(Gt, Gt)
@@ -85,26 +85,26 @@ pub fn min_test() {
   order.min(Lt, Lt)
   |> should.equal(Lt)
 
-  order.min(Lt, order.Eq)
+  order.min(Lt, Eq)
   |> should.equal(Lt)
 
   order.min(Lt, Gt)
   |> should.equal(Lt)
 
-  order.min(order.Eq, Lt)
+  order.min(Eq, Lt)
   |> should.equal(Lt)
 
-  order.min(order.Eq, order.Eq)
-  |> should.equal(order.Eq)
+  order.min(Eq, Eq)
+  |> should.equal(Eq)
 
-  order.min(order.Eq, Gt)
-  |> should.equal(order.Eq)
+  order.min(Eq, Gt)
+  |> should.equal(Eq)
 
   order.min(Gt, Lt)
   |> should.equal(Lt)
 
-  order.min(Gt, order.Eq)
-  |> should.equal(order.Eq)
+  order.min(Gt, Eq)
+  |> should.equal(Eq)
 
   order.min(Gt, Gt)
   |> should.equal(Gt)
-- 
cgit v1.2.3