brooklyn-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hadr...@apache.org
Subject [13/42] incubator-brooklyn git commit: [BROOKLYN-162] Refactor package in ./core/util
Date Mon, 17 Aug 2015 19:17:44 GMT
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a4c0e5fd/core/src/test/java/org/apache/brooklyn/core/util/file/ArchiveBuilderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/util/file/ArchiveBuilderTest.java b/core/src/test/java/org/apache/brooklyn/core/util/file/ArchiveBuilderTest.java
new file mode 100644
index 0000000..0ce8298
--- /dev/null
+++ b/core/src/test/java/org/apache/brooklyn/core/util/file/ArchiveBuilderTest.java
@@ -0,0 +1,194 @@
+/*
+ * 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.brooklyn.core.util.file;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import javax.annotation.Nullable;
+
+import org.apache.brooklyn.core.util.file.ArchiveBuilder;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import brooklyn.util.collections.MutableSet;
+import brooklyn.util.os.Os;
+import brooklyn.util.text.Identifiers;
+
+import com.google.common.base.Charsets;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.io.Files;
+
+/**
+ * Test the operation of the {@link ArchiveBuilder} class.
+ */
+@Test
+public class ArchiveBuilderTest {
+
+    private File parentDir, tmpDir, tmpDir2;
+    private Predicate<ZipEntry> isDirectory = new Predicate<ZipEntry>() {
+                @Override
+                public boolean apply(@Nullable ZipEntry input) {
+                    return input.isDirectory();
+                }
+            };
+
+    @BeforeClass
+    public void createTmpDirAndFiles() throws IOException {
+        parentDir = Os.newTempDir(getClass().getSimpleName());
+        Os.deleteOnExitRecursively(parentDir);
+        tmpDir = new File(parentDir, Identifiers.makeRandomId(4));
+        Os.mkdirs(tmpDir);
+        Files.write("abcdef", new File(tmpDir, "data01.txt"), Charsets.US_ASCII);
+        Files.write("123456", new File(tmpDir, "data02.txt"), Charsets.US_ASCII);
+        Files.write("qqqqqq", new File(tmpDir, "data03.txt"), Charsets.US_ASCII);
+        
+        tmpDir2 = new File(parentDir, Identifiers.makeRandomId(4));
+        Os.mkdirs(tmpDir2);
+        Files.write("zzzzzz", new File(tmpDir2, "data04.txt"), Charsets.US_ASCII);
+    }
+    
+    @Test
+    public void testCreateZipFromDir() throws Exception {
+        File archive = ArchiveBuilder.zip().addDirContentsAt(tmpDir, ".").create();
+        archive.deleteOnExit();
+
+        List<ZipEntry> entries = Lists.newArrayList();
+        ZipInputStream input = new ZipInputStream(new FileInputStream(archive));
+        ZipEntry entry = input.getNextEntry();
+        while (entry != null) {
+            entries.add(entry);
+            entry = input.getNextEntry();
+        }
+        assertEquals(entries.size(), 4);
+        Iterable<ZipEntry> directories = Iterables.filter(entries, isDirectory);
+        Iterable<ZipEntry> files = Iterables.filter(entries, Predicates.not(isDirectory));
+        assertEquals(Iterables.size(directories), 1);
+        assertEquals(Iterables.size(files), 3);
+        String dirName = Iterables.getOnlyElement(directories).getName();
+        assertEquals(dirName, "./");
+        
+        Set<String> names = MutableSet.of();
+        for (ZipEntry file : files) {
+            assertTrue(file.getName().startsWith(dirName));
+            names.add(file.getName());
+        }
+        assertTrue(names.contains("./data01.txt"));
+        assertFalse(names.contains("./data04.txt"));
+        input.close();
+    }
+
+    @Test
+    public void testCreateZipFromTwoDirs() throws Exception {
+        File archive = ArchiveBuilder.zip().addDirContentsAt(tmpDir, ".").addDirContentsAt(tmpDir2, ".").create();
+        archive.deleteOnExit();
+
+        List<ZipEntry> entries = Lists.newArrayList();
+        ZipInputStream input = new ZipInputStream(new FileInputStream(archive));
+        ZipEntry entry = input.getNextEntry();
+        while (entry != null) {
+            entries.add(entry);
+            entry = input.getNextEntry();
+        }
+        assertEquals(entries.size(), 5);
+        Iterable<ZipEntry> directories = Iterables.filter(entries, isDirectory);
+        Iterable<ZipEntry> files = Iterables.filter(entries, Predicates.not(isDirectory));
+        assertEquals(Iterables.size(directories), 1);
+        assertEquals(Iterables.size(files), 4);
+        String dirName = Iterables.getOnlyElement(directories).getName();
+        assertEquals(dirName, "./");
+        
+        Set<String> names = MutableSet.of();
+        for (ZipEntry file : files) {
+            assertTrue(file.getName().startsWith(dirName));
+            names.add(file.getName());
+        }
+        assertTrue(names.contains("./data01.txt"));
+        assertTrue(names.contains("./data04.txt"));
+        input.close();
+    }
+    @Test
+    public void testCreateZipFromFiles() throws Exception {
+        ArchiveBuilder builder = ArchiveBuilder.zip();
+        for (String fileName : Arrays.asList("data01.txt", "data02.txt", "data03.txt")) {
+            builder.addAt(new File(tmpDir, fileName), ".");
+        }
+        File archive = builder.create();
+        archive.deleteOnExit();
+
+        List<ZipEntry> entries = Lists.newArrayList();
+        ZipInputStream input = new ZipInputStream(new FileInputStream(archive));
+        ZipEntry entry = input.getNextEntry();
+        while (entry != null) {
+            entries.add(entry);
+            entry = input.getNextEntry();
+        }
+        assertEquals(entries.size(), 3);
+        Iterable<ZipEntry> directories = Iterables.filter(entries, isDirectory);
+        Iterable<ZipEntry> files = Iterables.filter(entries, Predicates.not(isDirectory));
+        assertTrue(Iterables.isEmpty(directories));
+        assertEquals(Iterables.size(files), 3);
+        for (ZipEntry file : files) {
+            assertTrue(file.getName().startsWith(Os.mergePathsUnix(".", "data")));
+        }
+        input.close();
+    }
+
+    @Test
+    public void testCreateZipFromFilesWithBaseDir() throws Exception {
+        ArchiveBuilder builder = ArchiveBuilder.zip();
+        String baseDir = tmpDir.getName();
+        for (String fileName : Arrays.asList("data01.txt", "data02.txt", "data03.txt")) {
+            builder.addFromLocalBaseDir(parentDir, Os.mergePaths(baseDir, fileName));
+        }
+        File archive = builder.create();
+        archive.deleteOnExit();
+
+        List<ZipEntry> entries = Lists.newArrayList();
+        ZipInputStream input = new ZipInputStream(new FileInputStream(archive));
+        ZipEntry entry = input.getNextEntry();
+        while (entry != null) {
+            entries.add(entry);
+            entry = input.getNextEntry();
+        }
+        assertEquals(entries.size(), 3);
+        Iterable<ZipEntry> directories = Iterables.filter(entries, isDirectory);
+        Iterable<ZipEntry> files = Iterables.filter(entries, Predicates.not(isDirectory));
+        assertTrue(Iterables.isEmpty(directories));
+        assertEquals(Iterables.size(files), 3);
+        for (ZipEntry file : files) {
+            assertTrue(file.getName().startsWith(Os.mergePathsUnix(".", baseDir)));
+        }
+        input.close();
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a4c0e5fd/core/src/test/java/org/apache/brooklyn/core/util/file/ArchiveUtilsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/util/file/ArchiveUtilsTest.java b/core/src/test/java/org/apache/brooklyn/core/util/file/ArchiveUtilsTest.java
new file mode 100644
index 0000000..a13ef63
--- /dev/null
+++ b/core/src/test/java/org/apache/brooklyn/core/util/file/ArchiveUtilsTest.java
@@ -0,0 +1,139 @@
+/*
+ * 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.brooklyn.core.util.file;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+import java.io.File;
+import java.util.Map;
+
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import brooklyn.entity.BrooklynAppUnitTestSupport;
+
+import org.apache.brooklyn.core.util.ResourceUtils;
+import org.apache.brooklyn.core.util.file.ArchiveBuilder;
+import org.apache.brooklyn.core.util.file.ArchiveUtils;
+import org.apache.brooklyn.location.basic.SshMachineLocation;
+
+import brooklyn.util.os.Os;
+
+import com.google.api.client.repackaged.com.google.common.base.Joiner;
+import com.google.common.base.Charsets;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.io.Files;
+
+// Test are integration, because relies on ssh/scp via SshMachineLocation
+public class ArchiveUtilsTest extends BrooklynAppUnitTestSupport {
+    
+    private SshMachineLocation machine;
+    private ResourceUtils resourceUtils;
+
+    private Map<String, String> archiveContents = ImmutableMap.of("a.txt", "mya");
+    private File destDir;
+    private File origZip;
+    private File origJar;
+
+    @BeforeClass(alwaysRun=true)
+    public void setUpClass() throws Exception {
+        origZip = newZip(archiveContents);
+        origJar = Os.newTempFile(ArchiveUtilsTest.class, ".jar");
+        Files.copy(origZip, origJar);
+    }
+    
+    @AfterClass(alwaysRun=true)
+    public void tearDownClass() throws Exception {
+        if (origZip != null) origZip.delete();
+        if (origJar != null) origJar.delete();
+    }
+
+    @BeforeMethod(alwaysRun=true)
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        machine = app.newLocalhostProvisioningLocation().obtain();
+        resourceUtils = ResourceUtils.create(ArchiveUtilsTest.class);
+        destDir = Os.newTempDir(getClass().getSimpleName());
+    }
+    
+    @AfterMethod(alwaysRun=true)
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        if (destDir != null) Os.deleteRecursively(destDir);
+    }
+    
+    @Test(groups="Integration")
+    public void testDeployZipWithNoOptionalArgsSupplied() throws Exception {
+        boolean result = ArchiveUtils.deploy(resourceUtils, ImmutableMap.<String, Object>of(), origZip.getAbsolutePath(), machine, destDir.getAbsolutePath(), true, null, null);
+        assertTrue(result);
+        assertFilesEqual(new File(destDir, origZip.getName()), origZip);
+        assertSubFilesEqual(destDir, archiveContents);
+    }
+    
+    @Test(groups="Integration")
+    public void testDeployZipDeletingArchiveAfterUnpack() throws Exception {
+        boolean result = ArchiveUtils.deploy(resourceUtils, ImmutableMap.<String, Object>of(), origZip.getAbsolutePath(), machine, destDir.getAbsolutePath(), false, null, null);
+        assertTrue(result);
+        assertFalse(new File(destDir, origZip.getName()).exists());
+        assertSubFilesEqual(destDir, archiveContents);
+    }
+    
+    @Test(groups="Integration")
+    public void testDeployJarNotUnpacked() throws Exception {
+        ArchiveUtils.deploy(origJar.getAbsolutePath(), machine, destDir.getAbsolutePath());
+        assertFilesEqual(new File(destDir, origJar.getName()), origJar);
+    }
+    
+    @Test(groups="Integration")
+    public void testDeployExplicitDestFile() throws Exception {
+        String destFile = "custom-destFile.jar";
+        ArchiveUtils.deploy(origJar.getAbsolutePath(), machine, destDir.getAbsolutePath(), destFile);
+        assertFilesEqual(new File(destDir, destFile), origJar);
+    }
+    
+    private File newZip(Map<String, String> files) throws Exception {
+        File parentDir = Os.newTempDir(getClass().getSimpleName()+"-archive");
+        for (Map.Entry<String, String> entry : files.entrySet()) {
+            File subFile = new File(Os.mergePaths(parentDir.getAbsolutePath(), entry.getKey()));
+            subFile.getParentFile().mkdirs();
+            Files.write(entry.getValue(), subFile, Charsets.UTF_8);
+        }
+        return ArchiveBuilder.zip().addDirContentsAt(parentDir, ".").create();
+    }
+    
+    private void assertFilesEqual(File f1, File f2) throws Exception {
+        byte[] bytes1 = Files.asByteSource(f1).read();
+        byte[] bytes2 = Files.asByteSource(f1).read();
+        assertEquals(bytes1, bytes2, "f1="+f1+"; f2="+f2);
+    }
+    
+    private void assertSubFilesEqual(File parentDir, Map<String, String> files) throws Exception {
+        for (Map.Entry<String, String> entry : archiveContents.entrySet()) {
+            File subFile = new File(Os.mergePaths(parentDir.getAbsolutePath(), entry.getKey()));
+            assertEquals(Joiner.on("\n").join(Files.readLines(subFile, Charsets.UTF_8)), entry.getValue());
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a4c0e5fd/core/src/test/java/org/apache/brooklyn/core/util/flags/MethodCoercionsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/util/flags/MethodCoercionsTest.java b/core/src/test/java/org/apache/brooklyn/core/util/flags/MethodCoercionsTest.java
new file mode 100644
index 0000000..2d1efa3
--- /dev/null
+++ b/core/src/test/java/org/apache/brooklyn/core/util/flags/MethodCoercionsTest.java
@@ -0,0 +1,149 @@
+/*
+ * 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.brooklyn.core.util.flags;
+
+import brooklyn.util.exceptions.Exceptions;
+import brooklyn.util.guava.Maybe;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableList;
+
+import org.apache.brooklyn.core.util.flags.MethodCoercions;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+public class MethodCoercionsTest {
+
+    private Method singleParameterMethod;
+    private Method multiParameterMethod;
+    private Method singleCollectionParameterMethod;
+
+    @BeforeClass
+    public void testFixtureSetUp() {
+        try {
+            singleParameterMethod = TestClass.class.getMethod("singleParameterMethod", int.class);
+            multiParameterMethod = TestClass.class.getMethod("multiParameterMethod", boolean.class, int.class);
+            singleCollectionParameterMethod = TestClass.class.getMethod("singleCollectionParameterMethod", List.class);
+        } catch (NoSuchMethodException e) {
+            throw Exceptions.propagate(e);
+        }
+    }
+
+    @Test
+    public void testMatchSingleParameterMethod() throws Exception {
+        Predicate<Method> predicate = MethodCoercions.matchSingleParameterMethod("singleParameterMethod", "42");
+        assertTrue(predicate.apply(singleParameterMethod));
+        assertFalse(predicate.apply(multiParameterMethod));
+        assertFalse(predicate.apply(singleCollectionParameterMethod));
+    }
+
+    @Test
+    public void testTryFindAndInvokeSingleParameterMethod() throws Exception {
+        TestClass instance = new TestClass();
+        Maybe<?> maybe = MethodCoercions.tryFindAndInvokeSingleParameterMethod(instance, "singleParameterMethod", "42");
+        assertTrue(maybe.isPresent());
+        assertTrue(instance.wasSingleParameterMethodCalled());
+    }
+
+    @Test
+    public void testMatchMultiParameterMethod() throws Exception {
+        Predicate<Method> predicate = MethodCoercions.matchMultiParameterMethod("multiParameterMethod", ImmutableList.of("true", "42"));
+        assertFalse(predicate.apply(singleParameterMethod));
+        assertTrue(predicate.apply(multiParameterMethod));
+        assertFalse(predicate.apply(singleCollectionParameterMethod));
+    }
+
+    @Test
+    public void testTryFindAndInvokeMultiParameterMethod() throws Exception {
+        TestClass instance = new TestClass();
+        Maybe<?> maybe = MethodCoercions.tryFindAndInvokeMultiParameterMethod(instance, "multiParameterMethod", ImmutableList.of("true", "42"));
+        assertTrue(maybe.isPresent());
+        assertTrue(instance.wasMultiParameterMethodCalled());
+    }
+
+    @Test
+    public void testTryFindAndInvokeBestMatchingMethod() throws Exception {
+        TestClass instance = new TestClass();
+        Maybe<?> maybe = MethodCoercions.tryFindAndInvokeBestMatchingMethod(instance, "singleParameterMethod", "42");
+        assertTrue(maybe.isPresent());
+        assertTrue(instance.wasSingleParameterMethodCalled());
+
+        instance = new TestClass();
+        maybe = MethodCoercions.tryFindAndInvokeBestMatchingMethod(instance, "multiParameterMethod", ImmutableList.of("true", "42"));
+        assertTrue(maybe.isPresent());
+        assertTrue(instance.wasMultiParameterMethodCalled());
+
+        instance = new TestClass();
+        maybe = MethodCoercions.tryFindAndInvokeBestMatchingMethod(instance, "singleCollectionParameterMethod", ImmutableList.of("fred", "joe"));
+        assertTrue(maybe.isPresent());
+        assertTrue(instance.wasSingleCollectionParameterMethodCalled());
+    }
+/*
+    @Test
+    public void testMatchSingleCollectionParameterMethod() throws Exception {
+        Predicate<Method> predicate = MethodCoercions.matchSingleCollectionParameterMethod("singleCollectionParameterMethod", ImmutableList.of("42"));
+        assertFalse(predicate.apply(singleParameterMethod));
+        assertFalse(predicate.apply(multiParameterMethod));
+        assertTrue(predicate.apply(singleCollectionParameterMethod));
+    }
+
+    @Test
+    public void testTryFindAndInvokeSingleCollectionParameterMethod() throws Exception {
+        TestClass instance = new TestClass();
+        Maybe<?> maybe = MethodCoercions.tryFindAndInvokeSingleCollectionParameterMethod(instance, "singleCollectionParameterMethod", ImmutableList.of("42"));
+        assertTrue(maybe.isPresent());
+        assertTrue(instance.wasSingleCollectionParameterMethodCalled());
+    }
+*/
+    public static class TestClass {
+
+        private boolean singleParameterMethodCalled;
+        private boolean multiParameterMethodCalled;
+        private boolean singleCollectionParameterMethodCalled;
+
+        public void singleParameterMethod(int parameter) {
+            singleParameterMethodCalled = true;
+        }
+
+        public void multiParameterMethod(boolean parameter1, int parameter2) {
+            multiParameterMethodCalled = true;
+        }
+
+        public void singleCollectionParameterMethod(List<String> parameter) {
+            singleCollectionParameterMethodCalled = true;
+        }
+
+        public boolean wasSingleParameterMethodCalled() {
+            return singleParameterMethodCalled;
+        }
+
+        public boolean wasMultiParameterMethodCalled() {
+            return multiParameterMethodCalled;
+        }
+
+        public boolean wasSingleCollectionParameterMethodCalled() {
+            return singleCollectionParameterMethodCalled;
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a4c0e5fd/core/src/test/java/org/apache/brooklyn/core/util/http/BetterMockWebServer.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/util/http/BetterMockWebServer.java b/core/src/test/java/org/apache/brooklyn/core/util/http/BetterMockWebServer.java
new file mode 100644
index 0000000..f02689b
--- /dev/null
+++ b/core/src/test/java/org/apache/brooklyn/core/util/http/BetterMockWebServer.java
@@ -0,0 +1,138 @@
+/*
+ * 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.brooklyn.core.util.http;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.Proxy;
+import java.net.URL;
+
+import javax.net.ssl.SSLSocketFactory;
+
+import com.google.common.base.Throwables;
+import com.google.mockwebserver.Dispatcher;
+import com.google.mockwebserver.MockResponse;
+import com.google.mockwebserver.MockWebServer;
+import com.google.mockwebserver.RecordedRequest;
+
+/** like MockWebServer (and delegating) but:
+ * <li> allows subclassing
+ * <li> easy way to create instance which returns localhost for {@link #getHostName()}
+ *      (since otherwise you can get failures on networks which misconfigure hostname) 
+ * */
+public class BetterMockWebServer {
+
+    final MockWebServer delegate = new MockWebServer();
+    String hostname = null;
+    boolean isHttps = false;
+    
+    public static BetterMockWebServer newInstanceLocalhost() {
+        return new BetterMockWebServer().setHostName("localhost");
+    }
+    
+    /** use {@link #newInstanceLocalhost()} or subclass */
+    protected BetterMockWebServer() {}
+
+    public BetterMockWebServer setHostName(String hostname) {
+        this.hostname = hostname;
+        return this;
+    }
+
+
+    // --- delegate methods (unchanged)
+    
+    public void enqueue(MockResponse response) {
+        delegate.enqueue(response);
+    }
+
+    public boolean equals(Object obj) {
+        return delegate.equals(obj);
+    }
+
+    public String getCookieDomain() {
+        return delegate.getCookieDomain();
+    }
+
+    public String getHostName() {
+        if (hostname!=null) return hostname;
+        return delegate.getHostName();
+    }
+
+    public int getPort() {
+        return delegate.getPort();
+    }
+
+    public int getRequestCount() {
+        return delegate.getRequestCount();
+    }
+
+    public URL getUrl(String path) {
+        try {
+            return isHttps
+                ? new URL("https://" + getHostName() + ":" + getPort() + path)
+                : new URL("http://" + getHostName() + ":" + getPort() + path);
+        } catch (MalformedURLException e) {
+            throw Throwables.propagate(e);
+        }
+    }
+
+    public int hashCode() {
+        return delegate.hashCode();
+    }
+
+    public void play() throws IOException {
+        delegate.play();
+    }
+
+    public void play(int port) throws IOException {
+        delegate.play(port);
+    }
+
+    public void setBodyLimit(int maxBodyLength) {
+        delegate.setBodyLimit(maxBodyLength);
+    }
+
+    public void setDispatcher(Dispatcher dispatcher) {
+        delegate.setDispatcher(dispatcher);
+    }
+
+    public void shutdown() throws IOException {
+        delegate.shutdown();
+    }
+
+    public RecordedRequest takeRequest() throws InterruptedException {
+        return delegate.takeRequest();
+    }
+
+    public Proxy toProxyAddress() {
+        return delegate.toProxyAddress();
+    }
+
+    public String toString() {
+        return delegate.toString();
+    }
+
+    public void useHttps(SSLSocketFactory sslSocketFactory, boolean tunnelProxy) {
+        isHttps = true;
+        delegate.useHttps(sslSocketFactory, tunnelProxy);
+    }
+    
+    
+    
+}

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a4c0e5fd/core/src/test/java/org/apache/brooklyn/core/util/http/HttpToolIntegrationTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/util/http/HttpToolIntegrationTest.java b/core/src/test/java/org/apache/brooklyn/core/util/http/HttpToolIntegrationTest.java
new file mode 100644
index 0000000..f557955
--- /dev/null
+++ b/core/src/test/java/org/apache/brooklyn/core/util/http/HttpToolIntegrationTest.java
@@ -0,0 +1,100 @@
+/*
+ * 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.brooklyn.core.util.http;
+
+import static org.testng.Assert.assertTrue;
+
+import java.net.URI;
+
+import org.apache.http.client.HttpClient;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+import org.apache.brooklyn.core.util.http.HttpTool;
+import org.apache.brooklyn.core.util.http.HttpToolResponse;
+import org.apache.brooklyn.location.basic.PortRanges;
+
+import brooklyn.test.HttpService;
+
+import com.google.common.collect.ImmutableMap;
+
+public class HttpToolIntegrationTest {
+
+    // TODO Expand test coverage for credentials etc
+    
+    private HttpService httpService;
+    private HttpService httpsService;
+
+    @BeforeMethod(alwaysRun=true)
+    public void setUp() throws Exception {
+        httpService = new HttpService(PortRanges.fromString("9000+"), false).start();
+        httpsService = new HttpService(PortRanges.fromString("9000+"), true).start();
+    }
+    
+    @AfterMethod(alwaysRun=true)
+    public void tearDown() throws Exception {
+        if (httpService != null) httpService.shutdown();
+        if (httpsService != null) httpsService.shutdown();
+    }
+    
+    @Test(groups = {"Integration"})
+    public void testHttpGet() throws Exception {
+        URI baseUri = new URI(httpService.getUrl());
+
+        HttpClient client = HttpTool.httpClientBuilder().build();
+        HttpToolResponse result = HttpTool.httpGet(client, baseUri, ImmutableMap.<String,String>of());
+        assertTrue(new String(result.getContent()).contains("Hello, World"), "val="+new String(result.getContent()));
+    }
+    
+    @Test(groups = {"Integration"})
+    public void testHttpRedirect() throws Exception {
+        URI baseUri = new URI(httpService.getUrl() + "hello/redirectAbsolute");
+
+        HttpClient client = HttpTool.httpClientBuilder().laxRedirect(true).build();
+        HttpToolResponse result = HttpTool.httpGet(client, baseUri, ImmutableMap.<String,String>of());
+        assertTrue(new String(result.getContent()).contains("Hello, World"), "val="+new String(result.getContent()));
+    }
+    
+    @Test(groups = {"Integration"})
+    public void testHttpPost() throws Exception {
+        URI baseUri = new URI(httpService.getUrl());
+
+        HttpClient client = HttpTool.httpClientBuilder().build();
+        HttpToolResponse result = HttpTool.httpPost(client, baseUri, ImmutableMap.<String,String>of(), new byte[0]);
+        assertTrue(new String(result.getContent()).contains("Hello, World"), "val="+new String(result.getContent()));
+    }
+    
+    @Test(groups = {"Integration"})
+    public void testHttpsGetWithTrustAll() throws Exception {
+        URI baseUri = new URI(httpsService.getUrl());
+
+        HttpClient client = HttpTool.httpClientBuilder().https(true).trustAll().build();
+        HttpToolResponse result = HttpTool.httpGet(client, baseUri, ImmutableMap.<String,String>of());
+        assertTrue(new String(result.getContent()).contains("Hello, World"), "val="+new String(result.getContent()));
+    }
+    
+    @Test(groups = {"Integration"})
+    public void testHttpsPostWithTrustSelfSigned() throws Exception {
+        URI baseUri = new URI(httpsService.getUrl());
+
+        HttpClient client = HttpTool.httpClientBuilder().https(true).trustSelfSigned().build();
+        HttpToolResponse result = HttpTool.httpPost(client, baseUri, ImmutableMap.<String,String>of(), new byte[0]);
+        assertTrue(new String(result.getContent()).contains("Hello, World"), "val="+new String(result.getContent()));
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a4c0e5fd/core/src/test/java/org/apache/brooklyn/core/util/internal/FlagUtilsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/util/internal/FlagUtilsTest.java b/core/src/test/java/org/apache/brooklyn/core/util/internal/FlagUtilsTest.java
new file mode 100644
index 0000000..02becf6
--- /dev/null
+++ b/core/src/test/java/org/apache/brooklyn/core/util/internal/FlagUtilsTest.java
@@ -0,0 +1,314 @@
+/*
+ * 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.brooklyn.core.util.internal;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+import java.lang.reflect.Field;
+import java.net.InetAddress;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.brooklyn.api.entity.trait.Configurable;
+import org.apache.brooklyn.api.management.Task;
+import org.apache.brooklyn.core.util.config.ConfigBag;
+import org.apache.brooklyn.core.util.flags.FlagUtils;
+import org.apache.brooklyn.core.util.flags.SetFromFlag;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testng.annotations.Test;
+
+import brooklyn.config.ConfigKey;
+import brooklyn.config.ConfigKey.HasConfigKey;
+import brooklyn.entity.basic.ConfigKeys;
+import brooklyn.event.basic.BasicConfigKey;
+import brooklyn.util.collections.MutableMap;
+
+import com.google.common.base.Function;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+
+public class FlagUtilsTest {
+
+    public static final Logger log = LoggerFactory.getLogger(FlagUtilsTest.class);
+    
+    @Test
+    public void testGetAllFields() {
+        log.info("types {}", FlagUtils.getAllAssignableTypes(Baz.class));
+        assertEquals(FlagUtils.getAllAssignableTypes(Baz.class), ImmutableList.of(Baz.class, Foo.class, Bar.class));
+        List<Field> fs = FlagUtils.getAllFields(Baz.class);
+        for (Field f : fs) {
+            log.info("field {}    {}", f.getName(), f);
+        }
+        List<String> fsn = ImmutableList.copyOf(Iterables.transform(fs, new Function<Field, String>() {
+            @Override public String apply(Field f) {
+                return f.getName();
+            }}));
+        assertTrue(fsn.indexOf("A") >= 0);
+        assertTrue(fsn.indexOf("w") > fsn.indexOf("A")); 
+        assertTrue(fsn.indexOf("x") > fsn.indexOf("A") );
+        assertTrue(fsn.indexOf("yNotY") > fsn.indexOf("A")); 
+        assertTrue(fsn.indexOf("Z") > fsn.indexOf("yNotY") );
+    }    
+    
+    @Test
+    public void testSetFieldsFromFlags() {
+        Foo f = new Foo();
+        Map<?,?> m = MutableMap.of("w", 3, "x", 1, "y", 7, "z", 9);
+        Map<?, ?> unused = FlagUtils.setFieldsFromFlags(m, f);
+        assertEquals(f.w, 3);
+        assertEquals(f.x, 1);
+        assertEquals(f.yNotY, 7);
+        assertEquals(unused, ImmutableMap.of("z", 9));
+        Map<?,?> m2 = FlagUtils.getFieldsWithValues(f);
+        m.remove("z");
+        assertEquals(m2, m);
+    }
+    
+    @Test
+    public void testCollectionCoercionOnSetFromFlags() {
+        WithSpecialFieldTypes s = new WithSpecialFieldTypes();
+        Map<?,?> m = ImmutableMap.of("set", ImmutableSet.of(1));
+        FlagUtils.setFieldsFromFlags(m, s);
+        assertEquals(s.set, ImmutableSet.of(1));
+    }
+
+    @Test
+    public void testInetAddressCoercionOnSetFromFlags() {
+        WithSpecialFieldTypes s = new WithSpecialFieldTypes();
+        Map<?,?> m = ImmutableMap.of("inet", "127.0.0.1");
+        FlagUtils.setFieldsFromFlags(m, s);
+        assertEquals(s.inet.getHostAddress(), "127.0.0.1");
+    }
+
+    @Test
+    public void testNonImmutableField() {
+        Foo f = new Foo();
+        FlagUtils.setFieldsFromFlags(ImmutableMap.of("w", 8), f);
+        assertEquals(f.w, 8);
+        FlagUtils.setFieldsFromFlags(ImmutableMap.of("w", 9), f);
+        assertEquals(f.w, 9);
+    }
+
+    @Test
+    public void testImmutableIntField() {
+        Foo f = new Foo();
+        FlagUtils.setFieldsFromFlags(ImmutableMap.of("x", 8), f);
+        assertEquals(f.x, 8);
+        boolean succeededWhenShouldntHave = false; 
+        try {
+            FlagUtils.setFieldsFromFlags(ImmutableMap.of("x", 9), f);
+            succeededWhenShouldntHave = true;
+        } catch (IllegalStateException e) {
+            //expected
+        }
+        assertFalse(succeededWhenShouldntHave);
+        assertEquals(f.x, 8);
+    }
+
+    @Test
+    public void testImmutableObjectField() {
+        WithImmutableNonNullableObject o = new WithImmutableNonNullableObject();
+        FlagUtils.setFieldsFromFlags(ImmutableMap.of("a", "a", "b", "b"), o);
+        assertEquals(o.a, "a");
+        assertEquals(o.b, "b");
+        
+        FlagUtils.setFieldsFromFlags(ImmutableMap.of("a", "a2"), o);
+        assertEquals(o.a, "a2");
+        
+        boolean succeededWhenShouldntHave = false;
+        try {
+            FlagUtils.setFieldsFromFlags(ImmutableMap.of("b", "b2"), o);
+            succeededWhenShouldntHave = true;
+        } catch (IllegalStateException e) {
+            //expected
+        }
+        assertFalse(succeededWhenShouldntHave);
+        assertEquals(o.b, "b");
+    }
+
+    @Test
+    public void testNonNullable() {
+        WithImmutableNonNullableObject o = new WithImmutableNonNullableObject();
+        //allowed
+        FlagUtils.setFieldsFromFlags(MutableMap.of("a", null), o);
+        assertEquals(o.a, null);
+        assertEquals(o.b, null);
+        //not allowed
+        boolean succeededWhenShouldntHave = false;
+        try {
+            FlagUtils.setFieldsFromFlags(MutableMap.of("b", null), o);
+            succeededWhenShouldntHave = true;
+        } catch (IllegalArgumentException e) {
+            //expected
+        }
+        assertFalse(succeededWhenShouldntHave);
+        assertEquals(o.b, null);
+    }
+    
+    @Test
+    public void testGetAnnotatedFields() throws Exception {
+        Map<Field, SetFromFlag> fm = FlagUtils.getAnnotatedFields(WithImmutableNonNullableObject.class);
+        assertEquals(fm.keySet().size(), 2);
+        assertTrue(fm.get(WithImmutableNonNullableObject.class.getDeclaredField("b")).immutable());
+    }
+
+    @Test
+    public void testCheckRequired() {
+        WithImmutableNonNullableObject f = new WithImmutableNonNullableObject();
+        FlagUtils.setFieldsFromFlags(ImmutableMap.of("a", "a is a"), f);
+        assertEquals(f.a, "a is a");
+        assertEquals(f.b, null);
+        int exceptions = 0;
+        try {
+            FlagUtils.checkRequiredFields(f);
+        } catch (IllegalStateException e) {
+            exceptions++;
+        }
+        assertEquals(exceptions, 1);
+    }
+
+    @Test
+    public void testSetConfigKeys() {
+        FooCK f = new FooCK();
+        Map<?,?> unused = FlagUtils.setFieldsFromFlags(ImmutableMap.of("f1", 9, "ck1", "do-set", "ck2", "dont-set", "c3", "do-set"), f);
+        assertEquals(f.bag.get(FooCK.CK1), "do-set");
+        assertEquals(f.bag.get(FooCK.CK3), "do-set");
+        assertEquals(f.f1, 9);
+        assertEquals(f.bag.containsKey(FooCK.CK2), false);
+        assertEquals(unused, ImmutableMap.of("ck2", "dont-set"));
+    }
+    
+    @Test
+    public void testSetAllConfigKeys() {
+        FooCK f = new FooCK();
+        Map<?,?> unused = FlagUtils.setAllConfigKeys(ImmutableMap.of("f1", 9, "ck1", "do-set", "ck2", "do-set-2", "c3", "do-set"), f, true);
+        assertEquals(f.bag.get(FooCK.CK1), "do-set");
+        assertEquals(f.bag.get(FooCK.CK3), "do-set");
+        assertEquals(f.bag.containsKey(FooCK.CK2), true);
+        assertEquals(f.bag.get(FooCK.CK2), "do-set-2");
+        assertEquals(unused, ImmutableMap.of("f1", 9));
+    }
+
+    @Test
+    public void testSetFromConfigKeys() {
+        FooCK f = new FooCK();
+        Map<?, ?> unused = FlagUtils.setFieldsFromFlags(ImmutableMap.of(new BasicConfigKey<Integer>(Integer.class, "f1"), 9, "ck1", "do-set", "ck2", "dont-set"), f);
+        assertEquals(f.bag.get(FooCK.CK1), "do-set");
+        assertEquals(f.f1, 9);
+        assertEquals(f.bag.containsKey(FooCK.CK2), false);
+        assertEquals(unused, ImmutableMap.of("ck2", "dont-set"));
+    }
+
+    public static class Foo {
+        @SetFromFlag
+        int w;
+        
+        @SetFromFlag(immutable=true)
+        private int x;
+        
+        @SetFromFlag("y")
+        public int yNotY;
+    }
+    
+    public static interface Bar {
+        static final String Z = "myzval";
+    }
+    
+    public static class Baz extends Foo implements Bar {
+        @SuppressWarnings("unused")  //inspected by reflection
+        private static int A;
+    }
+    
+    public static class WithImmutableNonNullableObject {
+        @SetFromFlag
+        Object a;
+        @SetFromFlag(immutable=true, nullable=false)
+        public Object b;
+    }
+    
+    public static class WithSpecialFieldTypes {
+        @SetFromFlag Set<?> set;
+        @SetFromFlag InetAddress inet;
+    }
+    
+    public static class FooCK implements Configurable {
+        @SetFromFlag
+        public static ConfigKey<String> CK1 = ConfigKeys.newStringConfigKey("ck1");
+        
+        public static ConfigKey<String> CK2 = ConfigKeys.newStringConfigKey("ck2");
+
+        @SetFromFlag("c3")
+        public static ConfigKey<String> CK3 = ConfigKeys.newStringConfigKey("ck3");
+
+        @SetFromFlag
+        int f1;
+        
+        ConfigBag bag = new ConfigBag();
+        BasicConfigurationSupport configSupport = new BasicConfigurationSupport();
+        
+        @Override
+        public ConfigurationSupport config() {
+            return configSupport;
+        }
+        
+        public <T> T setConfig(ConfigKey<T> key, T val) {
+            return config().set(key, val);
+        }
+        
+        private class BasicConfigurationSupport implements ConfigurationSupport {
+            @Override
+            public <T> T get(ConfigKey<T> key) {
+                return bag.get(key);
+            }
+
+            @Override
+            public <T> T get(HasConfigKey<T> key) {
+                return get(key.getConfigKey());
+            }
+
+            @Override
+            public <T> T set(ConfigKey<T> key, T val) {
+                T old = bag.get(key);
+                bag.configure(key, val);
+                return old;
+            }
+
+            @Override
+            public <T> T set(HasConfigKey<T> key, T val) {
+                return set(key.getConfigKey(), val);
+            }
+
+            @Override
+            public <T> T set(ConfigKey<T> key, Task<T> val) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public <T> T set(HasConfigKey<T> key, Task<T> val) {
+                return set(key.getConfigKey(), val);
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a4c0e5fd/core/src/test/java/org/apache/brooklyn/core/util/internal/RepeaterTest.groovy
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/util/internal/RepeaterTest.groovy b/core/src/test/java/org/apache/brooklyn/core/util/internal/RepeaterTest.groovy
new file mode 100644
index 0000000..08ef0da
--- /dev/null
+++ b/core/src/test/java/org/apache/brooklyn/core/util/internal/RepeaterTest.groovy
@@ -0,0 +1,257 @@
+/*
+ * 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.brooklyn.core.util.internal
+
+import static java.util.concurrent.TimeUnit.*
+import static org.testng.Assert.*
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.TimeUnit
+
+import org.apache.brooklyn.core.util.internal.Repeater;
+import org.testng.annotations.Test
+
+import brooklyn.util.internal.TimeExtras;
+import brooklyn.util.time.Duration;
+
+import com.google.common.base.Stopwatch
+
+public class RepeaterTest {
+    static { TimeExtras.init() }
+
+    @Test
+    public void sanityTest() {
+        new Repeater("Sanity test")
+            .repeat()
+            .until { true }
+            .every(10 * MILLISECONDS);
+    }
+
+    @Test
+    public void sanityTestDescription() {
+        new Repeater()
+            .repeat()
+            .until { true }
+            .every(10 * MILLISECONDS);
+    }
+
+    @Test
+    public void sanityTestBuilder() {
+        Repeater.create("Sanity test")
+            .repeat()
+            .until { true }
+            .every(10 * MILLISECONDS);
+    }
+
+    @Test
+    public void sanityTestBuilderDescription() {
+        Repeater.create()
+            .repeat()
+            .until { true }
+            .every(10 * MILLISECONDS);
+    }
+
+    @Test(expectedExceptions = [ NullPointerException.class ])
+    public void repeatFailsIfClosureIsNull() {
+        new Repeater("repeatFailsIfClosureIsNull").repeat((Callable<?>)null);
+        fail "Expected exception was not thrown"
+    }
+
+    @Test
+    public void repeatSucceedsIfClosureIsNonNull() {
+        new Repeater("repeatSucceedsIfClosureIsNonNull").repeat { true };
+    }
+
+    @Test(expectedExceptions = [ NullPointerException.class ])
+    public void untilFailsIfClosureIsNull() {
+        new Repeater("untilFailsIfClosureIsNull").until(null);
+        fail "Expected exception was not thrown"
+    }
+
+    @Test
+    public void untilSucceedsIfClosureIsNonNull() {
+        new Repeater("untilSucceedsIfClosureIsNonNull").until { true };
+    }
+
+    @Test(expectedExceptions = [ IllegalArgumentException.class ])
+    public void everyFailsIfPeriodIsZero() {
+        new Repeater("everyFailsIfPeriodIsZero").every(0 * MILLISECONDS);
+        fail "Expected exception was not thrown"
+    }
+
+    @Test(expectedExceptions = [ IllegalArgumentException.class ])
+    public void everyFailsIfPeriodIsNegative() {
+        new Repeater("everyFailsIfPeriodIsNegative").every(-1 * MILLISECONDS);
+        fail "Expected exception was not thrown"
+    }
+
+    @Test(expectedExceptions = [ NullPointerException.class ])
+    public void everyFailsIfUnitsIsNull() {
+        new Repeater("everyFailsIfUnitsIsNull").every(10, null);
+        fail "Expected exception was not thrown"
+    }
+
+    @Test
+    public void everySucceedsIfPeriodIsPositiveAndUnitsIsNonNull() {
+        new Repeater("repeatSucceedsIfClosureIsNonNull").every(10 * MILLISECONDS);
+    }
+
+    @Test(expectedExceptions = [ IllegalArgumentException.class ])
+    public void limitTimeToFailsIfPeriodIsZero() {
+        new Repeater("limitTimeToFailsIfPeriodIsZero").limitTimeTo(0, TimeUnit.MILLISECONDS);
+        fail "Expected exception was not thrown"
+    }
+
+    @Test(expectedExceptions = [ IllegalArgumentException.class ])
+    public void limitTimeToFailsIfPeriodIsNegative() {
+        new Repeater("limitTimeToFailsIfPeriodIsNegative").limitTimeTo(-1, TimeUnit.MILLISECONDS);
+        fail "Expected exception was not thrown"
+    }
+
+    @Test(expectedExceptions = [ NullPointerException.class ])
+    public void limitTimeToFailsIfUnitsIsNull() {
+        new Repeater("limitTimeToFailsIfUnitsIsNull").limitTimeTo(10, null);
+        fail "Expected exception was not thrown"
+    }
+
+    @Test
+    public void limitTimeToSucceedsIfPeriodIsPositiveAndUnitsIsNonNull() {
+        new Repeater("limitTimeToSucceedsIfClosureIsNonNull").limitTimeTo(10, TimeUnit.MILLISECONDS);
+    }
+
+    @Test
+    public void everyAcceptsDuration() {
+        new Repeater("everyAcceptsDuration").every(Duration.ONE_SECOND);
+    }
+
+    @Test
+    public void everyAcceptsLong() {
+        new Repeater("everyAcceptsLong").every(1000L);
+    }
+
+    @Test
+    public void everyAcceptsTimeUnit() {
+        new Repeater("everyAcceptsTimeUnit").every(1000000L, TimeUnit.MICROSECONDS);
+    }
+
+    @Test
+    public void runReturnsTrueIfExitConditionIsTrue() {
+        assertTrue new Repeater("runReturnsTrueIfExitConditionIsTrue")
+            .repeat()
+            .every(1 * MILLISECONDS)
+            .until { true }
+            .run();
+    }
+
+    @Test
+    public void runRespectsMaximumIterationLimitAndReturnsFalseIfReached() {
+        int iterations = 0;
+        assertFalse new Repeater("runRespectsMaximumIterationLimitAndReturnsFalseIfReached")
+            .repeat { iterations++ }
+            .every(1 * MILLISECONDS)
+            .until { false }
+            .limitIterationsTo(5)
+            .run();
+        assertEquals 5, iterations;
+    }
+
+    /**
+     * Check that the {@link Repeater} will stop after a time limit.
+     *
+     * The repeater is configured to run every 100ms and never stop until the limit is reached.
+     * This is given as {@link Repeater#limitTimeTo(groovy.time.Duration)} and the execution time
+     * is then checked to ensure it is between 100% and 400% of the specified value. Due to scheduling
+     * delays and other factors in a non RTOS system it is expected that the repeater will take much
+     * longer to exit occasionally.
+     *
+     * @see #runRespectsMaximumIterationLimitAndReturnsFalseIfReached()
+     */
+    @Test(groups="Integration")
+    public void runRespectsTimeLimitAndReturnsFalseIfReached() {
+        final long LIMIT = 2000l;
+        Repeater repeater = new Repeater("runRespectsTimeLimitAndReturnsFalseIfReached")
+            .repeat()
+            .every(100 * MILLISECONDS)
+            .until { false }
+            .limitTimeTo(LIMIT, TimeUnit.MILLISECONDS);
+
+        Stopwatch stopwatch = new Stopwatch().start();
+        boolean result = repeater.run();
+        stopwatch.stop();
+
+        assertFalse result;
+
+        long difference = stopwatch.elapsed(TimeUnit.MILLISECONDS);
+        assertTrue(difference >= LIMIT, "Difference was: " + difference);
+        assertTrue(difference < 4 * LIMIT, "Difference was: " + difference);
+    }
+
+    @Test(expectedExceptions = [ IllegalStateException.class ])
+    public void runFailsIfUntilWasNotSet() {
+        new Repeater("runFailsIfUntilWasNotSet")
+            .repeat()
+            .every(10 * MILLISECONDS)
+            .run();
+        fail "Expected exception was not thrown"
+    }
+
+    @Test(expectedExceptions = [ IllegalStateException.class ])
+    public void runFailsIfEveryWasNotSet() {
+        new Repeater("runFailsIfEveryWasNotSet")
+            .repeat()
+            .until { true }
+            .run();
+        fail "Expected exception was not thrown"
+    }
+
+    @Test(expectedExceptions = [ UnsupportedOperationException.class ])
+    public void testRethrowsException() {
+        boolean result = new Repeater("throwRuntimeException")
+            .repeat()
+            .every(10 * MILLISECONDS)
+            .until { throw new UnsupportedOperationException("fail") }
+            .rethrowException()
+            .limitIterationsTo(2)
+            .run();
+        fail "Expected exception was not thrown"
+    }
+
+    @Test
+    public void testNoRethrowsException() {
+        try {
+	        boolean result = new Repeater("throwRuntimeException")
+	            .repeat()
+	            .every(10 * MILLISECONDS)
+	            .until { throw new UnsupportedOperationException("fail") }
+	            .limitIterationsTo(2)
+	            .run();
+	        assertFalse result
+        } catch (RuntimeException re) {
+            fail "Exception should not have been thrown: " + re.getMessage()
+        }
+    }
+	
+	public void testFlags() {
+		int count=0;
+		new Repeater(period: 5*MILLISECONDS, timeout: 100*MILLISECONDS).repeat({ count++ }).until({ count>100}).run();
+		assertTrue count>10
+		assertTrue count<30
+	}
+	
+}

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a4c0e5fd/core/src/test/java/org/apache/brooklyn/core/util/internal/TypeCoercionsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/util/internal/TypeCoercionsTest.java b/core/src/test/java/org/apache/brooklyn/core/util/internal/TypeCoercionsTest.java
new file mode 100644
index 0000000..f1bb3f9
--- /dev/null
+++ b/core/src/test/java/org/apache/brooklyn/core/util/internal/TypeCoercionsTest.java
@@ -0,0 +1,360 @@
+/*
+ * 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.brooklyn.core.util.internal;
+
+import static org.testng.Assert.assertEquals;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.brooklyn.core.util.flags.ClassCoercionException;
+import org.apache.brooklyn.core.util.flags.TypeCoercions;
+import org.codehaus.groovy.runtime.GStringImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import brooklyn.entity.basic.Lifecycle;
+import brooklyn.util.collections.MutableSet;
+import brooklyn.util.text.StringPredicates;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.reflect.TypeToken;
+
+public class TypeCoercionsTest {
+
+    private static final Logger log = LoggerFactory.getLogger(TypeCoercionsTest.class);
+    
+    @Test
+    public void testCoerceCharSequenceToString() {
+        assertEquals(TypeCoercions.coerce(new StringBuilder("abc"), String.class), "abc");
+        assertEquals(TypeCoercions.coerce(new GStringImpl(new Object[0], new String[0]), String.class), "");
+    }
+    
+    @Test
+    public void testCoerceStringToPrimitive() {
+        assertEquals(TypeCoercions.coerce("1", Character.class), (Character)'1');
+        assertEquals(TypeCoercions.coerce(" ", Character.class), (Character)' ');
+        assertEquals(TypeCoercions.coerce("1", Short.class), (Short)((short)1));
+        assertEquals(TypeCoercions.coerce("1", Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce("1", Long.class), (Long)1l);
+        assertEquals(TypeCoercions.coerce("1", Float.class), (Float)1f);
+        assertEquals(TypeCoercions.coerce("1", Double.class), (Double)1d);
+        assertEquals(TypeCoercions.coerce("true", Boolean.class), (Boolean)true);
+        assertEquals(TypeCoercions.coerce("False", Boolean.class), (Boolean)false);
+        assertEquals(TypeCoercions.coerce("true ", Boolean.class), (Boolean)true);
+
+        assertEquals(TypeCoercions.coerce("1", char.class), (Character)'1');
+        assertEquals(TypeCoercions.coerce("1", short.class), (Short)((short)1));
+        assertEquals(TypeCoercions.coerce("1", int.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce("1", long.class), (Long)1l);
+        assertEquals(TypeCoercions.coerce("1", float.class), (Float)1f);
+        assertEquals(TypeCoercions.coerce("1", double.class), (Double)1d);
+        assertEquals(TypeCoercions.coerce("TRUE", boolean.class), (Boolean)true);
+        assertEquals(TypeCoercions.coerce("false", boolean.class), (Boolean)false);
+    }
+
+    @Test
+    public void testCoercePrimitivesToSameType() {
+        assertEquals(TypeCoercions.coerce('1', Character.class), (Character)'1');
+        assertEquals(TypeCoercions.coerce((short)1, Short.class), (Short)((short)1));
+        assertEquals(TypeCoercions.coerce(1, Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce(1l, Long.class), (Long)1l);
+        assertEquals(TypeCoercions.coerce(1f, Float.class), (Float)1f);
+        assertEquals(TypeCoercions.coerce(1d, Double.class), (Double)1d);
+        assertEquals(TypeCoercions.coerce(true, Boolean.class), (Boolean)true);
+    }
+    
+    @Test
+    public void testCastPrimitives() {
+        assertEquals(TypeCoercions.coerce(1L, Character.class), (Character)(char)1);
+        assertEquals(TypeCoercions.coerce(1L, Byte.class), (Byte)(byte)1);
+        assertEquals(TypeCoercions.coerce(1L, Short.class), (Short)(short)1);
+        assertEquals(TypeCoercions.coerce(1L, Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce(1L, Long.class), (Long)(long)1);
+        assertEquals(TypeCoercions.coerce(1L, Float.class), (Float)(float)1);
+        assertEquals(TypeCoercions.coerce(1L, Double.class), (Double)(double)1);
+        
+        assertEquals(TypeCoercions.coerce(1L, char.class), (Character)(char)1);
+        assertEquals(TypeCoercions.coerce(1L, byte.class), (Byte)(byte)1);
+        assertEquals(TypeCoercions.coerce(1L, short.class), (Short)(short)1);
+        assertEquals(TypeCoercions.coerce(1L, int.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce(1L, long.class), (Long)(long)1);
+        assertEquals(TypeCoercions.coerce(1L, float.class), (Float)(float)1);
+        assertEquals(TypeCoercions.coerce(1L, double.class), (Double)(double)1);
+        
+        assertEquals(TypeCoercions.coerce((char)1, Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce((byte)1, Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce((short)1, Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce((int)1, Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce((long)1, Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce((float)1, Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce((double)1, Integer.class), (Integer)1);
+    }
+    
+    @Test
+    public void testCoercePrimitiveFailures() {
+        // error messages don't have to be this exactly, but they should include sufficient information...
+        assertCoercionFailsWithErrorMatching("maybe", boolean.class, StringPredicates.containsAllLiterals("String", "boolean", "maybe"));
+        assertCoercionFailsWithErrorMatching("NaN", int.class, StringPredicates.containsAllLiterals("int", "NaN"));
+        assertCoercionFailsWithErrorMatching('c', boolean.class, StringPredicates.containsAllLiterals("boolean", "(c)"));  // will say 'string' rather than 'char'
+        assertCoercionFailsWithErrorMatching(0, boolean.class, StringPredicates.containsAllLiterals("Integer", "boolean", "0"));
+    }
+    
+    protected void assertCoercionFailsWithErrorMatching(Object input, Class<?> type, Predicate<? super String> errorMessageRequirement) {
+        try {
+            Object result = TypeCoercions.coerce(input, type);
+            Assert.fail("Should have failed type coercion of "+input+" to "+type+", instead got: "+result);
+        } catch (Exception e) {
+            if (errorMessageRequirement==null || errorMessageRequirement.apply(e.toString()))
+                log.info("Primitive coercion failed as expected, with: "+e);
+            else
+                Assert.fail("Error from type coercion of "+input+" to "+type+" failed with wrong exception; expected match of "+errorMessageRequirement+" but got: "+e);
+        }
+        
+    }
+
+    @Test
+    public void testCastToNumericPrimitives() {
+        assertEquals(TypeCoercions.coerce(BigInteger.ONE, Integer.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce(BigInteger.ONE, int.class), (Integer)1);
+        assertEquals(TypeCoercions.coerce(BigInteger.valueOf(Long.MAX_VALUE), Long.class), (Long)Long.MAX_VALUE);
+        assertEquals(TypeCoercions.coerce(BigInteger.valueOf(Long.MAX_VALUE), long.class), (Long)Long.MAX_VALUE);
+        
+        assertEquals(TypeCoercions.coerce(BigDecimal.valueOf(0.5), Double.class), 0.5d, 0.00001d);
+        assertEquals(TypeCoercions.coerce(BigDecimal.valueOf(0.5), double.class), 0.5d, 0.00001d);
+    }
+
+    @Test
+    public void testCoerceStringToBigNumber() {
+    	assertEquals(TypeCoercions.coerce("0.5", BigDecimal.class), BigDecimal.valueOf(0.5));
+    	assertEquals(TypeCoercions.coerce("1", BigInteger.class), BigInteger.valueOf(1));
+    }
+
+    @Test
+    public void testCoerceStringToEnum() {
+        assertEquals(TypeCoercions.coerce("STARTING", Lifecycle.class), Lifecycle.STARTING);
+        assertEquals(TypeCoercions.coerce("Starting", Lifecycle.class), Lifecycle.STARTING);
+        assertEquals(TypeCoercions.coerce("starting", Lifecycle.class), Lifecycle.STARTING);
+        
+        assertEquals(TypeCoercions.coerce("LOWERCASE", PerverseEnum.class), PerverseEnum.lowercase);
+        assertEquals(TypeCoercions.coerce("CAMELCASE", PerverseEnum.class), PerverseEnum.camelCase);
+        assertEquals(TypeCoercions.coerce("upper", PerverseEnum.class), PerverseEnum.UPPER);
+        assertEquals(TypeCoercions.coerce("upper_with_underscore", PerverseEnum.class), PerverseEnum.UPPER_WITH_UNDERSCORE);
+        assertEquals(TypeCoercions.coerce("LOWER_WITH_UNDERSCORE", PerverseEnum.class), PerverseEnum.lower_with_underscore);
+    }
+    public static enum PerverseEnum {
+        lowercase,
+        camelCase,
+        UPPER,
+        UPPER_WITH_UNDERSCORE,
+        lower_with_underscore;
+    }
+    
+    @Test(expectedExceptions = ClassCoercionException.class)
+    public void testCoerceStringToEnumFailure() {
+        TypeCoercions.coerce("scrambled-eggs", Lifecycle.class);
+    }
+
+    @Test
+    public void testListToSetCoercion() {
+        Set<?> s = TypeCoercions.coerce(ImmutableList.of(1), Set.class);
+        Assert.assertEquals(s, ImmutableSet.of(1));
+    }
+    
+    @Test
+    public void testSetToListCoercion() {
+        List<?> s = TypeCoercions.coerce(ImmutableSet.of(1), List.class);
+        Assert.assertEquals(s, ImmutableList.of(1));
+    }
+    
+    @Test
+    public void testIterableToArrayCoercion() {
+        String[] s = TypeCoercions.coerce(ImmutableList.of("a", "b"), String[].class);
+        Assert.assertTrue(Arrays.equals(s, new String[] {"a", "b"}), "result="+Arrays.toString(s));
+        
+        Integer[] i = TypeCoercions.coerce(ImmutableList.of(1, 2), Integer[].class);
+        Assert.assertTrue(Arrays.equals(i, new Integer[] {1, 2}), "result="+Arrays.toString(i));
+        
+        int[] i2 = TypeCoercions.coerce(ImmutableList.of(1, 2), int[].class);
+        Assert.assertTrue(Arrays.equals(i2, new int[] {1, 2}), "result="+Arrays.toString(i2));
+        
+        int[] i3 = TypeCoercions.coerce(MutableSet.of("1", 2), int[].class);
+        Assert.assertTrue(Arrays.equals(i3, new int[] {1, 2}), "result="+Arrays.toString(i3));
+    }
+
+    @Test
+    public void testListEntryCoercion() {
+        List<?> s = TypeCoercions.coerce(ImmutableList.of("java.lang.Integer", "java.lang.Double"), new TypeToken<List<Class<?>>>() { });
+        Assert.assertEquals(s, ImmutableList.of(Integer.class, Double.class));
+    }
+    
+    @Test
+    public void testListEntryToSetCoercion() {
+        Set<?> s = TypeCoercions.coerce(ImmutableList.of("java.lang.Integer", "java.lang.Double"), new TypeToken<Set<Class<?>>>() { });
+        Assert.assertEquals(s, ImmutableSet.of(Integer.class, Double.class));
+    }
+    
+    @Test
+    public void testListEntryToCollectionCoercion() {
+        Collection<?> s = TypeCoercions.coerce(ImmutableList.of("java.lang.Integer", "java.lang.Double"), new TypeToken<Collection<Class<?>>>() { });
+        Assert.assertEquals(s, ImmutableList.of(Integer.class, Double.class));
+    }
+
+    @Test
+    public void testMapValueCoercion() {
+        Map<?,?> s = TypeCoercions.coerce(ImmutableMap.of("int", "java.lang.Integer", "double", "java.lang.Double"), new TypeToken<Map<String, Class<?>>>() { });
+        Assert.assertEquals(s, ImmutableMap.of("int", Integer.class, "double", Double.class));
+    }
+    
+    @Test
+    public void testMapKeyCoercion() {
+        Map<?,?> s = TypeCoercions.coerce(ImmutableMap.of("java.lang.Integer", "int", "java.lang.Double", "double"), new TypeToken<Map<Class<?>, String>>() { });
+        Assert.assertEquals(s, ImmutableMap.of(Integer.class, "int", Double.class, "double"));
+    }
+
+    @Test
+    public void testStringToListCoercion() {
+        List<?> s = TypeCoercions.coerce("a,b,c", List.class);
+        Assert.assertEquals(s, ImmutableList.of("a", "b", "c"));
+    }
+
+    @Test
+    @SuppressWarnings("serial")
+    public void testCoerceRecursivelyStringToGenericsCollection() {
+        assertEquals(TypeCoercions.coerce("1,2", new TypeToken<List<Integer>>() {}), ImmutableList.of(1, 2));
+    }
+    
+    @Test
+    public void testJsonStringToMapCoercion() {
+        Map<?,?> s = TypeCoercions.coerce("{ \"a\" : \"1\", b : 2 }", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", "1", "b", 2));
+    }
+
+    @Test
+    public void testJsonStringWithoutQuotesToMapCoercion() {
+        Map<?,?> s = TypeCoercions.coerce("{ a : 1 }", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", 1));
+    }
+
+    @Test
+    public void testJsonComplexTypesToMapCoercion() {
+        Map<?,?> s = TypeCoercions.coerce("{ a : [1, \"2\", '\"3\"'], b: { c: d, 'e': \"f\" } }", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", ImmutableList.<Object>of(1, "2", "\"3\""), 
+            "b", ImmutableMap.of("c", "d", "e", "f")));
+    }
+
+    @Test
+    public void testJsonStringWithoutBracesToMapCoercion() {
+        Map<?,?> s = TypeCoercions.coerce("a : 1", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", 1));
+    }
+
+    @Test
+    public void testJsonStringWithoutBracesWithMultipleToMapCoercion() {
+        Map<?,?> s = TypeCoercions.coerce("a : 1, b : 2", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", 1, "b", 2));
+    }
+
+    @Test
+    public void testKeyEqualsValueStringToMapCoercion() {
+        Map<?,?> s = TypeCoercions.coerce("a=1,b=2", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", "1", "b", "2"));
+    }
+
+    @Test(expectedExceptions=IllegalArgumentException.class)
+    public void testJsonStringWithoutBracesOrSpaceDisallowedAsMapCoercion() {
+        // yaml requires spaces after the colon
+        Map<?,?> s = TypeCoercions.coerce("a:1,b:2", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", 1, "b", 2));
+    }
+    
+    @Test
+    public void testEqualsInBracesMapCoercion() {
+        Map<?,?> s = TypeCoercions.coerce("{ a = 1, b = '2' }", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", 1, "b", "2"));
+    }
+
+    @Test
+    public void testKeyEqualsOrColonValueWithBracesStringToMapCoercion() {
+        Map<?,?> s = TypeCoercions.coerce("{ a=1, b: 2 }", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", "1", "b", 2));
+    }
+
+    @Test
+    public void testKeyEqualsOrColonValueWithoutBracesStringToMapCoercion() {
+        Map<?,?> s = TypeCoercions.coerce("a=1, b: 2", Map.class);
+        Assert.assertEquals(s, ImmutableMap.of("a", "1", "b", 2));
+    }
+
+    @Test
+    public void testAs() {
+        Integer x = TypeCoercions.coerce(new WithAs("3"), Integer.class);
+        Assert.assertEquals(x, (Integer)3);
+    }
+
+    @Test
+    public void testFrom() {
+        WithFrom x = TypeCoercions.coerce("3", WithFrom.class);
+        Assert.assertEquals(x.value, 3);
+    }
+
+    @Test
+    public void testCoerceStringToNumber() {
+        assertEquals(TypeCoercions.coerce("1", Number.class), (Number) Double.valueOf(1));
+        assertEquals(TypeCoercions.coerce("1.0", Number.class), (Number) Double.valueOf(1.0));
+    }
+
+    @Test(expectedExceptions = ClassCoercionException.class)
+    public void testInvalidCoercionThrowsClassCoercionException() {
+        TypeCoercions.coerce(new Object(), TypeToken.of(Integer.class));
+    }
+
+    @Test
+    public void testCoercionFunction() {
+        assertEquals(TypeCoercions.function(Double.class).apply("1"), Double.valueOf(1));
+    }
+
+    public static class WithAs {
+        String value;
+        public WithAs(Object x) { value = ""+x; }
+        public Integer asInteger() {
+            return Integer.parseInt(value);
+        }
+    }
+
+    public static class WithFrom {
+        int value;
+        public static WithFrom fromString(String s) {
+            WithFrom result = new WithFrom();
+            result.value = Integer.parseInt(s);
+            return result;
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a4c0e5fd/core/src/test/java/org/apache/brooklyn/core/util/internal/ssh/RecordingSshTool.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/util/internal/ssh/RecordingSshTool.java b/core/src/test/java/org/apache/brooklyn/core/util/internal/ssh/RecordingSshTool.java
new file mode 100644
index 0000000..fdf3e73
--- /dev/null
+++ b/core/src/test/java/org/apache/brooklyn/core/util/internal/ssh/RecordingSshTool.java
@@ -0,0 +1,97 @@
+/*
+ * 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.brooklyn.core.util.internal.ssh;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.brooklyn.core.util.internal.ssh.SshTool;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+
+/** Mock tool */
+public class RecordingSshTool implements SshTool {
+    
+    public static class ExecCmd {
+        public final Map<String,?> props;
+        public final String summaryForLogging;
+        public final List<String> commands;
+        public final Map<?,?> env;
+        
+        ExecCmd(Map<String,?> props, String summaryForLogging, List<String> commands, Map env) {
+            this.props = props;
+            this.summaryForLogging = summaryForLogging;
+            this.commands = commands;
+            this.env = env;
+        }
+        
+        @Override
+        public String toString() {
+            return "ExecCmd["+summaryForLogging+": "+commands+"; "+props+"; "+env+"]";
+        }
+    }
+    
+    public static List<ExecCmd> execScriptCmds = Lists.newCopyOnWriteArrayList();
+    
+    private boolean connected;
+    
+    public RecordingSshTool(Map<?,?> props) {
+    }
+    @Override public void connect() {
+        connected = true;
+    }
+    @Override public void connect(int maxAttempts) {
+        connected = true;
+    }
+    @Override public void disconnect() {
+        connected = false;
+    }
+    @Override public boolean isConnected() {
+        return connected;
+    }
+    @Override public int execScript(Map<String, ?> props, List<String> commands, Map<String, ?> env) {
+        execScriptCmds.add(new ExecCmd(props, "", commands, env));
+        return 0;
+    }
+    @Override public int execScript(Map<String, ?> props, List<String> commands) {
+        return execScript(props, commands, ImmutableMap.<String,Object>of());
+    }
+    @Override public int execCommands(Map<String, ?> props, List<String> commands, Map<String, ?> env) {
+        execScriptCmds.add(new ExecCmd(props, "", commands, env));
+        return 0;
+    }
+    @Override public int execCommands(Map<String, ?> props, List<String> commands) {
+        return execCommands(props, commands, ImmutableMap.<String,Object>of());
+    }
+    @Override public int copyToServer(Map<String, ?> props, File localFile, String pathAndFileOnRemoteServer) {
+        return 0;
+    }
+    @Override public int copyToServer(Map<String, ?> props, InputStream contents, String pathAndFileOnRemoteServer) {
+        return 0;
+    }
+    @Override public int copyToServer(Map<String, ?> props, byte[] contents, String pathAndFileOnRemoteServer) {
+        return 0;
+    }
+    @Override public int copyFromServer(Map<String, ?> props, String pathAndFileOnRemoteServer, File local) {
+        return 0;
+    }
+}
\ No newline at end of file


Mime
View raw message