Add more tests

Author: martijn00

test/src/datetime/date_time_validator_test.dart

@@ -92,6 +92,7 @@ void main() {
         result,
         equals(FormBuilderLocalizations.current.dateStringErrorText),
       );
+      expect(result, validator.errorText);
     });
 
     test(

test/src/form_field_validator_extensions_test.dart

@@ -179,5 +179,105 @@ void main() {
       // Pass
       expect(validatorWithMessage('test'), isNull);
     });
+
+    test('FormFieldValidatorExtensions.and with nested validators', () {
+      // Arrange
+      final FormFieldValidator<String> validator1 =
+          FormBuilderValidators.required();
+      final FormFieldValidator<String> validator2 =
+          FormBuilderValidators.minLength(5);
+      final FormFieldValidator<String> validator3 =
+          FormBuilderValidators.maxLength(10);
+      final FormFieldValidator<String> combinedValidator =
+          validator1.and(validator2.and(validator3));
+
+      // Act & Assert
+      // Pass
+      expect(combinedValidator('hello'), isNull);
+      expect(combinedValidator('hello123'), isNull);
+
+      // Fail
+      expect(combinedValidator(null), isNotNull);
+      expect(combinedValidator(''), isNotNull);
+      expect(combinedValidator('test'), isNotNull);
+      expect(combinedValidator('hello world'), isNotNull);
+    });
+
+    test('FormFieldValidatorExtensions.or with nested validators', () {
+      // Arrange
+      final FormFieldValidator<String> validator1 =
+          FormBuilderValidators.endsWith('world');
+      final FormFieldValidator<String> validator2 =
+          FormBuilderValidators.startsWith('Hello');
+      final FormFieldValidator<String> validator3 =
+          FormBuilderValidators.equal('test');
+      final FormFieldValidator<String> combinedValidator =
+          validator1.or(validator2.or(validator3));
+
+      // Act & Assert
+      // Pass
+      expect(combinedValidator('Hello world'), isNull);
+      expect(combinedValidator('Hello'), isNull);
+      expect(combinedValidator('test'), isNull);
+
+      // Fail
+      expect(combinedValidator('123 hello'), isNotNull);
+      expect(combinedValidator(null), isNotNull);
+      expect(combinedValidator(''), isNotNull);
+    });
+
+    test('FormFieldValidatorExtensions.transform with custom transformation',
+        () {
+      // Arrange
+      final FormFieldValidator<String> validator =
+          FormBuilderValidators.transform<String>(
+        (String? value) => value?.toUpperCase() ?? '',
+        FormBuilderValidators.match(RegExp(r'^[A-Z]+$')),
+      );
+
+      // Act & Assert
+      // Pass
+      expect(validator('abc'), isNull);
+      expect(validator('ABC'), isNull);
+
+      // Fail
+      expect(validator('abc123'), isNotNull);
+      expect(validator(null), isNotNull);
+      expect(validator(''), isNotNull);
+    });
+
+    test('FormFieldValidatorExtensions.when with custom condition', () {
+      // Arrange
+      final FormFieldValidator<String> validator =
+          FormBuilderValidators.required<String>();
+      final FormFieldValidator<String> conditionalValidator =
+          validator.when((String? value) => value != 'skip');
+
+      // Act & Assert
+      // Pass
+      expect(conditionalValidator('test'), isNull);
+
+      // Fail
+      expect(conditionalValidator('skip'), isNull);
+      expect(conditionalValidator(null), isNotNull);
+      expect(conditionalValidator(''), isNotNull);
+    });
+
+    test('FormFieldValidatorExtensions.unless with custom condition', () {
+      // Arrange
+      final FormFieldValidator<String> validator =
+          FormBuilderValidators.required<String>();
+      final FormFieldValidator<String> conditionalValidator =
+          validator.unless((String? value) => value == 'skip');
+
+      // Act & Assert
+      // Pass
+      expect(conditionalValidator('skip'), isNull);
+
+      // Fail
+      expect(conditionalValidator('test'), isNull);
+      expect(conditionalValidator(null), isNotNull);
+      expect(conditionalValidator(''), isNotNull);
+    });
   });
 }

test/src/identity/country_validator_test.dart

@@ -128,5 +128,15 @@ void main() {
         expect(result, FormBuilderLocalizations.current.countryErrorText);
       }
     });
+
+    test('should return null when no arguments are set in the constructor', () {
+      // Arrange
+      final CountryValidator validator = CountryValidator();
+
+      // Act & Assert
+      expect(validator.validate('United States'), isNull);
+      expect(validator.validate('Canada'), isNull);
+      expect(validator.validate('InvalidCountry'), isNull);
+    });
   });
 }

test/src/identity/ssn_validator_test.dart

@@ -133,5 +133,17 @@ void main() {
       // Assert
       expect(result, customErrorMessage);
     });
+
+    test('should return default error if the SSN is empty', () {
+      // Arrange
+      final SsnValidator validator = SsnValidator();
+      const String emptySsn = '';
+
+      // Act
+      final String? result = validator.validate(emptySsn);
+
+      // Assert
+      expect(result, validator.errorText);
+    });
   });
 }

test/src/identity/zip_code_validator_test.dart

@@ -126,5 +126,17 @@ void main() {
       // Assert
       expect(result, customErrorMessage);
     });
+
+    test('should return default error if the value is empty', () {
+      // Arrange
+      final ZipCodeValidator validator = ZipCodeValidator();
+      const String value = '';
+
+      // Act
+      final String? result = validator.validate(value);
+
+      // Assert
+      expect(result, validator.errorText);
+    });
   });
 }

test/src/numeric/min_validator_test.dart

@@ -249,5 +249,16 @@ void main() {
         ),
       );
     });
+
+    test('should return the default error message for invalid value types', () {
+      // Arrange
+      const MinValidator<bool> validator = MinValidator<bool>(1);
+
+      // Act & Assert
+      expect(
+        validator.validate(false),
+        equals(validator.errorText),
+      );
+    });
   });
 }

test/src/numeric/negative_number_validator_test.dart

@@ -237,5 +237,17 @@ void main() {
         ),
       );
     });
+
+    test('should return the default error message for invalid value types', () {
+      // Arrange
+      const NegativeNumberValidator<bool> validator =
+          NegativeNumberValidator<bool>();
+
+      // Act & Assert
+      expect(
+        validator.validate(false),
+        equals(validator.errorText),
+      );
+    });
   });
 }

test/src/numeric/not_zero_number_validator_test.dart

@@ -169,5 +169,17 @@ void main() {
         ),
       );
     });
+
+    test('should return the default error message for invalid value types', () {
+      // Arrange
+      const NotZeroNumberValidator<bool> validator =
+          NotZeroNumberValidator<bool>();
+
+      // Act & Assert
+      expect(
+        validator.validate(false),
+        equals(validator.errorText),
+      );
+    });
   });
 }

test/src/numeric/numeric_validator_test.dart

@@ -167,5 +167,16 @@ void main() {
         ),
       );
     });
+
+    test('should return the default error message for invalid value types', () {
+      // Arrange
+      const NumericValidator<bool> validator = NumericValidator<bool>();
+
+      // Act & Assert
+      expect(
+        validator.validate(false),
+        equals(validator.errorText),
+      );
+    });
   });
 }

test/src/numeric/positive_number_validator_test.dart

@@ -38,6 +38,10 @@ void main() {
           FormBuilderLocalizations.current.positiveNumberErrorText,
         ),
       );
+      expect(
+        result,
+        equals(validator.errorText),
+      );
     });
 
     test('should return the custom error message if the value is zero', () {
@@ -279,5 +283,17 @@ void main() {
       // Assert
       expect(result, equals(customErrorMessage));
     });
+
+    test('should return the default error message for invalid value types', () {
+      // Arrange
+      const PositiveNumberValidator<bool> validator =
+          PositiveNumberValidator<bool>();
+
+      // Act & Assert
+      expect(
+        validator.validate(false),
+        equals(validator.errorText),
+      );
+    });
   });
 }