cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sate...@apache.org
Subject [11/50] [abbrv] git commit: updated refs/heads/deploy-from-snapshot to 44ba14d
Date Thu, 16 Jun 2016 08:12:12 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/StringUtilsTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/StringUtilsTest.java b/utils/src/test/java/com/cloud/utils/StringUtilsTest.java
new file mode 100644
index 0000000..3619ede
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/StringUtilsTest.java
@@ -0,0 +1,253 @@
+//
+// 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 com.cloud.utils;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import org.junit.Test;
+
+public class StringUtilsTest {
+
+    @Test
+    public void testGetPreferredCharset() {
+        final boolean ifUtf8Supported = StringUtils.isUtf8Supported();
+        if (ifUtf8Supported) {
+            assertEquals(StringUtils.getPreferredCharset(), Charset.forName("UTF-8"));
+        } else {
+            assertNotEquals(StringUtils.getPreferredCharset(), Charset.forName("UTF-8"));
+        }
+    }
+
+    @Test
+    public void testGetDefaultCharset() {
+        // Is this test irrelevant? Is wrapping the Charset.defaultCharset() too much?
+        // This test was added in order to cover the new StringUtils.getDefaultCharset().
+        // One cannot be sure that StringUtils.getPreferredCharset() will always be
+        // equals to Charset.defaultCharset()
+        assertEquals(StringUtils.getDefaultCharset(), Charset.defaultCharset());
+    }
+
+    @Test
+    public void testCleanPasswordFromJsonObjectAtEnd() {
+        final String input = "{\"foo\":\"bar\",\"password\":\"test\"}";
+        //TODO: It would be nice to clean up the regex in question to not
+        //have to return the trailing comma in the expected string below
+        final String expected = "{\"foo\":\"bar\",}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromJsonObjectInMiddle() {
+        final String input = "{\"foo\":\"bar\",\"password\":\"test\",\"test\":\"blah\"}";
+        final String expected = "{\"foo\":\"bar\",\"test\":\"blah\"}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromJsonObjectAlone() {
+        final String input = "{\"password\":\"test\"}";
+        final String expected = "{}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromJsonObjectAtStart() {
+        final String input = "{\"password\":\"test\",\"test\":\"blah\"}";
+        final String expected = "{\"test\":\"blah\"}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromJsonObjectWithMultiplePasswords() {
+        final String input = "{\"description\":\"foo\"}],\"password\":\"bar\",\"nic\":[{\"password\":\"bar2\",\"id\":\"1\"}]}";
+        final String expected = "{\"description\":\"foo\"}],\"nic\":[{\"id\":\"1\"}]}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromRequestString() {
+        final String input = "username=foo&password=bar&url=foobar";
+        final String expected = "username=foo&url=foobar";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromEncodedRequestString() {
+        final String input = "name=SS1&provider=SMB&zoneid=5a60af2b-3025-4f2a-9ecc-8e33bf2b94e3&url=cifs%3A%2F%2F10.102.192.150%2FSMB-Share%2Fsowmya%2Fsecondary%3Fuser%3Dsowmya%26password%3DXXXXX%40123%26domain%3DBLR";
+        final String expected = "name=SS1&provider=SMB&zoneid=5a60af2b-3025-4f2a-9ecc-8e33bf2b94e3&url=cifs%3A%2F%2F10.102.192.150%2FSMB-Share%2Fsowmya%2Fsecondary%3Fuser%3Dsowmya%26domain%3DBLR";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromRequestStringWithMultiplePasswords() {
+        final String input = "username=foo&password=bar&url=foobar&password=bar2&test=4";
+        final String expected = "username=foo&url=foobar&test=4";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromRequestStringMatchedAtEndSingleQuote() {
+        final String input = "'username=foo&password=bar'";
+        final String expected = "'username=foo'";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromRequestStringMatchedAtEndDoubleQuote() {
+        final String input = "\"username=foo&password=bar\"";
+        final String expected = "\"username=foo\"";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanPasswordFromRequestStringMatchedAtMiddleDoubleQuote() {
+        final String input = "\"username=foo&password=bar&goo=sdf\"";
+        final String expected = "\"username=foo&goo=sdf\"";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testJoin() {
+        assertEquals("a-b-c", StringUtils.join("-", "a", "b", "c"));
+        assertEquals("", StringUtils.join("-"));
+    }
+
+    @Test
+    public void testCleanSecretkeyFromJsonObjectAtEnd() {
+        final String input = "{\"foo\":\"bar\",\"secretkey\":\"test\"}";
+        // TODO: It would be nice to clean up the regex in question to not
+        // have to return the trailing comma in the expected string below
+        final String expected = "{\"foo\":\"bar\",}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanSecretkeyFromJsonObjectInMiddle() {
+        final String input = "{\"foo\":\"bar\",\"secretkey\":\"test\",\"test\":\"blah\"}";
+        final String expected = "{\"foo\":\"bar\",\"test\":\"blah\"}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanSecretkeyFromJsonObjectAlone() {
+        final String input = "{\"secretkey\":\"test\"}";
+        final String expected = "{}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanSecretkeyFromJsonObjectAtStart() {
+        final String input = "{\"secretkey\":\"test\",\"test\":\"blah\"}";
+        final String expected = "{\"test\":\"blah\"}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanSecretkeyFromJsonObjectWithMultiplePasswords() {
+        final String input = "{\"description\":\"foo\"}],\"secretkey\":\"bar\",\"nic\":[{\"secretkey\":\"bar2\",\"id\":\"1\"}]}";
+        final String expected = "{\"description\":\"foo\"}],\"nic\":[{\"id\":\"1\"}]}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanAccesskeyFromJsonObjectAtEnd() {
+        final String input = "{\"foo\":\"bar\",\"accesskey\":\"test\"}";
+        // TODO: It would be nice to clean up the regex in question to not
+        // have to return the trailing comma in the expected string below
+        final String expected = "{\"foo\":\"bar\",}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanAccesskeyFromJsonObjectInMiddle() {
+        final String input = "{\"foo\":\"bar\",\"accesskey\":\"test\",\"test\":\"blah\"}";
+        final String expected = "{\"foo\":\"bar\",\"test\":\"blah\"}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanAccesskeyFromJsonObjectAlone() {
+        final String input = "{\"accesskey\":\"test\"}";
+        final String expected = "{}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanAccesskeyFromJsonObjectAtStart() {
+        final String input = "{\"accesskey\":\"test\",\"test\":\"blah\"}";
+        final String expected = "{\"test\":\"blah\"}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanAccesskeyFromJsonObjectWithMultiplePasswords() {
+        final String input = "{\"description\":\"foo\"}],\"accesskey\":\"bar\",\"nic\":[{\"accesskey\":\"bar2\",\"id\":\"1\"}]}";
+        final String expected = "{\"description\":\"foo\"}],\"nic\":[{\"id\":\"1\"}]}";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanAccesskeyFromRequestString() {
+        final String input = "username=foo&accesskey=bar&url=foobar";
+        final String expected = "username=foo&url=foobar";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void testCleanSecretkeyFromRequestString() {
+        final String input = "username=foo&secretkey=bar&url=foobar";
+        final String expected = "username=foo&url=foobar";
+        final String result = StringUtils.cleanString(input);
+        assertEquals(result, expected);
+    }
+
+    @Test
+    public void listToCsvTags() {
+        assertEquals("a,b,c", StringUtils.listToCsvTags(Arrays.asList("a","b", "c")));
+        assertEquals("", StringUtils.listToCsvTags(new ArrayList<String>()));
+    }
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/TernaryTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/TernaryTest.java b/utils/src/test/java/com/cloud/utils/TernaryTest.java
new file mode 100644
index 0000000..cacbecb
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/TernaryTest.java
@@ -0,0 +1,34 @@
+//
+// 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 com.cloud.utils;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TernaryTest {
+    @Test
+    public void testEquals() {
+        Assert.assertEquals(new Ternary<String, String, String>("a", "b", "c"), new Ternary<String, String, String>("a", "b", "c"));
+        Assert.assertFalse(new Ternary<String, String, String>("a", "b", "c").equals(new Ternary<String, String, String>("a", "b", "d")));
+        Assert.assertFalse(new Ternary<String, String, String>("a", "b", "c").equals(""));
+        Assert.assertFalse(new Ternary<String, String, String>("a", "b", "c").equals(null));
+        Assert.assertFalse(new Ternary<String, String, String>("a", "b", "c").equals(new Pair<String, String>("a", "b")));
+    }
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/TestProfiler.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/TestProfiler.java b/utils/src/test/java/com/cloud/utils/TestProfiler.java
new file mode 100644
index 0000000..2306cd7
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/TestProfiler.java
@@ -0,0 +1,116 @@
+//
+// 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 com.cloud.utils;
+
+import org.apache.log4j.Logger;
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.cloud.utils.testcase.Log4jEnabledTestCase;
+
+public class TestProfiler extends Log4jEnabledTestCase {
+    protected final static Logger s_logger = Logger.getLogger(TestProfiler.class);
+
+    private static final long ONE_SECOND = 1000l;
+    private static final long MILLIS_FACTOR = 1000l;
+    private static final int MARGIN = 100;
+    private static final double EXPONENT = 3d;
+
+    @Test
+    public void testProfilerInMillis() {
+        s_logger.info("testProfiler() started");
+
+        final Profiler pf = new Profiler();
+        pf.start();
+        try {
+            Thread.sleep(ONE_SECOND);
+        } catch (final InterruptedException e) {
+        }
+        pf.stop();
+
+        final long durationInMillis = pf.getDurationInMillis();
+        s_logger.info("Duration in Millis: " + durationInMillis);
+
+        // An error margin in order to cover the time taken by the star/stop calls.
+        // 100 milliseconds margin seems too much, but it will avoid assertion error
+        // and also fail in case a duration in nanoseconds is used instead.
+        Assert.assertTrue(durationInMillis >= MILLIS_FACTOR  &&  durationInMillis <= MILLIS_FACTOR + MARGIN);
+
+        s_logger.info("testProfiler() stopped");
+    }
+
+    @Test
+    public void testProfilerInNano() {
+        final Profiler pf = new Profiler();
+        pf.start();
+        try {
+            Thread.sleep(ONE_SECOND);
+        } catch (final InterruptedException e) {
+        }
+        pf.stop();
+
+        final long duration = pf.getDuration();
+        s_logger.info("Duration in Nano: " + duration);
+        Assert.assertTrue(duration >= Math.pow(MILLIS_FACTOR, EXPONENT));
+    }
+
+    @Test
+    public void testProfilerNoStart() {
+        final Profiler pf = new Profiler();
+        try {
+            Thread.sleep(20);
+        } catch (final InterruptedException e) {
+        }
+        pf.stop();
+
+        Assert.assertTrue(pf.getDurationInMillis() == -1);
+        Assert.assertFalse(pf.isStarted());
+    }
+
+    @Test
+    public void testProfilerNoStop() {
+        final Profiler pf = new Profiler();
+        pf.start();
+        try {
+            Thread.sleep(20);
+        } catch (final InterruptedException e) {
+        }
+
+        Assert.assertTrue(pf.getDurationInMillis() == -1);
+        Assert.assertFalse(pf.isStopped());
+    }
+
+    @Test
+    public void testResolution() {
+        long nanoTime1 = 0l;
+        long nanoTime2 = 0l;
+        nanoTime1 = System.nanoTime();
+        nanoTime2 = System.nanoTime();
+
+        // Using sysout here because is faster than the logger and we don't want to
+        // waste time.
+        System.out.println("Nano time 1: " + nanoTime1);
+        System.out.println("Nano time 2: " + nanoTime2);
+
+        // We are measuring the elapsed time in 2 consecutive calls of System.nanoTime()
+        // That's the same as 0.002 milliseconds or 2000 nanoseconds.
+        Assert.assertTrue("Expected exactly 2 but it took more than 3 microseconds between 2 consecutive calls to System.nanoTime().", nanoTime2 - nanoTime1 <= 3000);
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/UriUtilsTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/UriUtilsTest.java b/utils/src/test/java/com/cloud/utils/UriUtilsTest.java
new file mode 100644
index 0000000..d2fd997
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/UriUtilsTest.java
@@ -0,0 +1,60 @@
+//
+// 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 com.cloud.utils;
+
+import junit.framework.Assert;
+
+import org.junit.Test;
+
+public class UriUtilsTest {
+    @Test
+    public void encodeURIComponent() {
+        Assert.assertEquals("http://localhost",
+                UriUtils.encodeURIComponent("http://localhost"));
+        Assert.assertEquals("http://localhost/",
+                UriUtils.encodeURIComponent("http://localhost/"));
+        Assert.assertEquals("http://localhost/foo/bar",
+                UriUtils.encodeURIComponent("http://localhost/foo/bar"));
+    }
+
+    @Test
+    public void getUpdateUri() {
+        // no password param, no request for encryption
+        Assert.assertEquals("http://localhost/foo/bar?param=true", UriUtils
+                .getUpdateUri("http://localhost/foo/bar?param=true", false));
+        // there is password param but still no request for encryption, should
+        // be unchanged
+        Assert.assertEquals("http://localhost/foo/bar?password=1234", UriUtils
+                .getUpdateUri("http://localhost/foo/bar?password=1234", false));
+        // if there is password param and encryption is requested then it may or
+        // may not be changed depending on how the EncrytionUtils is setup, but
+        // at least it needs to start with the same url
+        Assert.assertTrue(UriUtils.getUpdateUri(
+                "http://localhost/foo/bar?password=1234", true).startsWith(
+                "http://localhost/foo/bar"));
+
+        //just to see if it is still ok with multiple parameters
+        Assert.assertEquals("http://localhost/foo/bar?param1=true&param2=12345", UriUtils
+                .getUpdateUri("http://localhost/foo/bar?param1=true&param2=12345", false));
+
+        //XXX: Interesting cases not covered:
+        // * port is ignored and left out from the return value
+    }
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/UuidUtilsTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/UuidUtilsTest.java b/utils/src/test/java/com/cloud/utils/UuidUtilsTest.java
new file mode 100644
index 0000000..2ef6bbd
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/UuidUtilsTest.java
@@ -0,0 +1,42 @@
+//
+// 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 com.cloud.utils;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class UuidUtilsTest {
+
+    @Test
+    public void testValidateUUIDPass() throws Exception {
+        String serviceUuid = "f81a9aa3-1f7d-466f-b04b-f2b101486bae";
+
+        assertTrue(UuidUtils.validateUUID(serviceUuid));
+    }
+
+    @Test
+    public void testValidateUUIDFail() throws Exception {
+        String serviceUuid = "6fc6ce7-d503-4f95-9e68-c9cd281b13df";
+
+        assertFalse(UuidUtils.validateUUID(serviceUuid));
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/backoff/impl/ConstantTimeBackoffTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/backoff/impl/ConstantTimeBackoffTest.java b/utils/src/test/java/com/cloud/utils/backoff/impl/ConstantTimeBackoffTest.java
new file mode 100644
index 0000000..d397511
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/backoff/impl/ConstantTimeBackoffTest.java
@@ -0,0 +1,112 @@
+//
+// 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 com.cloud.utils.backoff.impl;
+
+import java.util.HashMap;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ConstantTimeBackoffTest {
+    final static private Log LOG = LogFactory.getLog(ConstantTimeBackoffTest.class);
+
+    @Test
+    public void waitBeforeRetryWithInterrupt() throws InterruptedException {
+        final ConstantTimeBackoff backoff = new ConstantTimeBackoff();
+        backoff.setTimeToWait(10);
+        Assert.assertTrue(backoff.getWaiters().isEmpty());
+        Thread waitThread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                backoff.waitBeforeRetry();
+            }
+        });
+        waitThread.start();
+        Thread.sleep(100);
+        Assert.assertFalse(backoff.getWaiters().isEmpty());
+        waitThread.interrupt();
+        Thread.sleep(100);
+        Assert.assertTrue(backoff.getWaiters().isEmpty());
+    }
+
+    @Test
+    public void waitBeforeRetry() throws InterruptedException {
+        final ConstantTimeBackoff backoff = new ConstantTimeBackoff();
+        // let's not wait too much in a test
+        backoff.setTimeToWait(0);
+        // check if the list of waiters is empty
+        Assert.assertTrue(backoff.getWaiters().isEmpty());
+        // call the waitBeforeRetry which will wait 0 ms and return
+        backoff.waitBeforeRetry();
+        // on normal exit the list of waiters should be cleared
+        Assert.assertTrue(backoff.getWaiters().isEmpty());
+    }
+
+    @Test
+    public void configureEmpty() {
+        // at this point this is the only way rhe configure method gets invoked,
+        // therefore have to make sure it works correctly
+        final ConstantTimeBackoff backoff = new ConstantTimeBackoff();
+        backoff.configure("foo", new HashMap<String, Object>());
+        Assert.assertEquals(5000, backoff.getTimeToWait());
+    }
+
+    @Test
+    public void configureWithValue() {
+        final ConstantTimeBackoff backoff = new ConstantTimeBackoff();
+        HashMap<String, Object> params = new HashMap<String, Object>();
+        params.put("seconds", "100");
+        backoff.configure("foo", params);
+        Assert.assertEquals(100000, backoff.getTimeToWait());
+    }
+
+    /**
+     * Test that wakeup returns false when trying to wake a non existing thread.
+     */
+    @Test
+    public void wakeupNotExisting() {
+        final ConstantTimeBackoff backoff = new ConstantTimeBackoff();
+        Assert.assertFalse(backoff.wakeup("NOT EXISTING THREAD"));
+    }
+
+    /**
+     * Test that wakeup will return true if the thread is waiting.
+     */
+    @Test
+    public void wakeupExisting() throws InterruptedException {
+        final ConstantTimeBackoff backoff = new ConstantTimeBackoff();
+        backoff.setTimeToWait(10);
+        Thread thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                LOG.debug("before");
+                backoff.waitBeforeRetry();
+                LOG.debug("after");
+            }
+        });
+        thread.start();
+        LOG.debug("thread started");
+        Thread.sleep(100);
+        LOG.debug("testing wakeup");
+        Assert.assertTrue(backoff.wakeup(thread.getName()));
+    }
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/crypto/EncryptionSecretKeyCheckerTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/crypto/EncryptionSecretKeyCheckerTest.java b/utils/src/test/java/com/cloud/utils/crypto/EncryptionSecretKeyCheckerTest.java
new file mode 100644
index 0000000..0f3f058
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/crypto/EncryptionSecretKeyCheckerTest.java
@@ -0,0 +1,45 @@
+//
+// 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 com.cloud.utils.crypto;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.util.Properties;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.cloud.utils.crypt.EncryptionSecretKeyChecker;
+import com.cloud.utils.db.DbProperties;
+import com.cloud.utils.exception.CloudRuntimeException;
+
+public class EncryptionSecretKeyCheckerTest {
+
+  private EncryptionSecretKeyChecker checker = new EncryptionSecretKeyChecker();
+
+  @Test(expected = CloudRuntimeException.class)
+  public void testKeyFileDoesNotExists() throws IOException, URISyntaxException {
+    Assert.assertNotNull(checker);
+    Properties properties = DbProperties.getDbProperties();
+    properties.setProperty("db.cloud.encryption.type", "file");
+    checker.check(properties);
+  }
+
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/crypto/RSAHelperTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/crypto/RSAHelperTest.java b/utils/src/test/java/com/cloud/utils/crypto/RSAHelperTest.java
new file mode 100644
index 0000000..27d9d50
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/crypto/RSAHelperTest.java
@@ -0,0 +1,54 @@
+//
+// 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 com.cloud.utils.crypto;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Test;
+
+import com.cloud.utils.crypt.RSAHelper;
+
+public class RSAHelperTest {
+    @Test
+    public void testEncryptWithRSA() {
+        String rsaKey =
+            "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC2D2Cs0XAEqm+ajJpumIPrMpKp0CWtIW+8ZY2/MJCW"
+                + "hge1eY18u9I3PPnkMVJsTOaN0wQojjw4AkKgKjNZXA9wyUq56UyN/stmipu8zifWPgxQGDRkuzzZ6buk"
+                + "ef8q2Awjpo8hv5/0SRPJxQLEafESnUP+Uu/LUwk5VVC7PHzywJRUGFuzDl/uT72+6hqpL2YpC6aTl4/P"
+                + "2eDvUQhCdL9dBmUSFX8ftT53W1jhsaQl7mPElVgSCtWz3IyRkogobMPrpJW/IPKEiojKIuvNoNv4CDR6" + "ybeVjHOJMb9wi62rXo+CzUsW0Y4jPOX/OykAm5vrNOhQhw0aaBcv5XVv8BRX";
+        String encryptedString = RSAHelper.encryptWithSSHPublicKey(rsaKey, "content");
+        assertNotNull(encryptedString);
+    }
+
+    @Test
+    public void testEncryptWithDSA() {
+        String dssKey =
+            "ssh-dss AAAAB3NzaC1kc3MAAACBALbaewDnzZ5AcGbZno7VW1m7Si3Q+yEANXZioVupfSwOP0q9aP2iV"
+                + "tyqq575JnUVZXMDR2Gr254F/qCJ0TKAvucN0gcd2XslX4jBcu1Z7s7YZf6d7fC58k0NE6/keokJNKhQO"
+                + "i56iirRzSA/YFrD64mzfq6rEmai0q7GjGGP0RT1AAAAFQDO5++6JonyqnoRkV9Yl1OaEOPjVwAAAIAYA"
+                + "tqtKtU/INlTIuL3wt3nyKzwPUnz3fqxP5Ger3OlRZsOahalTFt2OF5jGGmCunyBTRteOetZObr0QhUIF"
+                + "4bSDr6UiYYYbH1ES0ws/t1mDIeTh3UUHV1QYACN6c07FKyKLMtB9AthiG2FMLKCEedG3NeXItuNzsuQD"
+                + "+n/K1rzMAAAAIBi5SM4pFPiB7BvTZvARV56vrG5QNgWVazSwbwgl/EACiWYbRauHDUQA9f+Rq+ayWcsR"
+                + "os1CD+Q81y9SmlQaZVKkSPZLxXfu5bi3s4o431xjilhZdt4vKbj2pK364IjghJPNBBfmRXzlj9awKxr/" + "UebZcBgNRyeky7VZSbbF2jQSQ==";
+        String encryptedString = RSAHelper.encryptWithSSHPublicKey(dssKey, "content");
+        assertNull(encryptedString);
+    }
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/encoding/UrlEncoderTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/encoding/UrlEncoderTest.java b/utils/src/test/java/com/cloud/utils/encoding/UrlEncoderTest.java
new file mode 100644
index 0000000..3d4dfc9
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/encoding/UrlEncoderTest.java
@@ -0,0 +1,33 @@
+//
+// 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 com.cloud.utils.encoding;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UrlEncoderTest {
+    @Test
+    public void encode() {
+        Assert.assertEquals("%2Ftmp%2F", new URLEncoder().encode("/tmp/"));
+        Assert.assertEquals("%20", new URLEncoder().encode(" "));
+        Assert.assertEquals("%5F", new URLEncoder().encode("_"));
+        Assert.assertEquals("%25", new URLEncoder().encode("%"));
+    }
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/exception/ExceptionUtilTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/exception/ExceptionUtilTest.java b/utils/src/test/java/com/cloud/utils/exception/ExceptionUtilTest.java
new file mode 100644
index 0000000..9e1948e
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/exception/ExceptionUtilTest.java
@@ -0,0 +1,52 @@
+//
+// 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 com.cloud.utils.exception;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import org.junit.Test;
+
+public class ExceptionUtilTest {
+
+    @Test
+    public void test() throws Exception {
+        FileNotFoundException fnfe = new FileNotFoundException();
+        try {
+            ExceptionUtil.rethrow(fnfe, IOException.class);
+            fail();
+        } catch (IOException e) {
+            assertTrue("we won !?!", true);
+        }
+
+        ExceptionUtil.rethrow(fnfe, ClassNotFoundException.class);
+
+        try {
+            ExceptionUtil.rethrow(fnfe, FileNotFoundException.class);
+            fail();
+        } catch (FileNotFoundException e) {
+            assertTrue("we won !?!", true);
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/net/Ip4AddressTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/net/Ip4AddressTest.java b/utils/src/test/java/com/cloud/utils/net/Ip4AddressTest.java
new file mode 100644
index 0000000..79ff238
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/net/Ip4AddressTest.java
@@ -0,0 +1,40 @@
+// 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 com.cloud.utils.net;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+public class Ip4AddressTest {
+
+    @Test
+    public void testEquals() throws Exception {
+        new EqualsTester()
+                .addEqualityGroup(new Ip4Address("0.0.0.1", "00:00:00:00:00:02"), new Ip4Address(1L, 2L))
+                .addEqualityGroup(new Ip4Address("0.0.0.1", "00:00:00:00:00:00"), new Ip4Address(1L, 0L), new Ip4Address(1L, 0L), new Ip4Address(1L), new Ip4Address("0.0.0.1"))
+                .testEquals();
+    }
+
+    @Test
+    public void testIsSameAddressAs() {
+        Assert.assertTrue("1 and one should be considdered the same address", new Ip4Address(1L, 5L).isSameAddressAs("0.0.0.1"));
+        Assert.assertFalse("zero and 0L should be considdered the same address but a Long won't be accepted", new Ip4Address("0.0.0.0", "00:00:00:00:00:08").isSameAddressAs(0L));
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/net/IpTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/net/IpTest.java b/utils/src/test/java/com/cloud/utils/net/IpTest.java
new file mode 100644
index 0000000..89608f1
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/net/IpTest.java
@@ -0,0 +1,63 @@
+//
+// 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 com.cloud.utils.net;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+public class IpTest {
+
+    @Test
+    public void testUltimate() {
+        Ip max = new Ip(2L * Integer.MAX_VALUE +1 );
+        assertEquals("Maximal address not created", "255.255.255.255", max.addr());
+    }
+    @Test
+    public void testTurningOfTheCentury() {
+        Ip eve = new Ip(Integer.MAX_VALUE);
+        assertEquals("Minimal address not created", "127.255.255.255", eve.addr());
+        Ip dawn = new Ip(Integer.MAX_VALUE + 1L);
+        assertEquals("Minimal address not created", "128.0.0.0", dawn.addr());
+    }
+    @Test
+    public void testStart() {
+        Ip min = new Ip(0);
+        assertEquals("Minimal address not created", "0.0.0.0", min.addr());
+    }
+
+    @Test
+    public void testEquals() {
+        new EqualsTester()
+                .addEqualityGroup(new Ip("0.0.0.1"), new Ip(1L))
+                .addEqualityGroup(new Ip("0.0.0.0"), new Ip(0L))
+                .testEquals();
+    }
+
+    @Test
+    public void testIsSameAddressAs() {
+        Assert.assertTrue("1 and one should be considdered the same address", new Ip(1L).isSameAddressAs("0.0.0.1"));
+        Assert.assertTrue("zero and 0L should be considdered the same address", new Ip("0.0.0.0").isSameAddressAs(0L));
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/net/MacAddressTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/net/MacAddressTest.java b/utils/src/test/java/com/cloud/utils/net/MacAddressTest.java
new file mode 100644
index 0000000..845a435
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/net/MacAddressTest.java
@@ -0,0 +1,60 @@
+//
+// 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 com.cloud.utils.net;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class MacAddressTest {
+
+    @Test
+    public final void testMacAddress() throws Exception {
+        MacAddress mac = new MacAddress();
+        assertEquals(0L,mac.toLong());
+    }
+
+    @Test
+    public final void testMacAddressLong() throws Exception {
+        MacAddress mac = new MacAddress(1L);
+        assertEquals(1L,mac.toLong());
+    }
+
+    @Test
+    public final void testMacAddressToLong() throws Exception {
+        // TODO this test should fail this address is beyond the acceptable range for macaddresses
+        MacAddress mac = new MacAddress(Long.MAX_VALUE);
+        assertEquals(Long.MAX_VALUE,mac.toLong());
+        System.out.println(mac.toString());
+    }
+
+    // TODO    public final void testToLong() throws Exception {
+    // TODO    public final void testToByteArray() throws Exception {
+    // TODO    public final void testToStringString() throws Exception {
+    // TODO    public final void testToString() throws Exception {
+    // TODO    public final void testGetMacAddress() throws Exception {
+    // TODO    public final void testParse() throws Exception {
+    // TODO    public final void testMain() throws Exception {
+    // TODO    public final void testParseLong() throws Exception {
+    // TODO    public final void testParseInt() throws Exception {
+    // TODO    public final void testParseShort() throws Exception {
+    // TODO    public final void testParseByte() throws Exception {
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java b/utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java
new file mode 100644
index 0000000..1ab4459
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java
@@ -0,0 +1,421 @@
+//
+// 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 com.cloud.utils.net;
+
+import static org.hamcrest.Matchers.anyOf;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigInteger;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import org.apache.log4j.Logger;
+import org.junit.Test;
+
+import com.googlecode.ipv6.IPv6Address;
+
+public class NetUtilsTest {
+
+    private static final Logger s_logger = Logger.getLogger(NetUtilsTest.class);
+
+    @Test
+    public void testGetRandomIpFromCidrWithSize24() throws Exception {
+        final String cidr = "192.168.124.1";
+        final int size = 24;
+        final int netCharacters = 12;
+
+        final long ip = NetUtils.getRandomIpFromCidr(cidr, size, new TreeSet<Long>());
+
+        assertThat("The ip " + NetUtils.long2Ip(ip) + " retrieved must be within the cidr " + cidr + "/" + size, cidr.substring(0, netCharacters), equalTo(NetUtils.long2Ip(ip)
+                .substring(0, netCharacters)));
+    }
+
+    @Test
+    public void testGetRandomIpFromCidrWithSize16() throws Exception {
+        final String cidr = "192.168.124.1";
+        final int size = 16;
+        final int netCharacters = 8;
+
+        final long ip = NetUtils.getRandomIpFromCidr(cidr, 16, new TreeSet<Long>());
+
+        assertThat("The ip " + NetUtils.long2Ip(ip) + " retrieved must be within the cidr " + cidr + "/" + size, cidr.substring(0, netCharacters), equalTo(NetUtils.long2Ip(ip)
+                .substring(0, netCharacters)));
+    }
+
+    @Test
+    public void testGetRandomIpFromCidrWithSize8() throws Exception {
+        final String cidr = "192.168.124.1";
+        final int size = 8;
+        final int netCharacters = 4;
+
+        final long ip = NetUtils.getRandomIpFromCidr(cidr, 16, new TreeSet<Long>());
+
+        assertThat("The ip " + NetUtils.long2Ip(ip) + " retrieved must be within the cidr " + cidr + "/" + size, cidr.substring(0, netCharacters), equalTo(NetUtils.long2Ip(ip)
+                .substring(0, netCharacters)));
+    }
+
+    @Test
+    public void testGetRandomIpFromCidrUsignAvoid() throws Exception {
+        final String cidr = "192.168.124.1";
+        final int size = 30;
+
+        final SortedSet<Long> avoid = new TreeSet<Long>();
+        long ip = NetUtils.getRandomIpFromCidr(cidr, size, avoid);
+        assertThat("We should be able to retrieve an ip on the first call.", ip, not(equalTo(-1L)));
+        avoid.add(ip);
+        ip = NetUtils.getRandomIpFromCidr(cidr, size, avoid);
+        assertThat("We should be able to retrieve an ip on the second call.", ip, not(equalTo(-1L)));
+        assertThat("ip returned is not in the avoid list", avoid, not(contains(ip)));
+        avoid.add(ip);
+        ip = NetUtils.getRandomIpFromCidr(cidr, size, avoid);
+        assertThat("We should be able to retrieve an ip on the third call.", ip, not(equalTo(-1L)));
+        assertThat("ip returned is not in the avoid list", avoid, not(contains(ip)));
+        avoid.add(ip);
+        ip = NetUtils.getRandomIpFromCidr(cidr, size, avoid);
+        assertEquals("This should be -1 because we ran out of ip addresses: " + ip, ip, -1);
+    }
+
+    @Test
+    public void testIsValidS2SVpnPolicy() {
+        assertTrue(NetUtils.isValidS2SVpnPolicy("aes128-sha1"));
+        assertTrue(NetUtils.isValidS2SVpnPolicy("3des-sha1"));
+        assertTrue(NetUtils.isValidS2SVpnPolicy("3des-sha1,aes256-sha1"));
+        assertTrue(NetUtils.isValidS2SVpnPolicy("3des-md5;modp1024"));
+        assertTrue(NetUtils.isValidS2SVpnPolicy("3des-sha1,aes128-sha1;modp1536"));
+        assertFalse(NetUtils.isValidS2SVpnPolicy("des-md5;modp1024,aes128-sha1;modp1536"));
+        assertFalse(NetUtils.isValidS2SVpnPolicy("des-sha1"));
+        assertFalse(NetUtils.isValidS2SVpnPolicy("abc-123,ase-sha1"));
+        assertFalse(NetUtils.isValidS2SVpnPolicy("de-sh,aes-sha1"));
+        assertFalse(NetUtils.isValidS2SVpnPolicy(""));
+        assertFalse(NetUtils.isValidS2SVpnPolicy(";modp1536"));
+        assertFalse(NetUtils.isValidS2SVpnPolicy(",aes;modp1536,,,"));
+    }
+
+    @Test
+    public void testGetIp6FromRange() {
+        assertEquals(NetUtils.getIp6FromRange("1234:5678::1-1234:5678::1"), "1234:5678::1");
+        for (int i = 0; i < 5; i++) {
+            final String ip = NetUtils.getIp6FromRange("1234:5678::1-1234:5678::2");
+            assertThat(ip, anyOf(equalTo("1234:5678::1"), equalTo("1234:5678::2")));
+            s_logger.info("IP is " + ip);
+        }
+        String ipString = null;
+        final IPv6Address ipStart = IPv6Address.fromString("1234:5678::1");
+        final IPv6Address ipEnd = IPv6Address.fromString("1234:5678::ffff:ffff:ffff:ffff");
+        for (int i = 0; i < 10; i++) {
+            ipString = NetUtils.getIp6FromRange(ipStart.toString() + "-" + ipEnd.toString());
+            s_logger.info("IP is " + ipString);
+            final IPv6Address ip = IPv6Address.fromString(ipString);
+            assertThat(ip, greaterThanOrEqualTo(ipStart));
+            assertThat(ip, lessThanOrEqualTo(ipEnd));
+        }
+    }
+
+    @Test
+    public void testCountIp6InRange() {
+        assertEquals(new BigInteger("2"), NetUtils.countIp6InRange("1234:5678::1-1234:5678::2"));
+    }
+
+    @Test
+    public void testCountIp6InRangeWithInvalidRange() {
+        assertEquals(null, NetUtils.countIp6InRange("1234:5678::2-1234:5678::0"));
+    }
+
+    @Test
+    public void testCountIp6InRangeWithNullStart() {
+        assertEquals(null, NetUtils.countIp6InRange("-1234:5678::0"));
+    }
+
+    @Test
+    public void testCountIp6InRangeWithNoEnd() {
+        assertEquals(new BigInteger("1"), NetUtils.countIp6InRange("1234:5678::2"));
+    }
+
+    @Test
+    public void testGetIp6CidrSize() {
+        assertEquals(NetUtils.getIp6CidrSize("1234:5678::1/32"), 32);
+        assertEquals(NetUtils.getIp6CidrSize("1234:5678::1"), 0);
+    }
+
+    @Test
+    public void testIsValidIp6Cidr() {
+        assertTrue(NetUtils.isValidIp6Cidr("1234:5678::1/64"));
+        assertFalse(NetUtils.isValidIp6Cidr("1234:5678::1"));
+    }
+
+    @Test
+    public void testIsValidIpv6() {
+        assertTrue(NetUtils.isValidIpv6("fc00::1"));
+        assertFalse(NetUtils.isValidIpv6(""));
+        assertFalse(NetUtils.isValidIpv6(null));
+        assertFalse(NetUtils.isValidIpv6("1234:5678::1/64"));
+    }
+
+    @Test
+    public void testIsIp6InRange() {
+        assertTrue(NetUtils.isIp6InRange("1234:5678:abcd::1", "1234:5678:abcd::1-1234:5678:abcd::1"));
+        assertFalse(NetUtils.isIp6InRange("1234:5678:abcd::1", "1234:5678:abcd::2-1234:5678:abcd::1"));
+        assertFalse(NetUtils.isIp6InRange("1234:5678:abcd::1", null));
+        assertTrue(NetUtils.isIp6InRange("1234:5678:abcd::1", "1234:5678::1-1234:5679::1"));
+    }
+
+    @Test
+    public void testIsIp6InNetwork() {
+        assertFalse(NetUtils.isIp6InNetwork("1234:5678:abcd::1", "1234:5678::/64"));
+        assertTrue(NetUtils.isIp6InNetwork("1234:5678::1", "1234:5678::/64"));
+        assertTrue(NetUtils.isIp6InNetwork("1234:5678::ffff:ffff:ffff:ffff", "1234:5678::/64"));
+        assertTrue(NetUtils.isIp6InNetwork("1234:5678::", "1234:5678::/64"));
+    }
+
+    @Test
+    public void testGetNextIp6InRange() {
+        String range = "1234:5678::1-1234:5678::8000:0000";
+        assertEquals(NetUtils.getNextIp6InRange("1234:5678::8000:0", range), "1234:5678::1");
+        assertEquals(NetUtils.getNextIp6InRange("1234:5678::7fff:ffff", range), "1234:5678::8000:0");
+        assertEquals(NetUtils.getNextIp6InRange("1234:5678::1", range), "1234:5678::2");
+        range = "1234:5678::1-1234:5678::ffff:ffff:ffff:ffff";
+        assertEquals(NetUtils.getNextIp6InRange("1234:5678::ffff:ffff:ffff:ffff", range), "1234:5678::1");
+    }
+
+    @Test
+    public void testIsIp6RangeOverlap() {
+        assertFalse(NetUtils.isIp6RangeOverlap("1234:5678::1-1234:5678::ffff", "1234:5678:1::1-1234:5678:1::ffff"));
+        assertTrue(NetUtils.isIp6RangeOverlap("1234:5678::1-1234:5678::ffff", "1234:5678::2-1234:5678::f"));
+        assertTrue(NetUtils.isIp6RangeOverlap("1234:5678::f-1234:5678::ffff", "1234:5678::2-1234:5678::f"));
+        assertFalse(NetUtils.isIp6RangeOverlap("1234:5678::f-1234:5678::ffff", "1234:5678::2-1234:5678::e"));
+        assertFalse(NetUtils.isIp6RangeOverlap("1234:5678::f-1234:5678::f", "1234:5678::2-1234:5678::e"));
+    }
+
+    @Test
+    public void testStandardizeIp6Address() {
+        assertEquals(NetUtils.standardizeIp6Address("1234:0000:0000:5678:0000:0000:ABCD:0001"), "1234::5678:0:0:abcd:1");
+        assertEquals(NetUtils.standardizeIp6Cidr("1234:0000:0000:5678:0000:0000:ABCD:0001/64"), "1234:0:0:5678::/64");
+    }
+
+    @Test
+    public void testGenerateUriForPvlan() {
+        assertEquals("pvlan://123-i456", NetUtils.generateUriForPvlan("123", "456").toString());
+    }
+
+    @Test
+    public void testGetPrimaryPvlanFromUri() {
+        assertEquals("123", NetUtils.getPrimaryPvlanFromUri(NetUtils.generateUriForPvlan("123", "456")));
+    }
+
+    @Test
+    public void testGetIsolatedPvlanFromUri() {
+        assertEquals("456", NetUtils.getIsolatedPvlanFromUri(NetUtils.generateUriForPvlan("123", "456")));
+    }
+
+    @Test
+    public void testIsValidCIDR() throws Exception {
+        //Test to check IP Range of 2 CIDR
+        final String cidrFirst = "10.0.144.0/20";
+        final String cidrSecond = "10.0.151.0/20";
+        final String cidrThird = "10.0.144.0/21";
+
+        assertTrue(NetUtils.isValidCIDR(cidrFirst));
+        assertTrue(NetUtils.isValidCIDR(cidrSecond));
+        assertTrue(NetUtils.isValidCIDR(cidrThird));
+    }
+
+    @Test
+    public void testIsValidCidrList() throws Exception {
+        final String cidrFirst = "10.0.144.0/20,1.2.3.4/32,5.6.7.8/24";
+        final String cidrSecond = "10.0.151.0/20,129.0.0.0/4";
+        final String cidrThird = "10.0.144.0/21";
+
+        assertTrue(NetUtils.isValidCidrList(cidrFirst));
+        assertTrue(NetUtils.isValidCidrList(cidrSecond));
+        assertTrue(NetUtils.isValidCidrList(cidrThird));
+    }
+
+    @Test
+    public void testIsSameIpRange() {
+        final String cidrFirst = "10.0.144.0/20";
+        final String cidrSecond = "10.0.151.0/20";
+        final String cidrThird = "10.0.144.0/21";
+
+        //Check for exactly same CIDRs
+        assertTrue(NetUtils.isSameIpRange(cidrFirst, cidrFirst));
+        //Check for 2 different CIDRs, but same IP Range
+        assertTrue(NetUtils.isSameIpRange(cidrFirst, cidrSecond));
+        //Check for 2 different CIDRs and different IP Range
+        assertFalse(NetUtils.isSameIpRange(cidrFirst, cidrThird));
+        //Check for Incorrect format of CIDR
+        assertFalse(NetUtils.isSameIpRange(cidrFirst, "10.3.6.5/50"));
+    }
+
+    @Test
+    public void testGenerateMacOnIncrease() {
+        String mac = "06:01:23:00:45:67";
+        assertEquals("06:01:25:00:45:67", NetUtils.generateMacOnIncrease(mac, 2));
+        assertEquals("06:01:33:00:45:67", NetUtils.generateMacOnIncrease(mac, 16));
+        mac = "06:ff:ff:00:45:67";
+        assertEquals("06:00:00:00:45:67", NetUtils.generateMacOnIncrease(mac, 1));
+        assertEquals("06:00:0f:00:45:67", NetUtils.generateMacOnIncrease(mac, 16));
+    }
+
+    @Test
+    public void testGetLocalIPString() {
+        assertNotNull(NetUtils.getLocalIPString());
+    }
+
+    @Test
+    public void testSameIsolationId() {
+        assertTrue(NetUtils.isSameIsolationId("1", "vlan://1"));
+        assertTrue(NetUtils.isSameIsolationId("", null));
+        assertTrue(NetUtils.isSameIsolationId("UnTagged", "vlan://uNtAGGED"));
+        assertFalse(NetUtils.isSameIsolationId("2", "vlan://uNtAGGED"));
+        assertFalse(NetUtils.isSameIsolationId("2", "vlan://3"));
+        assertFalse(NetUtils.isSameIsolationId("bla", null));
+    }
+
+    @Test
+    public void testValidateGuestCidr() throws Exception {
+        final String guestCidr = "192.168.1.0/24";
+
+        assertTrue(NetUtils.validateGuestCidr(guestCidr));
+    }
+
+    @Test
+    public void testMac2Long() {
+        assertEquals(0l, NetUtils.mac2Long("00:00:00:00:00:00"));
+        assertEquals(1l, NetUtils.mac2Long("00:00:00:00:00:01"));
+        assertEquals(0xFFl, NetUtils.mac2Long("00:00:00:00:00:FF"));
+        assertEquals(0xFFAAl, NetUtils.mac2Long("00:00:00:00:FF:AA"));
+        assertEquals(0x11FFAAl, NetUtils.mac2Long("00:00:00:11:FF:AA"));
+        assertEquals(0x12345678l, NetUtils.mac2Long("00:00:12:34:56:78"));
+        assertEquals(0x123456789Al, NetUtils.mac2Long("00:12:34:56:78:9A"));
+        assertEquals(0x123456789ABCl, NetUtils.mac2Long("12:34:56:78:9A:BC"));
+    }
+
+    @Test
+    public void testLong2Mac() {
+        assertEquals("00:00:00:00:00:00", NetUtils.long2Mac(0l));
+        assertEquals("00:00:00:00:00:01", NetUtils.long2Mac(1l));
+        assertEquals("00:00:00:00:00:ff", NetUtils.long2Mac(0xFFl));
+        assertEquals("00:00:00:00:ff:aa", NetUtils.long2Mac(0xFFAAl));
+        assertEquals("00:00:00:11:ff:aa", NetUtils.long2Mac(0x11FFAAl));
+        assertEquals("00:00:12:34:56:78", NetUtils.long2Mac(0x12345678l));
+        assertEquals("00:12:34:56:78:9a", NetUtils.long2Mac(0x123456789Al));
+        assertEquals("12:34:56:78:9a:bc", NetUtils.long2Mac(0x123456789ABCl));
+    }
+
+    @Test
+    public void testIp2Long() {
+        assertEquals(0x7f000001l, NetUtils.ip2Long("127.0.0.1"));
+        assertEquals(0xc0a80001l, NetUtils.ip2Long("192.168.0.1"));
+        assertEquals(0x08080808l, NetUtils.ip2Long("8.8.8.8"));
+    }
+
+    @Test
+    public void testLong2Ip() {
+        assertEquals("127.0.0.1", NetUtils.long2Ip(0x7f000001l));
+        assertEquals("192.168.0.1", NetUtils.long2Ip(0xc0a80001l));
+        assertEquals("8.8.8.8", NetUtils.long2Ip(0x08080808l));
+    }
+
+    @Test
+    public void test31BitPrefixStart() {
+        final String ipAddress = "192.168.0.0";
+        final String cidr = "192.168.0.0/31";
+
+        final boolean isInRange = NetUtils.isIpWithtInCidrRange(ipAddress, cidr);
+
+        assertTrue("Check if the subnetUtils.setInclusiveHostCount(true) has been called.", isInRange);
+    }
+
+    @Test
+    public void test31BitPrefixEnd() {
+        final String ipAddress = "192.168.0.1";
+        final String cidr = "192.168.0.0/31";
+
+        final boolean isInRange = NetUtils.isIpWithtInCidrRange(ipAddress, cidr);
+
+        assertTrue("Check if the subnetUtils.setInclusiveHostCount(true) has been called.", isInRange);
+    }
+
+    @Test
+    public void test31BitPrefixFail() {
+        final String ipAddress = "192.168.0.2";
+        final String cidr = "192.168.0.0/31";
+
+        final boolean isInRange = NetUtils.isIpWithtInCidrRange(ipAddress, cidr);
+
+        assertFalse("Out of the range. Why did it return true?", isInRange);
+    }
+
+    @Test
+    public void test31BitPrefixIpRangesOverlapd() {
+        final String gw = "192.168.0.0";
+        String ip1;
+        String ip2;
+
+        for (int i = 1, j = 2; i <= 254; i++, j++) {
+            ip1 = "192.168.0." + i;
+            ip2 = "192.168.0." + j;
+
+            final boolean doesOverlap = NetUtils.ipRangesOverlap(ip1, ip2, gw, gw);
+            assertFalse("It should overlap, but it's a 31-bit ip", doesOverlap);
+        }
+    }
+
+    @Test
+    public void test31BitPrefixIpRangesOverlapdFail() {
+        String gw;
+        String ip1;
+        String ip2;
+
+        for (int i = 10, j = 12; i <= 254; i++, j++) {
+            gw = "192.168.0." + i;
+            ip1 = "192.168.0." + i;
+            ip2 = "192.168.0." + j;
+
+            final boolean doesOverlap = NetUtils.ipRangesOverlap(ip1, ip2, gw, gw);
+            assertTrue("It overlaps!", doesOverlap);
+        }
+    }
+
+    @Test
+    public void testIs31PrefixCidrFail() {
+        final String cidr = "10.10.0.0/32";
+        final boolean is31PrefixCidr = NetUtils.is31PrefixCidr(cidr);
+
+        assertFalse("It should fail! 32 bit prefix.", is31PrefixCidr);
+    }
+
+    @Test
+    public void testIs31PrefixCidr() {
+        final String cidr = "10.10.0.0/31";
+        final boolean is31PrefixCidr = NetUtils.is31PrefixCidr(cidr);
+
+        assertTrue("It should pass! 31 bit prefix.", is31PrefixCidr);
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/rest/RESTServiceConnectorTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/rest/RESTServiceConnectorTest.java b/utils/src/test/java/com/cloud/utils/rest/RESTServiceConnectorTest.java
new file mode 100644
index 0000000..6d58b5b
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/rest/RESTServiceConnectorTest.java
@@ -0,0 +1,395 @@
+//
+// 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 com.cloud.utils.rest;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.util.Collections;
+
+import org.apache.commons.httpclient.Header;
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.HttpException;
+import org.apache.commons.httpclient.HttpMethod;
+import org.apache.commons.httpclient.methods.DeleteMethod;
+import org.apache.commons.httpclient.methods.GetMethod;
+import org.apache.commons.httpclient.methods.PostMethod;
+import org.apache.commons.httpclient.methods.PutMethod;
+import org.apache.commons.httpclient.params.HttpClientParams;
+import org.apache.http.HttpStatus;
+import org.junit.Before;
+import org.junit.Test;
+
+public class RESTServiceConnectorTest {
+    protected static final String UUID = "aaaa";
+    protected static final String UUID_JSON_RESPONSE = "{\"uuid\" : \"aaaa\"}";
+
+    RESTServiceConnector connector;
+    HttpClient client = mock(HttpClient.class);
+    HttpMethod method;
+    String type;
+    String uri;
+
+    @Before
+    public void setUp() {
+        final HttpClientParams hmp = mock(HttpClientParams.class);
+        when(client.getParams()).thenReturn(hmp);
+        connector = new RESTServiceConnector(null) {
+            @Override
+            public HttpClient createHttpClient() {
+                return client;
+            }
+
+            @Override
+            public HttpMethod createMethod(final String newType, final String newUri) {
+                type = newType;
+                uri = newUri;
+                return method;
+            }
+        };
+
+        connector.validation = new RESTValidationStrategy();
+        connector.setAdminCredentials("admin", "adminpass");
+        connector.setControllerAddress("localhost");
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteLoginWithoutHostname() throws CloudstackRESTException {
+        connector.setControllerAddress(null);
+        connector.validation.login(RESTServiceConnector.protocol, client);
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteLoginWithoutCredentials() throws CloudstackRESTException {
+        method = mock(PutMethod.class);
+        connector.setAdminCredentials(null, null);
+        connector.validation.login(RESTServiceConnector.protocol, client);
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteUpdateObjectWithoutHostname() throws CloudstackRESTException {
+        method = mock(PutMethod.class);
+        connector.setControllerAddress(null);
+        connector.executeUpdateObject(new String(), "/", Collections.<String, String> emptyMap());
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteUpdateObjectWithoutCredentials() throws CloudstackRESTException {
+        method = mock(PutMethod.class);
+        connector.setAdminCredentials(null, null);
+        connector.executeUpdateObject(new String(), "/", Collections.<String, String> emptyMap());
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteCreateObjectWithoutHostname() throws CloudstackRESTException {
+        method = mock(PostMethod.class);
+        connector.setControllerAddress(null);
+        connector.executeCreateObject(new String(), String.class, "/", Collections.<String, String> emptyMap());
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteCreateObjectWithoutCredentials() throws CloudstackRESTException {
+        method = mock(PostMethod.class);
+        connector.setAdminCredentials(null, null);
+        connector.executeCreateObject(new String(), String.class, "/", Collections.<String, String> emptyMap());
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteDeleteObjectWithoutHostname() throws CloudstackRESTException {
+        method = mock(DeleteMethod.class);
+        connector.setControllerAddress(null);
+        connector.executeDeleteObject("/");
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteDeleteObjectWithoutCredentials() throws CloudstackRESTException {
+        method = mock(DeleteMethod.class);
+        connector.setAdminCredentials(null, null);
+        connector.executeDeleteObject("/");
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteRetrieveObjectWithoutHostname() throws CloudstackRESTException {
+        method = mock(GetMethod.class);
+        connector.setControllerAddress(null);
+        connector.executeRetrieveObject(String.class, "/", Collections.<String, String> emptyMap());
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteRetrieveObjectWithoutCredentials() throws CloudstackRESTException {
+        method = mock(GetMethod.class);
+        connector.setAdminCredentials(null, null);
+        connector.executeRetrieveObject(String.class, "/", Collections.<String, String> emptyMap());
+    }
+
+    @Test
+    public void testExecuteMethod() throws CloudstackRESTException {
+        final GetMethod gm = mock(GetMethod.class);
+
+        when(gm.getStatusCode()).thenReturn(HttpStatus.SC_OK);
+        connector.executeMethod(gm);
+        verify(gm, times(1)).getStatusCode();
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteMethodWithLogin() throws CloudstackRESTException, HttpException, IOException {
+        final GetMethod gm = mock(GetMethod.class);
+        when(client.executeMethod((HttpMethod)any())).thenThrow(new HttpException());
+        when(gm.getStatusCode()).thenReturn(HttpStatus.SC_UNAUTHORIZED).thenReturn(HttpStatus.SC_UNAUTHORIZED);
+        connector.executeMethod(gm);
+        verify(gm, times(1)).getStatusCode();
+    }
+
+    /* Bit of a roundabout way to ensure that login is called after an un authorized result
+     * It not possible to properly mock login()
+     */
+    public void testExecuteMethodWithLoginSucced2ndAttempt() throws CloudstackRESTException, HttpException, IOException {
+        // Prepare
+        final GetMethod gm = mock(GetMethod.class);
+        when(gm.getStatusCode()).thenReturn(HttpStatus.SC_UNAUTHORIZED).thenReturn(HttpStatus.SC_UNAUTHORIZED);
+
+        final RESTValidationStrategy previousValidationStrategy = connector.validation;
+        connector.validation = new RESTValidationStrategy(){
+            @Override
+            protected void login(final String protocol, final HttpClient client)
+                    throws CloudstackRESTException {
+                // Do nothing
+            }
+        };
+        connector.setAdminCredentials("admin", "adminpass");
+        connector.setControllerAddress("localhost");
+
+        // Execute
+        connector.executeMethod(gm);
+        // Leave mock object as is was
+        connector.validation = previousValidationStrategy;
+
+        // Assert/verify
+        verify(gm, times(2)).getStatusCode();
+    }
+
+    @Test
+    public void testExecuteCreateObject() throws CloudstackRESTException, IOException {
+        JsonEntity ls = new JsonEntity();
+        method = mock(PostMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_CREATED);
+        when(method.getResponseBodyAsString()).thenReturn(UUID_JSON_RESPONSE);
+        ls = connector.executeCreateObject(ls, JsonEntity.class, "/", Collections.<String, String> emptyMap());
+        assertTrue(UUID.equals(ls.getUuid()));
+        verify(method, times(1)).releaseConnection();
+
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteCreateObjectFailure() throws CloudstackRESTException, IOException {
+        JsonEntity ls = new JsonEntity();
+        method = mock(PostMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_INTERNAL_SERVER_ERROR);
+        final Header header = mock(Header.class);
+        when(header.getValue()).thenReturn("text/html");
+        when(method.getResponseHeader("Content-Type")).thenReturn(header);
+        when(method.getResponseBodyAsString()).thenReturn("Off to timbuktu, won't be back later.");
+        when(method.isRequestSent()).thenReturn(true);
+        try {
+            ls = connector.executeCreateObject(ls, JsonEntity.class, "/", Collections.<String, String> emptyMap());
+        } finally {
+            verify(method, times(1)).releaseConnection();
+        }
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteCreateObjectException() throws CloudstackRESTException, IOException {
+        JsonEntity ls = new JsonEntity();
+        when(client.executeMethod((HttpMethod)any())).thenThrow(new HttpException());
+        method = mock(PostMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_INTERNAL_SERVER_ERROR);
+        final Header header = mock(Header.class);
+        when(header.getValue()).thenReturn("text/html");
+        when(method.getResponseHeader("Content-Type")).thenReturn(header);
+        when(method.getResponseBodyAsString()).thenReturn("Off to timbuktu, won't be back later.");
+        try {
+            ls = connector.executeCreateObject(ls, JsonEntity.class, "/", Collections.<String, String> emptyMap());
+        } finally {
+            verify(method, times(1)).releaseConnection();
+        }
+    }
+
+    @Test
+    public void testExecuteUpdateObject() throws CloudstackRESTException, IOException {
+        final JsonEntity ls = new JsonEntity();
+        method = mock(PutMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_OK);
+        connector.executeUpdateObject(ls, "/", Collections.<String, String> emptyMap());
+        verify(method, times(1)).releaseConnection();
+        verify(client, times(1)).executeMethod(method);
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteUpdateObjectFailure() throws CloudstackRESTException, IOException {
+        final JsonEntity ls = new JsonEntity();
+        method = mock(PutMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_INTERNAL_SERVER_ERROR);
+        final Header header = mock(Header.class);
+        when(header.getValue()).thenReturn("text/html");
+        when(method.getResponseHeader("Content-Type")).thenReturn(header);
+        when(method.getResponseBodyAsString()).thenReturn("Off to timbuktu, won't be back later.");
+        when(method.isRequestSent()).thenReturn(true);
+        try {
+            connector.executeUpdateObject(ls, "/", Collections.<String, String> emptyMap());
+        } finally {
+            verify(method, times(1)).releaseConnection();
+        }
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteUpdateObjectException() throws CloudstackRESTException, IOException {
+        final JsonEntity ls = new JsonEntity();
+        method = mock(PutMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_OK);
+        when(client.executeMethod((HttpMethod)any())).thenThrow(new IOException());
+        try {
+            connector.executeUpdateObject(ls, "/", Collections.<String, String> emptyMap());
+        } finally {
+            verify(method, times(1)).releaseConnection();
+        }
+    }
+
+    @Test
+    public void testExecuteDeleteObject() throws CloudstackRESTException, IOException {
+        method = mock(DeleteMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_NO_CONTENT);
+        connector.executeDeleteObject("/");
+        verify(method, times(1)).releaseConnection();
+        verify(client, times(1)).executeMethod(method);
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteDeleteObjectFailure() throws CloudstackRESTException, IOException {
+        method = mock(DeleteMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_INTERNAL_SERVER_ERROR);
+        final Header header = mock(Header.class);
+        when(header.getValue()).thenReturn("text/html");
+        when(method.getResponseHeader("Content-Type")).thenReturn(header);
+        when(method.getResponseBodyAsString()).thenReturn("Off to timbuktu, won't be back later.");
+        when(method.isRequestSent()).thenReturn(true);
+        try {
+            connector.executeDeleteObject("/");
+        } finally {
+            verify(method, times(1)).releaseConnection();
+        }
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteDeleteObjectException() throws CloudstackRESTException, IOException {
+        method = mock(DeleteMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_NO_CONTENT);
+        when(client.executeMethod((HttpMethod)any())).thenThrow(new HttpException());
+        try {
+            connector.executeDeleteObject("/");
+        } finally {
+            verify(method, times(1)).releaseConnection();
+        }
+    }
+
+    @Test
+    public void testExecuteRetrieveObject() throws CloudstackRESTException, IOException {
+        method = mock(GetMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_OK);
+        when(method.getResponseBodyAsString()).thenReturn(UUID_JSON_RESPONSE);
+        connector.executeRetrieveObject(JsonEntity.class, "/", Collections.<String, String> emptyMap());
+        verify(method, times(1)).releaseConnection();
+        verify(client, times(1)).executeMethod(method);
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteRetrieveObjectFailure() throws CloudstackRESTException, IOException {
+        method = mock(GetMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_INTERNAL_SERVER_ERROR);
+        when(method.getResponseBodyAsString()).thenReturn(UUID_JSON_RESPONSE);
+        final Header header = mock(Header.class);
+        when(header.getValue()).thenReturn("text/html");
+        when(method.getResponseHeader("Content-Type")).thenReturn(header);
+        when(method.getResponseBodyAsString()).thenReturn("Off to timbuktu, won't be back later.");
+        when(method.isRequestSent()).thenReturn(true);
+        try {
+            connector.executeRetrieveObject(JsonEntity.class, "/", Collections.<String, String> emptyMap());
+        } finally {
+            verify(method, times(1)).releaseConnection();
+        }
+    }
+
+    @Test(expected = CloudstackRESTException.class)
+    public void testExecuteRetrieveObjectException() throws CloudstackRESTException, IOException {
+        method = mock(GetMethod.class);
+        when(method.getStatusCode()).thenReturn(HttpStatus.SC_OK);
+        when(method.getResponseBodyAsString()).thenReturn(UUID_JSON_RESPONSE);
+        when(client.executeMethod((HttpMethod)any())).thenThrow(new HttpException());
+        try {
+            connector.executeRetrieveObject(JsonEntity.class, "/", Collections.<String, String> emptyMap());
+        } finally {
+            verify(method, times(1)).releaseConnection();
+        }
+    }
+
+}
+
+class JsonEntity {
+    private String displayName;
+    private String uuid;
+    private String href;
+    private String schema;
+
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    public void setDisplayName(final String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getUuid() {
+        return uuid;
+    }
+
+    public void setUuid(final String uuid) {
+        this.uuid = uuid;
+    }
+
+    public String getHref() {
+        return href;
+    }
+
+    public void setHref(final String href) {
+        this.href = href;
+    }
+
+    public String getSchema() {
+        return schema;
+    }
+
+    public void setSchema(final String schema) {
+        this.schema = schema;
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/ssh/SSHKeysHelperTest.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/ssh/SSHKeysHelperTest.java b/utils/src/test/java/com/cloud/utils/ssh/SSHKeysHelperTest.java
new file mode 100644
index 0000000..a3daf91
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/ssh/SSHKeysHelperTest.java
@@ -0,0 +1,73 @@
+//
+// 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 com.cloud.utils.ssh;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class SSHKeysHelperTest {
+    @Test
+    public void rsaKeyTest() {
+        String rsaKey =
+            "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC2D2Cs0XAEqm+ajJpumIPrMpKp0CWtIW+8ZY2/MJCW"
+                + "hge1eY18u9I3PPnkMVJsTOaN0wQojjw4AkKgKjNZXA9wyUq56UyN/stmipu8zifWPgxQGDRkuzzZ6buk"
+                + "ef8q2Awjpo8hv5/0SRPJxQLEafESnUP+Uu/LUwk5VVC7PHzywJRUGFuzDl/uT72+6hqpL2YpC6aTl4/P"
+                + "2eDvUQhCdL9dBmUSFX8ftT53W1jhsaQl7mPElVgSCtWz3IyRkogobMPrpJW/IPKEiojKIuvNoNv4CDR6"
+                + "ybeVjHOJMb9wi62rXo+CzUsW0Y4jPOX/OykAm5vrNOhQhw0aaBcv5XVv8BRX test@testkey";
+        String storedRsaKey =
+            "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC2D2Cs0XAEqm+ajJpumIPrMpKp0CWtIW+8ZY2/MJCW"
+                + "hge1eY18u9I3PPnkMVJsTOaN0wQojjw4AkKgKjNZXA9wyUq56UyN/stmipu8zifWPgxQGDRkuzzZ6buk"
+                + "ef8q2Awjpo8hv5/0SRPJxQLEafESnUP+Uu/LUwk5VVC7PHzywJRUGFuzDl/uT72+6hqpL2YpC6aTl4/P"
+                + "2eDvUQhCdL9dBmUSFX8ftT53W1jhsaQl7mPElVgSCtWz3IyRkogobMPrpJW/IPKEiojKIuvNoNv4CDR6" + "ybeVjHOJMb9wi62rXo+CzUsW0Y4jPOX/OykAm5vrNOhQhw0aaBcv5XVv8BRX";
+        String parsedKey = SSHKeysHelper.getPublicKeyFromKeyMaterial(rsaKey);
+        String fingerprint = SSHKeysHelper.getPublicKeyFingerprint(parsedKey);
+
+        assertTrue(storedRsaKey.equals(parsedKey));
+        assertTrue("f6:96:3f:f4:78:f7:80:11:6c:f8:e3:2b:40:20:f1:14".equals(fingerprint));
+
+    }
+
+    @Test
+    public void dsaKeyTest() {
+        String dssKey =
+            "ssh-dss AAAAB3NzaC1kc3MAAACBALbaewDnzZ5AcGbZno7VW1m7Si3Q+yEANXZioVupfSwOP0q9aP2iV"
+                + "tyqq575JnUVZXMDR2Gr254F/qCJ0TKAvucN0gcd2XslX4jBcu1Z7s7YZf6d7fC58k0NE6/keokJNKhQO"
+                + "i56iirRzSA/YFrD64mzfq6rEmai0q7GjGGP0RT1AAAAFQDO5++6JonyqnoRkV9Yl1OaEOPjVwAAAIAYA"
+                + "tqtKtU/INlTIuL3wt3nyKzwPUnz3fqxP5Ger3OlRZsOahalTFt2OF5jGGmCunyBTRteOetZObr0QhUIF"
+                + "4bSDr6UiYYYbH1ES0ws/t1mDIeTh3UUHV1QYACN6c07FKyKLMtB9AthiG2FMLKCEedG3NeXItuNzsuQD"
+                + "+n/K1rzMAAAAIBi5SM4pFPiB7BvTZvARV56vrG5QNgWVazSwbwgl/EACiWYbRauHDUQA9f+Rq+ayWcsR"
+                + "os1CD+Q81y9SmlQaZVKkSPZLxXfu5bi3s4o431xjilhZdt4vKbj2pK364IjghJPNBBfmRXzlj9awKxr/" + "UebZcBgNRyeky7VZSbbF2jQSQ== test key";
+        String storedDssKey =
+            "ssh-dss AAAAB3NzaC1kc3MAAACBALbaewDnzZ5AcGbZno7VW1m7Si3Q+yEANXZioVupfSwOP0q9aP2iV"
+                + "tyqq575JnUVZXMDR2Gr254F/qCJ0TKAvucN0gcd2XslX4jBcu1Z7s7YZf6d7fC58k0NE6/keokJNKhQO"
+                + "i56iirRzSA/YFrD64mzfq6rEmai0q7GjGGP0RT1AAAAFQDO5++6JonyqnoRkV9Yl1OaEOPjVwAAAIAYA"
+                + "tqtKtU/INlTIuL3wt3nyKzwPUnz3fqxP5Ger3OlRZsOahalTFt2OF5jGGmCunyBTRteOetZObr0QhUIF"
+                + "4bSDr6UiYYYbH1ES0ws/t1mDIeTh3UUHV1QYACN6c07FKyKLMtB9AthiG2FMLKCEedG3NeXItuNzsuQD"
+                + "+n/K1rzMAAAAIBi5SM4pFPiB7BvTZvARV56vrG5QNgWVazSwbwgl/EACiWYbRauHDUQA9f+Rq+ayWcsR"
+                + "os1CD+Q81y9SmlQaZVKkSPZLxXfu5bi3s4o431xjilhZdt4vKbj2pK364IjghJPNBBfmRXzlj9awKxr/" + "UebZcBgNRyeky7VZSbbF2jQSQ==";
+        String parsedKey = SSHKeysHelper.getPublicKeyFromKeyMaterial(dssKey);
+        String fingerprint = SSHKeysHelper.getPublicKeyFingerprint(parsedKey);
+
+        assertTrue(storedDssKey.equals(parsedKey));
+        assertTrue("fc:6e:ef:31:93:f8:92:2b:a9:03:c7:06:90:f5:ec:bb".equals(fingerprint));
+
+    }
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/test/java/com/cloud/utils/testcase/Log4jEnabledTestCase.java
----------------------------------------------------------------------
diff --git a/utils/src/test/java/com/cloud/utils/testcase/Log4jEnabledTestCase.java b/utils/src/test/java/com/cloud/utils/testcase/Log4jEnabledTestCase.java
new file mode 100644
index 0000000..51cde2c
--- /dev/null
+++ b/utils/src/test/java/com/cloud/utils/testcase/Log4jEnabledTestCase.java
@@ -0,0 +1,58 @@
+//
+// 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 com.cloud.utils.testcase;
+
+import java.io.File;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.Random;
+
+import junit.framework.TestCase;
+
+import org.apache.log4j.xml.DOMConfigurator;
+
+public class Log4jEnabledTestCase extends TestCase {
+    @Override
+    protected void setUp() {
+        URL configUrl = System.class.getResource("/conf/log4j-cloud.xml");
+        if (configUrl != null) {
+            System.out.println("Configure log4j using log4j-cloud.xml");
+
+            try {
+                File file = new File(configUrl.toURI());
+
+                System.out.println("Log4j configuration from : " + file.getAbsolutePath());
+                DOMConfigurator.configureAndWatch(file.getAbsolutePath(), 10000);
+            } catch (URISyntaxException e) {
+                System.out.println("Unable to convert log4j configuration Url to URI");
+            }
+        } else {
+            System.out.println("Configure log4j with default properties");
+        }
+    }
+
+    public static int getRandomMilliseconds(int rangeLo, int rangeHi) {
+        int i = new Random().nextInt();
+
+        long pos = (long)i - (long)Integer.MIN_VALUE;
+        long iRange = (long)Integer.MAX_VALUE - (long)Integer.MIN_VALUE;
+        return rangeLo + (int)((rangeHi - rangeLo) * pos / iRange);
+    }
+}


Mime
View raw message