chore(getUtils): Add initial tests for util functions

@@ -70,14 +70,13 @@ class GetUtils {
       return true;
       return true;
     }
     }
 
 
-    /// FIXME: null checking here is.. pointless (? see isNull above)
     if(value is String) {
     if(value is String) {
-      return value.toString() == 'null' || value.toString().trim().isEmpty;
+      return value.toString().trim().isEmpty;
     }
     }
 
 
     // Pretty sure that isNullOrBlank should't be validating
     // Pretty sure that isNullOrBlank should't be validating
     // iterables... but I'm going to keep this for compatibility.
     // iterables... but I'm going to keep this for compatibility.
-    return _hasIsEmpty(value) ? value.isEmpty as bool : true;
+    return _hasIsEmpty(value) ? value.isEmpty as bool : false;
   }
   }
 
 
   /// Checks if string is int or double.
   /// Checks if string is int or double.

@@ -8,60 +8,63 @@ class TestClass {
 class EmptyClass {}
 class EmptyClass {}
 
 
 void main() {
 void main() {
-  group('dynamic extensions', () {
-    test('var.isNullOrBlank on a string ', () {
-      var string = '';
-      expect('foo'.isNullOrBlank, equals(false));
-      expect(string.isNullOrBlank, equals(true));
-    });
-    test('var.isNullOrBlank on a int ', () {
-      expect(5.isNullOrBlank, equals(false));
-      expect(0.isNullOrBlank, equals(false));
+  group('isNullOrBlank on dynamic', () {
+    // Identity util to convert to iterables
+    dynamic _id(dynamic e) => e;
+
+    test('null isNullOrBlank should be true for null', () {
+      expect((null).isNullOrBlank, true);
     });
     });
 
 
-    test('var.isNullOrBlank on a double ', () {
+    test('isNullOrBlank should be false for unsupported types', () {
+      expect(5.isNullOrBlank, false);
+      expect(0.isNullOrBlank, false);
+
       expect(5.0.isNullOrBlank, equals(false));
       expect(5.0.isNullOrBlank, equals(false));
       expect(0.0.isNullOrBlank, equals(false));
       expect(0.0.isNullOrBlank, equals(false));
-    });
 
 
-    test('var.isNullOrBlank on a list ', () {
-      var list = ['foo'];
-      expect([].isNullOrBlank, equals(true));
-      expect(['oi', 'foo'].isNullOrBlank, equals(false));
-      expect([{}, {}].isNullOrBlank, equals(false));
-      expect(list[0].isNullOrBlank, equals(false));
+      TestClass testClass;
+      expect(testClass.isNullOrBlank, equals(true));
+      expect(TestClass().isNullOrBlank, equals(false));
+      expect(EmptyClass().isNullOrBlank, equals(false));
     });
     });
 
 
-    test('var.isNullOrBlank on a set ', () {
-      var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};
-      expect(<String>{}.isNullOrBlank, equals(true));
-      expect({'foo', 'bar'}.isNullOrBlank, equals(false));
-      expect(halogens.isNullOrBlank, equals(false));
+    test('isNullOrBlank should validate strings', () {
+      expect("".isNullOrBlank, true);
+      expect("  ".isNullOrBlank, true);
+
+      expect("foo".isNullOrBlank, false);
+      expect(" foo ".isNullOrBlank, false);
+
+      expect("null".isNullOrBlank, false);
     });
     });
 
 
-    test('var.isNullOrBlank on a map ', () {
-      var map = {"foo": 'bar', "one": "um"};
-      expect({}.isNullOrBlank, equals(true));
-      expect({"other": "thing"}.isNullOrBlank, equals(false));
-      expect({'first': [], 'second': []}.isNullOrBlank, equals(false));
-      expect(map["foo"].isNullOrBlank, equals(false));
-      expect(map["other"].isNullOrBlank, equals(true));
+    test('isNullOrBlank should validate iterables', () {
+      expect([].map(_id).isNullOrBlank, true);
+      expect([1].map(_id).isNullOrBlank, false);
     });
     });
 
 
-    test('var.isNullOrBlank on a function ', () {
-      someFunction({String string, int integer}) {
-        expect(string.isNullOrBlank, equals(false));
-        expect(integer.isNullOrBlank, equals(true));
-      }
+    test('isNullOrBlank should validate lists', () {
+      expect([].isNullOrBlank, true);
+      expect(['oi', 'foo'].isNullOrBlank, false);
+      expect([{}, {}].isNullOrBlank, false);
+      expect(['foo'][0].isNullOrBlank, false);
+    });
 
 
-      someFunction(string: 'some value');
+    test('isNullOrBlank should validate sets', () {
+      expect((<dynamic>{}).isNullOrBlank, true);
+      expect(({1}).isNullOrBlank, false);
+      expect({'fluorine', 'chlorine', 'bromine'}.isNullOrBlank, false);
     });
     });
 
 
-    test('var.isNullOrBlank on a class ', () {
-      TestClass testClass;
-      expect(TestClass().isNullOrBlank, equals(false));
-      expect(testClass.isNullOrBlank, equals(true));
-      expect(EmptyClass().isNullOrBlank, equals(false));
+    test('isNullOrBlank should validate maps', () {
+      expect(({}).isNullOrBlank, true);
+      expect(({1: 1}).isNullOrBlank, false);
+      expect({"other": "thing"}.isNullOrBlank, false);
+
+      final map = {"foo": 'bar', "one": "um"};
+      expect(map["foo"].isNullOrBlank, false);
+      expect(map["other"].isNullOrBlank, true);
     });
     });
   });
   });
 
 

+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+
+// Identity util to convert to iterables
+dynamic _id(dynamic e) => e;
+
+void main() {
+  // Tests for GetUtils.isNullOrBlank are located at dynamic extensions
+  group('GetUtils.isLength* functions', () {
+    test('isLengthEqualTo should validate iterable lengths', () {
+      // iterables should cover list and set
+      expect(GetUtils.isLengthEqualTo([].map(_id), 0), true);
+      expect(GetUtils.isLengthEqualTo([1, 2].map(_id), 2), true);
+
+      expect(GetUtils.isLengthEqualTo({}, 0), true);
+      expect(GetUtils.isLengthEqualTo({1: 1, 2: 1}, 2), true);
+      expect(GetUtils.isLengthEqualTo({}, 2), false);
+
+      expect(GetUtils.isLengthEqualTo("", 0), true);
+      expect(GetUtils.isLengthEqualTo("a", 0), false);
+      expect(GetUtils.isLengthEqualTo("a", 1), true);
+    });
+
+    test('isLengthGreaterOrEqual should validate lengths', () {
+      // iterables should cover list and set
+      expect(GetUtils.isLengthGreaterOrEqual([].map(_id), 0), true);
+      expect(GetUtils.isLengthGreaterOrEqual([1, 2].map(_id), 2), true);
+      expect(GetUtils.isLengthGreaterOrEqual([1, 2].map(_id), 1), true);
+
+      expect(GetUtils.isLengthGreaterOrEqual({}, 0), true);
+      expect(GetUtils.isLengthGreaterOrEqual({1: 1, 2: 1}, 1), true);
+      expect(GetUtils.isLengthGreaterOrEqual({1: 1, 2: 1}, 2), true);
+      expect(GetUtils.isLengthGreaterOrEqual({}, 2), false);
+
+      expect(GetUtils.isLengthGreaterOrEqual("", 0), true);
+      expect(GetUtils.isLengthGreaterOrEqual("a", 0), true);
+      expect(GetUtils.isLengthGreaterOrEqual("", 1), false);
+    });
+
+    test('isLengthLessOrEqual should validate lengths', () {
+      // iterables should cover list and set
+      expect(GetUtils.isLengthLessOrEqual([].map(_id), 0), true);
+      expect(GetUtils.isLengthLessOrEqual([1, 2].map(_id), 2), true);
+      expect(GetUtils.isLengthLessOrEqual([1, 2].map(_id), 1), false);
+
+      expect(GetUtils.isLengthLessOrEqual({}, 0), true);
+      expect(GetUtils.isLengthLessOrEqual({1: 1, 2: 1}, 1), false);
+      expect(GetUtils.isLengthLessOrEqual({1: 1, 2: 1}, 3), true);
+      expect(GetUtils.isLengthLessOrEqual({}, 2), true);
+
+      expect(GetUtils.isLengthLessOrEqual("", 0), true);
+      expect(GetUtils.isLengthLessOrEqual("a", 2), true);
+      expect(GetUtils.isLengthLessOrEqual("a", 0), false);
+    });
+  });
+}