| /* |
| * 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.sling.launchpad.app; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import org.apache.sling.launchpad.base.shared.SharedConstants; |
| |
| import junit.framework.TestCase; |
| |
| public class MainTest extends TestCase { |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| System.setProperty("___sling_dont_exit___", "true"); |
| } |
| |
| public void test_parseCommandLine_null_args() { |
| String[] args = null; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertTrue("commandline map must be empty", commandline.isEmpty()); |
| } |
| |
| public void test_parseCommandLine_empty_args() { |
| String[] args = {}; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertTrue("commandline map must be empty", commandline.isEmpty()); |
| } |
| |
| public void test_parseCommandLine_single_dash() { |
| String[] args = { "-" }; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertTrue("commandline map must be empty", commandline.isEmpty()); |
| } |
| |
| public void test_parseCommandLine_single_arg_no_par() { |
| String[] args = { "-a" }; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertEquals("commandline map must have one entry", 1, |
| commandline.size()); |
| assertEquals("single argument must be " + args[0].charAt(1), |
| String.valueOf(args[0].charAt(1)), |
| commandline.keySet().iterator().next()); |
| assertEquals("single argument value must be " + args[0].charAt(1), |
| String.valueOf(args[0].charAt(1)), |
| commandline.values().iterator().next()); |
| } |
| |
| public void test_parseCommandLine_single_arg_with_par() { |
| String[] args = { "-a", "value" }; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertEquals("commandline map must have one entry", 1, |
| commandline.size()); |
| assertEquals("single argument must be " + args[0].charAt(1), |
| String.valueOf(args[0].charAt(1)), |
| commandline.keySet().iterator().next()); |
| assertEquals("single argument value must be " + args[1], args[1], |
| commandline.values().iterator().next()); |
| } |
| |
| public void test_parseCommandLine_two_args_no_par() { |
| String[] args = { "-a", "-b" }; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertEquals("commandline map must have two entries", 2, |
| commandline.size()); |
| assertEquals("argument a must a", "a", commandline.get("a")); |
| assertEquals("argument b must b", "b", commandline.get("b")); |
| } |
| |
| public void test_parseCommandLine_two_args_first_par() { |
| String[] args = { "-a", "apar", "-b" }; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertEquals("commandline map must have two entries", 2, |
| commandline.size()); |
| assertEquals("argument a must apar", "apar", commandline.get("a")); |
| assertEquals("argument b must b", "b", commandline.get("b")); |
| } |
| |
| public void test_parseCommandLine_two_args_second_par() { |
| String[] args = { "-a", "-b", "bpar" }; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertEquals("commandline map must have two entries", 2, |
| commandline.size()); |
| assertEquals("argument a must a", "a", commandline.get("a")); |
| assertEquals("argument b must bpar", "bpar", commandline.get("b")); |
| } |
| |
| public void test_parseCommandLine_two_args_all_par() { |
| String[] args = { "-a", "apar", "-b", "bpar" }; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertEquals("commandline map must have two entries", 2, |
| commandline.size()); |
| assertEquals("argument a must apar", "apar", commandline.get("a")); |
| assertEquals("argument b must bpar", "bpar", commandline.get("b")); |
| } |
| |
| public void test_parseCommandLine_three_args_with_dash() { |
| String[] args = { "-a", "apar", "-", "-b", "bpar" }; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertEquals("commandline map must have three entries", 3, |
| commandline.size()); |
| assertEquals("argument a must apar", "apar", commandline.get("a")); |
| assertEquals("argument -b must -b", "-b", commandline.get("-b")); |
| assertEquals("argument bpar must bpar", "bpar", commandline.get("bpar")); |
| } |
| |
| public void test_parseCommandLine_single_arg_with_dash_par() { |
| String[] args = { "-a", "-" }; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| assertNotNull("commandline map must not be null", commandline); |
| assertEquals("commandline map must have three entries", 1, |
| commandline.size()); |
| assertEquals("argument a must -", "-", commandline.get("a")); |
| } |
| |
| public void test_convertCommandLineArgs_no_args() { |
| Map<String, String> props = Main.convertCommandLineArgs(new HashMap<String, String>()); |
| assertNotNull(props); |
| assertTrue(props.isEmpty()); |
| } |
| |
| public void test_converCommandLineArgs_unknown() { |
| assertNull(Main.convertCommandLineArgs(Collections.singletonMap("u", "short"))); |
| assertNull(Main.convertCommandLineArgs(Collections.singletonMap("longer", "long"))); |
| } |
| |
| public void test_converCommandLineArgs_j_start_stop_status() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("j", "j")); |
| assertNull(props); |
| |
| Map<String, String> props1 = Main.convertCommandLineArgs(Collections.singletonMap("j", "host:port")); |
| assertNotNull(props1); |
| assertEquals(1, props1.size()); |
| assertEquals("host:port", props1.get("sling.control.socket")); |
| |
| Map<String, String> propsStart = Main.convertCommandLineArgs(Collections.singletonMap("start", "start")); |
| assertNotNull(propsStart); |
| assertEquals(1, propsStart.size()); |
| assertEquals("start", propsStart.get("sling.control.action")); |
| |
| Map<String, String> propsStatus = Main.convertCommandLineArgs(Collections.singletonMap("status", "status")); |
| assertNotNull(propsStatus); |
| assertEquals(1, propsStatus.size()); |
| assertEquals("status", propsStatus.get("sling.control.action")); |
| |
| Map<String, String> propsStop = Main.convertCommandLineArgs(Collections.singletonMap("stop", "stop")); |
| assertNotNull(propsStop); |
| assertEquals(1, propsStop.size()); |
| assertEquals("stop", propsStop.get("sling.control.action")); |
| } |
| |
| public void test_converCommandLineArgs_l() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("l", "INFO")); |
| assertNotNull(props); |
| assertEquals(1, props.size()); |
| assertEquals("INFO", props.get("org.apache.sling.commons.log.level")); |
| |
| Map<String, String> props2 = Main.convertCommandLineArgs(Collections.singletonMap("l", "l")); |
| assertNull(props2); |
| } |
| |
| public void test_converCommandLineArgs_f() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("f", "sling.changed")); |
| assertNotNull(props); |
| assertEquals(1, props.size()); |
| assertEquals("sling.changed", props.get("org.apache.sling.commons.log.file")); |
| |
| Map<String, String> props1 = Main.convertCommandLineArgs(Collections.singletonMap("f", "-")); |
| assertNotNull(props1); |
| assertEquals(1, props1.size()); |
| assertEquals("", props1.get("org.apache.sling.commons.log.file")); |
| |
| Map<String, String> props2 = Main.convertCommandLineArgs(Collections.singletonMap("f", "f")); |
| assertNull(props2); |
| } |
| |
| public void test_converCommandLineArgs_c() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("c", "sling.changed")); |
| assertNotNull(props); |
| assertEquals(1, props.size()); |
| assertEquals("sling.changed", props.get(SharedConstants.SLING_HOME)); |
| |
| Map<String, String> props2 = Main.convertCommandLineArgs(Collections.singletonMap("c", "c")); |
| assertNull(props2); |
| } |
| |
| public void test_converCommandLineArgs_i() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("i", "launchpad")); |
| assertNotNull(props); |
| assertEquals(1, props.size()); |
| assertEquals("launchpad", props.get(SharedConstants.SLING_LAUNCHPAD)); |
| |
| Map<String, String> props2 = Main.convertCommandLineArgs(Collections.singletonMap("i", "i")); |
| assertNull(props2); |
| } |
| |
| public void test_converCommandLineArgs_a() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("a", "0.0.0.0")); |
| assertNotNull(props); |
| assertEquals(1, props.size()); |
| assertEquals("0.0.0.0", props.get("org.apache.felix.http.host")); |
| } |
| |
| public void test_converCommandLineArgs_r() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("r", "/mycontext")); |
| assertNotNull(props); |
| assertEquals(1, props.size()); |
| assertEquals("/mycontext", props.get("org.apache.felix.http.context_path")); |
| } |
| |
| public void test_converCommandLineArgs_p() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("p", "1234")); |
| assertNotNull(props); |
| assertEquals(1, props.size()); |
| assertEquals("1234", props.get("org.osgi.service.http.port")); |
| |
| Map<String, String> props1 = Main.convertCommandLineArgs(Collections.singletonMap("p", "abc")); |
| assertNull(props1); |
| |
| Map<String, String> props2 = Main.convertCommandLineArgs(Collections.singletonMap("p", "p")); |
| assertNull(props2); |
| } |
| |
| public void test_converCommandLineArgs_n() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("n", "n")); |
| assertNotNull(props); |
| assertEquals(1, props.size()); |
| assertEquals(Boolean.FALSE.toString(), props.get("sling.shutdown.hook")); |
| |
| Map<String, String> props1 = Main.convertCommandLineArgs(Collections.singletonMap("D", "sling.shutdown.hook=" + Boolean.TRUE.toString())); |
| assertNotNull(props1); |
| assertEquals(1, props1.size()); |
| assertEquals(Boolean.TRUE.toString(), props1.get("sling.shutdown.hook")); |
| } |
| |
| public void test_converCommandLineArgs_multi_D() { |
| String[] args = {"-Da1=b1", "-Da2=b2"}; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| Map<String, String> props = Main.convertCommandLineArgs(commandline); |
| assertEquals(2, props.size()); |
| assertEquals("b1", props.get("a1")); |
| assertEquals("b2", props.get("a2")); |
| } |
| |
| public void test_converCommandLineArgs_multi_D_with_space() { |
| String[] args = {"-D", "a1=b1", "-D", "a2=b2"}; |
| Map<String, String> commandline = Main.parseCommandLine(args); |
| Map<String, String> props = Main.convertCommandLineArgs(commandline); |
| assertEquals(2, props.size()); |
| assertEquals("b1", props.get("a1")); |
| assertEquals("b2", props.get("a2")); |
| } |
| |
| public void test_converCommandLineArgs_D() { |
| Map<String, String> props = Main.convertCommandLineArgs(Collections.singletonMap("D", "name=value")); |
| assertNotNull(props); |
| assertEquals(1, props.size()); |
| assertEquals("value", props.get("name")); |
| |
| Map<String, String> props2 = Main.convertCommandLineArgs(Collections.singletonMap("D", "flag")); |
| assertNotNull(props2); |
| assertEquals(1, props2.size()); |
| assertEquals("flag", props2.get("flag")); |
| |
| Map<String, String> props1 = Main.convertCommandLineArgs(Collections.singletonMap("D", "D")); |
| assertNull(props1); |
| } |
| |
| public void test_installShutdownHook() throws SecurityException, NoSuchMethodException, IllegalArgumentException, |
| IllegalAccessException, InvocationTargetException { |
| final Method m = Main.class.getDeclaredMethod("installShutdownHook", Map.class); |
| m.setAccessible(true); |
| |
| final String key = "sling.shutdown.hook"; |
| System.getProperties().remove(key); |
| |
| TestCase.assertEquals(Boolean.TRUE, m.invoke(null, new HashMap<String, String>())); |
| TestCase.assertEquals(Boolean.TRUE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "true")))); |
| TestCase.assertEquals(Boolean.TRUE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "TRUE")))); |
| TestCase.assertEquals(Boolean.FALSE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "false")))); |
| TestCase.assertEquals(Boolean.FALSE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "not true")))); |
| |
| System.setProperty(key, "true"); |
| TestCase.assertEquals(Boolean.TRUE, m.invoke(null, new HashMap<String, String>())); |
| System.setProperty(key, "TRUE"); |
| TestCase.assertEquals(Boolean.TRUE, m.invoke(null, new HashMap<String, String>())); |
| System.setProperty(key, "false"); |
| TestCase.assertEquals(Boolean.FALSE, m.invoke(null, new HashMap<String, String>())); |
| System.setProperty(key, "not true"); |
| TestCase.assertEquals(Boolean.FALSE, m.invoke(null, new HashMap<String, String>())); |
| |
| System.setProperty(key, "true"); |
| TestCase.assertEquals(Boolean.TRUE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "true")))); |
| TestCase.assertEquals(Boolean.TRUE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "TRUE")))); |
| TestCase.assertEquals(Boolean.FALSE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "false")))); |
| TestCase.assertEquals(Boolean.FALSE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "not true")))); |
| |
| System.setProperty(key, "false"); |
| TestCase.assertEquals(Boolean.TRUE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "true")))); |
| TestCase.assertEquals(Boolean.TRUE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "TRUE")))); |
| TestCase.assertEquals(Boolean.FALSE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "false")))); |
| TestCase.assertEquals(Boolean.FALSE, m.invoke(null, new HashMap<String, String>(Collections.singletonMap(key, "not true")))); |
| } |
| } |