Added parameterized tests and related fixes

.github/workflows/gradle.yml

@@ -48,7 +48,7 @@ jobs:
             ${{ runner.os }}-gradle-${{ matrix.java-version }}-
 
       - name: Test with Gradle
-        run: ./gradlew build check --stacktrace
+        run: ./gradlew build check --stacktrace -PtestsBadgeApiKey=${{ secrets.TESTS_BADGE_API_KEY }}
 
       - name: SonarCloud
         if: success() && matrix.java-version == env.SONAR_JDK

README.md

@@ -4,6 +4,7 @@
 [![Maven Central Repo](https://maven-badges.herokuapp.com/maven-central/com.uwyn/urlencoder/badge.svg?color=blue)](https://maven-badges.herokuapp.com/maven-central/com.uwyn/urlencoder)
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=gbevin_urlencoder&metric=alert_status)](https://sonarcloud.io/dashboard?id=gbevin_urlencoder)
 [![GitHub CI](https://github.com/gbevin/urlencoder/actions/workflows/gradle.yml/badge.svg)](https://github.com/gbevin/urlencoder/actions/workflows/gradle.yml)
+[![Tests](https://rife2.com/tests-badge/badge/com.uwyn/urlencoder)](https://github.com/gbevin/urlencoder/actions/workflows/gradle.yml)
 
 # URL Encoder for Java
 

lib/build.gradle.kts

@@ -1,5 +1,7 @@
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.api.tasks.testing.logging.TestLogEvent
+import java.net.*
+import java.net.http.*
 
 plugins {
     application
@@ -55,12 +57,45 @@ tasks {
         }
     }
 
-    withType<Test> {
+    test {
         useJUnitPlatform()
         testLogging {
             exceptionFormat = TestExceptionFormat.FULL
             events = setOf(TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.FAILED)
         }
+        addTestListener(object : TestListener {
+            override fun beforeTest(p0: TestDescriptor?) = Unit
+            override fun beforeSuite(p0: TestDescriptor?) = Unit
+            override fun afterTest(desc: TestDescriptor, result: TestResult) = Unit
+            override fun afterSuite(desc: TestDescriptor, result: TestResult) {
+                if (desc.parent == null) {
+                    val passed = result.successfulTestCount
+                    val failed = result.failedTestCount
+                    val skipped = result.skippedTestCount
+
+                    if (project.properties["testsBadgeApiKey"] != null) {
+                        val apiKey = project.properties["testsBadgeApiKey"]
+                        val response: java.net.http.HttpResponse<String> = HttpClient.newHttpClient()
+                            .send(
+                                HttpRequest.newBuilder()
+                                    .uri(
+                                        URI(
+                                            "https://rife2.com/tests-badge/update/com.uwyn/urlencoder?" +
+                                                    "apiKey=$apiKey&" +
+                                                    "passed=$passed&" +
+                                                    "failed=$failed&" +
+                                                    "skipped=$skipped"
+                                        )
+                                    )
+                                    .POST(HttpRequest.BodyPublishers.noBody())
+                                    .build(), HttpResponse.BodyHandlers.ofString()
+                            )
+                        println("RESPONSE: " + response.statusCode())
+                        println(response.body())
+                    }
+                }
+            }
+        })
     }
 
     jacocoTestReport {

lib/src/main/java/com/uwyn/urlencoder/UrlEncoder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Copyright 2001-2023 Geert Bevin (gbevin[remove] at uwyn dot com)
  * Licensed under the Apache License, Version 2.0 (the "License")
  */
 package com.uwyn.urlencoder;
@@ -167,7 +167,7 @@ public final class UrlEncoder {
      * @since 1.0
      */
     public static String encode(String source, String allow) {
-        if (source == null || source.isBlank()) {
+        if (source == null || source.isEmpty()) {
             return source;
         }
 
@@ -246,7 +246,7 @@ public final class UrlEncoder {
         }
 
         var text = "";
-        if (args.size() == 1) {
+        if (args.size() == 1 && !args.get(0).isEmpty()) {
             text = args.remove(0);
             valid_arguments = true;
         }

lib/src/test/java/com/uwyn/urlencoder/UrlEncoderTest.java

@@ -1,137 +1,150 @@
 /*
- * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Copyright 2001-2023 Geert Bevin (gbevin[remove] at uwyn dot com)
  * Licensed under the Apache License, Version 2.0 (the "License")
  */
 package com.uwyn.urlencoder;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
 
-import java.util.Map;
+import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
 
 class UrlEncoderTest {
-    private String[] invalid = {"sdkjfh%", "sdkjfh%6", "sdkjfh%xx", "sdfjfh%-1"};
-    private String same = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVQXYZ0123456789-_.~";
-    private Map<String, String> validMap = Map.of(
-            "a test &", "a%20test%20%26",
-            "!abcdefghijklmnopqrstuvwxyz%%ABCDEFGHIJKLMNOPQRSTUVQXYZ0123456789-_.~=",
-            "%21abcdefghijklmnopqrstuvwxyz%25%25ABCDEFGHIJKLMNOPQRSTUVQXYZ0123456789-_.~%3D",
-            "%#okékÉȢ smile!😁", "%25%23ok%C3%A9k%C3%89%C8%A2%20smile%21%F0%9F%98%81"
-    );
+    private final String same = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVQXYZ0123456789-_.~";
+
+    private static Stream<String> invalid() {
+        return Stream.of("sdkjfh%", "sdkjfh%6", "sdkjfh%xx", "sdfjfh%-1");
+    }
+
+    private static Stream<Arguments> validMap() {
+        return Stream.of(
+                arguments("a test &", "a%20test%20%26"),
+                arguments(
+                        "!abcdefghijklmnopqrstuvwxyz%%ABCDEFGHIJKLMNOPQRSTUVQXYZ0123456789-_.~=",
+                        "%21abcdefghijklmnopqrstuvwxyz%25%25ABCDEFGHIJKLMNOPQRSTUVQXYZ0123456789-_.~%3D"
+                ),
+                arguments("%#okékÉȢ smile!😁", "%25%23ok%C3%A9k%C3%89%C8%A2%20smile%21%F0%9F%98%81"),
+                arguments(
+                        "\uD808\uDC00\uD809\uDD00\uD808\uDF00\uD808\uDD00",
+                        "%F0%92%80%80%F0%92%94%80%F0%92%8C%80%F0%92%84%80"
+                )
+        );
+    }
+
+    @ParameterizedTest(name = "decode({0}) should be {1}")
+    @MethodSource("validMap")
+    void testDecodeUrl(String expected, String source) {
+        assertEquals(expected, UrlEncoder.decode(source));
+    }
 
     @Test
-    void testDecodeURL() {
-        assertNull(UrlEncoder.decode(null));
-        assertSame("", UrlEncoder.decode(""));
+    void testDecodeNotNeeded() {
         assertSame(same, UrlEncoder.decode(same));
-        validMap.forEach((expected, source) -> assertEquals(expected, UrlEncoder.decode(source)));
+        assertEquals("", UrlEncoder.decode(""), "decode('')");
+        assertEquals(" ", UrlEncoder.decode(" "), "decode(' ')");
+    }
 
-        for (String i : invalid) {
-            assertThrows(IllegalArgumentException.class, () -> UrlEncoder.decode(i));
-        }
+    @ParameterizedTest(name = "decode({0})")
+    @MethodSource("invalid")
+    void testDecodeWithException(String source) {
+        assertThrows(IllegalArgumentException.class, () -> UrlEncoder.decode(source), "decode(" + source + ")");
     }
 
     @Test
-    void testEncodeURL() {
-        assertNull(UrlEncoder.encode(null));
-        assertTrue(UrlEncoder.encode("").isEmpty());
+    void testDecodeWithNull() {
+        assertNull(UrlEncoder.decode(null), "decode(null)");
+    }
+
+    @Test
+    void testEncodeWhenNoneNeeded() {
         assertSame(same, UrlEncoder.encode(same));
-        assertSame(same, UrlEncoder.encode(same, ""));
-        validMap.forEach((source, expected) -> assertEquals(expected, UrlEncoder.encode(source)));
-
-        assertEquals("?test=a%20test", UrlEncoder.encode("?test=a test", "?="));
-        assertEquals("?test=a%20test", UrlEncoder.encode("?test=a test", '?', '='));
-        assertEquals("aaa", UrlEncoder.encode("aaa", 'a'));
+        assertSame(same, UrlEncoder.encode(same, ""), "with empty allow");
     }
 
     @Test
-    void testMainNoArgs() {
-        var result = UrlEncoder.processMain(new String[0]);
-        assertEquals(1, result.status);
-        assertTrue(result.output.contains("Usage :"));
+    void testEncodeWithAllowArg() {
+        assertEquals("?test=a%20test", UrlEncoder.encode("?test=a test", '=', '?'), "encode(x, =, ?)");
+        assertEquals("?test=a%20test", UrlEncoder.encode("?test=a test", "=?"), "encode(x, =?)");
+        assertEquals("aaa", UrlEncoder.encode("aaa", 'a'), "encode(aaa, a)");
+        assertEquals(" ", UrlEncoder.encode(" ", ' '), "encode(' ', ' ')");
+    }
+
+    @Test
+    void testEncodeWithEmptyOrBlank() {
+        assertTrue(UrlEncoder.encode("", "").isEmpty(), "encode('','')");
+        assertEquals("", UrlEncoder.encode(""), "encode('')");
+        assertEquals("%20", UrlEncoder.encode(" "), "encode('')");
+    }
+
+    @ParameterizedTest(name = "encode({0}) should be {1}")
+    @MethodSource("validMap")
+    void testEncodeUrl(String source, String expected) {
+        assertEquals(expected, UrlEncoder.encode(source));
+    }
+
+    @Test
+    void testEncodeWithNulls() {
+        assertNull(UrlEncoder.encode(null), "encode(null)");
+        assertNull(UrlEncoder.encode(null, (String) null), "encode(null, null)");
+        assertEquals("foo", UrlEncoder.encode("foo", (String) null), "encode(foo, null");
+    }
+
+    @ParameterizedTest(name = "processMain(-d {1}) should be {0}")
+    @MethodSource("validMap")
+    void testMainDecode(String expected, String source) {
+        var result = UrlEncoder.processMain(new String[]{"-d", source});
+        assertEquals(expected, result.output);
+        assertEquals(0, result.status, "processMain(-d " + source + ").status");
+    }
+
+    @ParameterizedTest(name = "processMain(-e {0})")
+    @MethodSource("validMap")
+    void testMainEncode(String source, String expected) {
+        var result = UrlEncoder.processMain(new String[]{source});
+        assertEquals(expected, result.output);
+        assertEquals(0, result.status, "processMain(-e " + source + ").status");
+    }
+
+    @ParameterizedTest(name = "processMain(-d {0})")
+    @MethodSource("invalid")
+    void testMainEncodeWithExceptions(String source) {
+        assertThrows(IllegalArgumentException.class, () -> UrlEncoder.processMain(new String[]{"-d", source}), source);
     }
 
     @Test
     void testMainTooManyArgs() {
-        var result = UrlEncoder.processMain(new String[] {"-x", "-g", "f"});
-        assertEquals(1, result.status);
-        assertTrue(result.output.contains("Usage :"));
+        assertTrue(UrlEncoder.processMain(new String[]{"foo", "bar", "test"}).output.contains("Usage :"), "too many args");
     }
 
     @Test
-    void testMainMissingEncodeText() {
-        var result = UrlEncoder.processMain(new String[] {"-e"});
-        assertEquals(1, result.status);
-        assertTrue(result.output.contains("Usage :"));
+    void testMainWithEmptyArgs() {
+        assertTrue(UrlEncoder.processMain(new String[]{" ", " "}).output.contains("Usage :"), "processMain(' ', ' ')");
+        assertTrue(UrlEncoder.processMain(new String[]{"foo", " "}).output.contains("Usage :"), "processMain('foo', ' ')");
+        assertTrue(UrlEncoder.processMain(new String[]{" ", "foo"}).output.contains("Usage :"), "processMain(' ', 'foo')");
+        assertTrue(UrlEncoder.processMain(new String[]{"-d ", ""}).output.contains("Usage :"), "processMain('-d', '')");
+        assertEquals("%20", UrlEncoder.processMain(new String[]{"-e", " "}).output, "processMain('-e', ' ')");
+        assertEquals(" ", UrlEncoder.processMain(new String[]{"-d", " "}).output, "processMain('-d', ' ')");
     }
 
-    @Test
-    void testMainMissingDecodeText() {
-        var result = UrlEncoder.processMain(new String[] {"-d"});
-        assertEquals(1, result.status);
-        assertTrue(result.output.contains("Usage :"));
+    @ParameterizedTest
+    @ValueSource(strings = {"", "-d", "-e"})
+    void testMainWithInvalidArgs(String arg) {
+        var result = UrlEncoder.processMain(new String[]{arg});
+        assertTrue(result.output.contains("Usage :"), "processMain('" + arg + "')");
+        assertEquals(1, result.status, "processMain('" + arg + "').status");
     }
 
-    @Test
-    void testMainWrongArgs1() {
-        var result = UrlEncoder.processMain(new String[] {"-p"});
-        assertEquals(1, result.status);
-        assertTrue(result.output.contains("Usage :"));
+    @ParameterizedTest(name = "processMain(-e {0})")
+    @MethodSource("validMap")
+    void testMainWithOption(String source, String expected) {
+        var result = UrlEncoder.processMain(new String[]{"-e", source});
+        assertEquals(expected, result.output);
+        assertEquals(0, result.status, "processMain(-e " + source + ").status");
     }
-
-    @Test
-    void testMainWrongArgs2() {
-        var result = UrlEncoder.processMain(new String[] {"-x", "txt"});
-        assertEquals(1, result.status);
-        assertTrue(result.output.contains("Usage :"));
-    }
-
-    @Test
-    void testMainWrongArgs3() {
-        var result = UrlEncoder.processMain(new String[] {"stuff", "txt"});
-        assertEquals(1, result.status);
-        assertTrue(result.output.contains("Usage :"));
-    }
-
-    @Test
-    void testMainWrongArgs4() {
-        var result = UrlEncoder.processMain(new String[] {"-d", "stuff", "txt"});
-        assertEquals(1, result.status);
-        assertTrue(result.output.contains("Usage :"));
-    }
-
-    @Test
-    void testMainWrongArgs5() {
-        var result = UrlEncoder.processMain(new String[] {"-e", "stuff", "txt"});
-        assertEquals(1, result.status);
-        assertTrue(result.output.contains("Usage :"));
-    }
-
-    @Test
-    void testDecodeMainOption() {
-        validMap.forEach((expected, source) -> {
-            var result = UrlEncoder.processMain(new String[] {"-d", source});
-            assertEquals(0, result.status);
-            assertEquals(expected, result.output);
-        });
-    }
-
-    @Test
-    void testEncodeMainDefault() {
-        validMap.forEach((source, expected) -> {
-            var result = UrlEncoder.processMain(new String[] {source});
-            assertEquals(0, result.status);
-            assertEquals(expected, result.output);
-        });
-    }
-
-    @Test
-    void testEncodeMainOption() {
-        validMap.forEach((source, expected) -> {
-            var result = UrlEncoder.processMain(new String[] {"-e", source});
-            assertEquals(0, result.status);
-            assertEquals(expected, result.output);
-        });
-    }
-}
+}