Use map instead of array to publish parameters.

Author: sbabcoc

src/main/java/com/nordstrom/automation/junit/ArtifactCollector.java

@@ -4,7 +4,6 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -123,12 +122,12 @@ private Path getCollectionPath() {
      * @return artifact file base name
      */
     private String getArtifactBaseName() {
-        if (getParameters().length == 0) {
-            return getDescription().getMethodName();
-        } else {
-            int hashcode = Arrays.deepHashCode(getParameters());
+        int hashcode = getParameters().hashCode();
+        if (hashcode != 0) {
             String hashStr = String.format("%08X", hashcode);
             return getDescription().getMethodName() + "-" + hashStr;
+        } else {
+            return getDescription().getMethodName();
         }
     }
 

src/main/java/com/nordstrom/automation/junit/ArtifactParams.java

@@ -1,5 +1,10 @@
 package com.nordstrom.automation.junit;
 
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
 import org.junit.runner.Description;
 
 /**
@@ -17,10 +22,61 @@ public interface ArtifactParams {
     /**
      * Get the parameters associated with this test class instance.
      * 
-     * @return array of test class parameters
+     * @return optional map of named test class parameters
+     */
+    default Optional<Map<String, Object>> getParameters() {
+        return Optional.empty();
+    }
+    
+    /**
+     * Assemble a map of test class instance parameters.
+     * 
+     * @param params array of {@link Param} objects; may be {@code null} or empty
+     * @return optional map of parameters (may be empty)
      */
-    default Object[] getParameters() {
-        return new Object[0];
+    public static Optional<Map<String, Object>> mapOf(Param... params) {
+        if ((params == null) || (params.length == 0)) {
+            return Optional.empty();
+        }
+        Map<String, Object> paramMap = new HashMap<>();
+        for (Param param : params) {
+            paramMap.put(param.key, param.val);
+        }
+        return Optional.of(Collections.unmodifiableMap(paramMap));
     }
 
+    /**
+     * Create a test parameter object for the specified key/value pair.
+     * 
+     * @param key test parameter key (name)
+     * @param val test parameter value
+     * @return test parameter object
+     */
+    public static Param param(String key, Object val) {
+        return new Param(key, val);
+    }
+    
+    /**
+     * This class defines a test parameter object.
+     */
+    static class Param {
+        
+        private final String key;
+        private final Object val;
+        
+        /**
+         * Constructor for test parameter object.
+         * 
+         * @param key test parameter key
+         * @param val test parameter value
+         */
+        public Param(String key, Object val) {
+            if ((key == null) || key.isEmpty()) {
+                throw new IllegalArgumentException("[key] must be a non-empty string");
+            }
+            this.key = key;
+            this.val = val;
+        }
+    }
+
 }

src/main/java/com/nordstrom/automation/junit/AtomIdentity.java

@@ -1,5 +1,8 @@
 package com.nordstrom.automation.junit;
 
+import java.util.Map;
+import java.util.Optional;
+
 import org.junit.rules.TestWatcher;
 import org.junit.runner.Description;
 
@@ -47,11 +50,11 @@ public Description getDescription() {
      * {@inheritDoc}
      */
     @Override
-    public Object[] getParameters() {
+    public Optional<Map<String, Object>> getParameters() {
         if (instance instanceof ArtifactParams) {
             return ((ArtifactParams) instance).getParameters();
         }
-        return new Object[0];
+        return Optional.empty();
     }
 
 }

src/test/java/com/nordstrom/automation/junit/ArtifactCollectorParameterized.java

@@ -1,6 +1,10 @@
 package com.nordstrom.automation.junit;
 
 import static org.junit.Assert.assertEquals;
+import static com.nordstrom.automation.junit.ArtifactParams.param;
+
+import java.util.Map;
+import java.util.Optional;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -22,12 +26,13 @@ public static Object[] data() {
     }
 
     @Override
-    public Object[] getParameters() {
-        return new Object[] { input };
+    public Optional<Map<String, Object>> getParameters() {
+        return ArtifactParams.mapOf(param("input", input));
     }
 
     @Test
     public void parameterized() {
+        System.out.println("parameterized: input = [" + input + "]");
         assertEquals("first test", input);
     }
 }

src/test/java/com/nordstrom/automation/junit/UnitTestArtifact.java

@@ -1,5 +1,6 @@
 package com.nordstrom.automation.junit;
 
+import java.util.Map.Entry;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -39,9 +40,10 @@ public byte[] getArtifact(Object instance, Throwable reason) {
             ArtifactParams publisher = (ArtifactParams) instance;
             StringBuilder artifact = new StringBuilder("method: ")
                             .append(publisher.getDescription().getMethodName()).append("\n");
-            int i = 0;
-            for (Object param : publisher.getParameters()) {
-                artifact.append("param" + i++ + ": [" + param + "]\n");
+            if (publisher.getParameters().isPresent()) {
+                for (Entry<String, Object> param : publisher.getParameters().get().entrySet()) {
+                    artifact.append(param.getKey() + ": [" + param.getValue() + "]\n");
+                }
             }
             return artifact.toString().getBytes().clone();
         } else {