init

test/org/apache/catalina/util/TestParameterMap.java

@@ -0,0 +1,254 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.catalina.util;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class TestParameterMap {
+
+    private static final String[] TEST_PARAM_VALUES_1 = { "value1" };
+    private static final String[] TEST_PARAM_VALUES_2 = { "value2" };
+    private static final String[] TEST_PARAM_VALUES_2_UPDATED = { "value2-updated" };
+    private static final String[] TEST_PARAM_VALUES_3 = { "value3" };
+
+    private Map<String, String[]> paramMap;
+
+    @Before
+    public void setUp() {
+        paramMap = new ParameterMap<>();
+
+        paramMap.put("param1", TEST_PARAM_VALUES_1);
+        paramMap.put("param2", TEST_PARAM_VALUES_2);
+        paramMap.put("param3", TEST_PARAM_VALUES_3);
+
+        Assert.assertTrue(paramMap.containsKey("param1"));
+        Assert.assertArrayEquals(TEST_PARAM_VALUES_1, paramMap.get("param1"));
+        Assert.assertTrue(paramMap.containsKey("param2"));
+        Assert.assertArrayEquals(TEST_PARAM_VALUES_2, paramMap.get("param2"));
+        Assert.assertTrue(paramMap.containsKey("param3"));
+        Assert.assertArrayEquals(TEST_PARAM_VALUES_3, paramMap.get("param3"));
+
+        final Set<String> keySet = paramMap.keySet();
+        Assert.assertTrue(keySet.contains("param1"));
+        Assert.assertTrue(keySet.contains("param2"));
+        Assert.assertTrue(keySet.contains("param3"));
+
+        paramMap.put("param2", TEST_PARAM_VALUES_2_UPDATED);
+        paramMap.remove("param3");
+
+        Assert.assertTrue(paramMap.containsKey("param1"));
+        Assert.assertArrayEquals(TEST_PARAM_VALUES_1, paramMap.get("param1"));
+        Assert.assertTrue(paramMap.containsKey("param2"));
+        Assert.assertArrayEquals(TEST_PARAM_VALUES_2_UPDATED, paramMap.get("param2"));
+        Assert.assertFalse(paramMap.containsKey("param3"));
+        Assert.assertNull(paramMap.get("param3"));
+
+        Assert.assertTrue(keySet.contains("param1"));
+        Assert.assertTrue(keySet.contains("param2"));
+        Assert.assertFalse(keySet.contains("param3"));
+    }
+
+    @After
+    public void tearDown() {
+        Assert.assertTrue(paramMap.containsKey("param1"));
+        Assert.assertArrayEquals(TEST_PARAM_VALUES_1, paramMap.get("param1"));
+        Assert.assertTrue(paramMap.containsKey("param2"));
+        Assert.assertArrayEquals(TEST_PARAM_VALUES_2_UPDATED, paramMap.get("param2"));
+        Assert.assertFalse(paramMap.containsKey("param3"));
+        Assert.assertNull(paramMap.get("param3"));
+    }
+
+    @Test
+    public void testMapImmutabilityAfterLocked() {
+        ((ParameterMap<String, String[]>) paramMap).setLocked(true);
+
+        try {
+            String[] updatedParamValues22 = new String[] { "value2-updated-2" };
+            paramMap.put("param2", updatedParamValues22);
+            Assert.fail("ParameterMap is not locked.");
+        } catch (IllegalStateException expectedException) {
+        }
+
+        try {
+            final Map<String, String[]> additionalParams = new HashMap<>();
+            additionalParams.put("param4", new String[] { "value4" });
+            paramMap.putAll(additionalParams);
+            Assert.fail("ParameterMap is not locked.");
+        } catch (IllegalStateException expectedException) {
+        }
+
+        try {
+            paramMap.remove("param2");
+            Assert.fail("ParameterMap is not locked.");
+        } catch (IllegalStateException expectedException) {
+        }
+
+        try {
+            paramMap.clear();
+            Assert.fail("ParameterMap is not locked.");
+        } catch (IllegalStateException expectedException) {
+        }
+    }
+
+    @Test
+    public void testKeySetImmutabilityAfterLocked() {
+        ((ParameterMap<String, String[]>) paramMap).setLocked(true);
+
+        final Set<String> keySet = paramMap.keySet();
+
+        try {
+            keySet.add("param4");
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            keySet.remove("param2");
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            keySet.removeAll(Arrays.asList("param1", "param2"));
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            keySet.retainAll(Collections.emptyList());
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            keySet.clear();
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+    }
+
+    @Test
+    public void testValuesImmutabilityAfterLocked() {
+        ((ParameterMap<String, String[]>) paramMap).setLocked(true);
+
+        final Collection<String[]> valuesCol = paramMap.values();
+
+        try {
+            valuesCol.add(new String[] { "value4" });
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            List<String[]> list = new ArrayList<>();
+            list.add(new String[] { "value4" });
+            valuesCol.addAll(list);
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            valuesCol.remove(TEST_PARAM_VALUES_1);
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            List<String[]> list = new ArrayList<>();
+            list.add(TEST_PARAM_VALUES_1);
+            valuesCol.removeAll(list);
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            valuesCol.retainAll(Collections.emptyList());
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            valuesCol.clear();
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+    }
+
+    @Test
+    public void testEntrySetImmutabilityAfterLocked() {
+        ((ParameterMap<String, String[]>) paramMap).setLocked(true);
+
+        final Set<Map.Entry<String, String[]>> entrySet = paramMap.entrySet();
+
+        try {
+            final Map<String, String[]> anotherParamsMap = new HashMap<>();
+            anotherParamsMap.put("param4", new String[] { "value4" });
+            Map.Entry<String, String[]> anotherEntry = anotherParamsMap.entrySet().iterator().next();
+            entrySet.add(anotherEntry);
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            final Map<String, String[]> anotherParamsMap = new HashMap<>();
+            anotherParamsMap.put("param4", new String[] { "value4" });
+            anotherParamsMap.put("param5", new String[] { "value5" });
+            entrySet.addAll(anotherParamsMap.entrySet());
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            final Map.Entry<String, String[]> entry = entrySet.iterator().next();
+            entrySet.remove(entry);
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            Set<Map.Entry<String, String[]>> anotherEntrySet = new HashSet<>(entrySet);
+            entrySet.removeAll(anotherEntrySet);
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            entrySet.retainAll(Collections.emptySet());
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+
+        try {
+            entrySet.clear();
+            Assert.fail("ParameterMap is not locked.");
+        } catch (UnsupportedOperationException expectedException) {
+        }
+    }
+}