Moving all files to root directory

Change-Id: Ica5535fd6ec85f350fe1640b42137b49f83f10f0
Signed-off-by: Patrick Brady <pb071s@att.com>

10 files changed, 1361 insertions, 0 deletions

diff --git a/appc-common/src/test/java/org/openecomp/appc/concurrent/TestSignal.java b/appc-common/src/test/java/org/openecomp/appc/concurrent/TestSignal.java
new file mode 100644
index 000000000..1751b62d9
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/concurrent/TestSignal.java
@@ -0,0 +1,132 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.appc.concurrent;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.TimeoutException;
+
+import org.junit.Test;
+import org.openecomp.appc.concurrent.Signal;
+
+public class TestSignal {
+
+    private static final DateFormat formatter = new SimpleDateFormat("HH:mm:ss.SSS");
+    public static final String SIGNAL_READY = "READY";
+    public static final String SIGNAL_SHUTDOWN = "SHUTDOWN";
+
+    @Test
+    public void TestSimpleSignal() throws TimeoutException {
+
+        Signal mySignal = new Signal(Thread.currentThread());
+        mySignal.setTimeout(5000L);
+        Fred fred = new Fred(mySignal);
+        Thread t1 = new Thread(fred);
+
+        /*
+         * Verify that fred is dead, then start him and wait for him to signal us he is ready to proceed
+         */
+        assertFalse(t1.isAlive());
+        t1.start();
+        System.out.println(formatter.format(new Date()) + " MAIN: Waiting for Ready...");
+        mySignal.waitFor(SIGNAL_READY);
+        System.out.println(formatter.format(new Date()) + " MAIN: Signal Ready received");
+
+        /*
+         * Verify that fred is still alive and we will sleep for a while (simulate doing things)
+         */
+        assertTrue(t1.isAlive());
+        try {
+            Thread.sleep(250L);
+        } catch (InterruptedException e) {
+            // ignored
+        }
+
+        /*
+         * Verify that fred is still alive and signal him to shutdown
+         */
+        assertTrue(t1.isAlive());
+        System.out.println(formatter.format(new Date()) + " MAIN: Signaling shutdown");
+        fred.getSignal().signal(SIGNAL_SHUTDOWN);
+
+        /*
+         * Wait a little bit
+         */
+        try {
+            Thread.sleep(250L);
+        } catch (InterruptedException e) {
+            // ignored
+        }
+
+        /*
+         * Verify that fred is dead now and that he completed normally
+         */
+        System.out.println(formatter.format(new Date()) + " MAIN: Shutting down...");
+        assertFalse(t1.isAlive());
+        assertTrue(fred.isCompleted());
+    }
+
+    public class Fred implements Runnable {
+        private Signal signal;
+        private Signal parentSignal;
+        private boolean completed = false;
+
+        public Fred(Signal parentSignal) {
+            this.parentSignal = parentSignal;
+        }
+
+        @Override
+        public void run() {
+            signal = new Signal(Thread.currentThread());
+            signal.setTimeout(5000L);
+            try {
+                Thread.sleep(250L);
+            } catch (InterruptedException e) {
+                // Ignore
+            }
+
+            System.out.println(formatter.format(new Date()) + " FRED: Signaling ready...");
+            parentSignal.signal(SIGNAL_READY);
+
+            try {
+                System.out.println(formatter.format(new Date()) + " FRED: Waiting for shutdown...");
+                signal.waitFor(SIGNAL_SHUTDOWN);
+                System.out.println(formatter.format(new Date()) + " FRED: Received shutdown");
+                completed = true;
+            } catch (TimeoutException e) {
+                e.printStackTrace();
+            }
+        }
+
+        public boolean isCompleted() {
+            return completed;
+        }
+
+        public Signal getSignal() {
+            return signal;
+        }
+    }
+}
diff --git a/appc-common/src/test/java/org/openecomp/appc/encryption/TestEncryption.java b/appc-common/src/test/java/org/openecomp/appc/encryption/TestEncryption.java
new file mode 100644
index 000000000..e82a44352
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/encryption/TestEncryption.java
@@ -0,0 +1,43 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.appc.encryption;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+import org.junit.Test;
+import org.openecomp.appc.encryption.EncryptionTool;
+
+public class TestEncryption {
+
+    @Test
+    public void testEncryptionDecryption() {
+        String plain = "AppC";
+        String enc = EncryptionTool.getInstance().encrypt(plain);
+        assertNotEquals(plain, enc);
+        String dec = EncryptionTool.getInstance().decrypt(enc);
+        assertNotEquals(enc, dec);
+        assertEquals(plain, dec);
+        System.out.println(String.format("%s = [%s]", plain, enc));
+    }
+
+}
diff --git a/appc-common/src/test/java/org/openecomp/appc/pool/CachedElementTest.java b/appc-common/src/test/java/org/openecomp/appc/pool/CachedElementTest.java
new file mode 100644
index 000000000..423d33952
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/pool/CachedElementTest.java
@@ -0,0 +1,273 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+
+
+package org.openecomp.appc.pool;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.openecomp.appc.pool.Allocator;
+import org.openecomp.appc.pool.CachedElement;
+import org.openecomp.appc.pool.Destructor;
+import org.openecomp.appc.pool.Pool;
+import org.openecomp.appc.pool.PoolDrainedException;
+import org.openecomp.appc.pool.PoolExtensionException;
+import org.openecomp.appc.pool.PoolSpecificationException;
+import org.openecomp.appc.pool.*;
+
+
+public class CachedElementTest implements Allocator<Testable>, Destructor<Testable> {
+    private static final int MIN = 10;
+    private static final int MAX = 100;
+    private Pool<Testable> pool;
+    private int index = 0;
+    private int destroyCount = 0;
+
+    /**
+     * setup
+     *
+     * @throws PoolSpecificationException
+     *             If the minimum size is less than 0, or if the max size is non-zero and less than the min size.
+     */
+    @Before
+    public void setup() throws PoolSpecificationException {
+        pool = new Pool<>(MIN, MAX);
+    }
+
+    /**
+     * Test state
+     */
+    @Test
+    public void testAllocator() {
+        assertNull(pool.getAllocator());
+        pool.setAllocator(this);
+        assertNotNull(pool.getAllocator());
+    }
+
+    /**
+     * Test state
+     */
+    @Test
+    public void testDestructor() {
+        assertNull(pool.getDestructor());
+        pool.setDestructor(this);
+        assertNotNull(pool.getDestructor());
+    }
+
+    /**
+     * Test that we can allocate and release elements and that the pool maintains them in MRU order
+     *
+     * @throws PoolExtensionException
+     *             If the pool cannot be extended
+     * @throws PoolDrainedException
+     *             If the caller is trying to reserve an element from a drained pool
+     */
+    @Test
+    public void testAllocateAndRelease() throws PoolExtensionException, PoolDrainedException {
+        pool.setAllocator(this);
+
+        assertFalse(pool.isDrained());
+
+        /*
+         * Allocate three elements
+         */
+        Testable value1 = pool.reserve();
+        assertNotNull(value1);
+        assertEquals(Integer.valueOf(MIN - 1), Integer.valueOf(value1.getId()));
+        assertEquals(1, pool.getAllocatedSize());
+        assertEquals(MIN - 1, pool.getFreeSize());
+        assertEquals(1, pool.getAllocatedSize());
+
+        Testable value2 = pool.reserve();
+        assertNotNull(value2);
+        assertEquals(Integer.valueOf(MIN - 2), Integer.valueOf(value2.getId()));
+        assertEquals(2, pool.getAllocatedSize());
+        assertEquals(MIN - 2, pool.getFreeSize());
+        assertEquals(2, pool.getAllocatedSize());
+
+        Testable value3 = pool.reserve();
+        assertNotNull(value3);
+        assertEquals(Integer.valueOf(MIN - 3), Integer.valueOf(value3.getId()));
+        assertEquals(3, pool.getAllocatedSize());
+        assertEquals(MIN - 3, pool.getFreeSize());
+        assertEquals(3, pool.getAllocatedSize());
+
+        /*
+         * Now, release them in the order obtained
+         */
+        pool.release(value1);
+        pool.release(value2);
+        pool.release(value3);
+
+        assertEquals(0, pool.getAllocatedSize());
+        assertEquals(MIN, pool.getFreeSize());
+
+        /*
+         * Now, allocate them again, but their values should be reversed (3, 2, 1) representing the most recently used
+         * to the least recently used.
+         */
+        value1 = pool.reserve();
+        assertNotNull(value1);
+        assertEquals(Integer.valueOf(MIN - 3), Integer.valueOf(value1.getId()));
+
+        value2 = pool.reserve();
+        assertNotNull(value2);
+        assertEquals(Integer.valueOf(MIN - 2), Integer.valueOf(value2.getId()));
+
+        value3 = pool.reserve();
+        assertNotNull(value3);
+        assertEquals(Integer.valueOf(MIN - 1), Integer.valueOf(value3.getId()));
+    }
+
+    /**
+     * Test that we can trim the pool to a desired size
+     *
+     * @throws PoolDrainedException
+     *             If the caller is trying to release or reserve an element from a drained pool
+     * @throws PoolExtensionException
+     *             If the pool cannot be extended
+     * @throws IllegalAccessException
+     *             if this Method object is enforcing Java language access control and the underlying method is
+     *             inaccessible.
+     * @throws IllegalArgumentException
+     *             if the method is an instance method and the specified object argument is not an instance of the class
+     *             or interface declaring the underlying method (or of a subclass or implementor thereof); if the number
+     *             of actual and formal parameters differ; if an unwrapping conversion for primitive arguments fails; or
+     *             if, after possible unwrapping, a parameter value cannot be converted to the corresponding formal
+     *             parameter type by a method invocation conversion.
+     * @throws InvocationTargetException
+     *             if the underlying method throws an exception.
+     * @throws SecurityException
+     *             If a security manager, s, is present and any of the following conditions is met:
+     *             <ul>
+     *             <li>invocation of s.checkMemberAccess(this, Member.DECLARED) denies access to the declared method</li>
+     *             <li>the caller's class loader is not the same as or an ancestor of the class loader for the current
+     *             class and invocation of s.checkPackageAccess() denies access to the package of this class</li>
+     *             </ul>
+     * @throws NoSuchMethodException
+     *             if a matching method is not found.
+     */
+    @SuppressWarnings("nls")
+    @Test
+    public void testTrim() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException,
+        PoolDrainedException, PoolExtensionException, NoSuchMethodException, SecurityException {
+
+        pool.setAllocator(this);
+        int SIZE = 50;
+        Testable[] array = new Testable[SIZE];
+
+        assertEquals(0, pool.getAllocatedSize());
+        for (int i = 0; i < SIZE; i++) {
+            array[i] = pool.reserve();
+        }
+        assertEquals(SIZE, pool.getAllocatedSize());
+
+        for (int i = 0; i < SIZE; i++) {
+            pool.release(array[i]);
+        }
+        assertEquals(0, pool.getAllocatedSize());
+
+        assertEquals(SIZE, pool.getFreeSize());
+
+        Method trimMethod = Pool.class.getDeclaredMethod("trim", new Class[] {
+            Integer.TYPE
+        });
+        trimMethod.setAccessible(true);
+        trimMethod.invoke(pool, new Object[] {
+            SIZE - MIN
+        });
+
+        assertEquals(MIN, pool.getFreeSize());
+    }
+
+    /**
+     * Test that we can drain a pool containing a mix of free and allocated elements
+     *
+     * @throws PoolDrainedException
+     *             If the caller is trying to release or reserve an element from a drained pool
+     * @throws PoolExtensionException
+     *             If the pool cannot be extended
+     * @throws IOException
+     *             if an I/O error occurs
+     */
+    @Test
+    public void testDrain() throws PoolExtensionException, PoolDrainedException, IOException {
+        int SIZE = 50;
+        int FREE = 20;
+        int ALLOC = SIZE - FREE;
+
+        Testable[] array = new Testable[SIZE];
+        pool.setAllocator(this);
+        pool.setDestructor(this);
+
+        assertFalse(pool.isDrained());
+
+        assertEquals(0, pool.getAllocatedSize());
+        for (int i = 0; i < SIZE; i++) {
+            array[i] = pool.reserve();
+        }
+        assertEquals(SIZE, pool.getAllocatedSize());
+
+        for (int i = 0; i < FREE; i++) {
+            array[i].close();
+        }
+        assertEquals(ALLOC, pool.getAllocatedSize());
+        assertEquals(FREE, pool.getFreeSize());
+
+        pool.drain();
+        assertEquals(0, pool.getFreeSize());
+        assertEquals(0, pool.getAllocatedSize());
+        assertTrue(pool.isDrained());
+
+        assertEquals(SIZE, destroyCount);
+    }
+
+    /**
+     * @see org.openecomp.appc.pool.Allocator#allocate(org.openecomp.appc.pool.Pool)
+     */
+    @Override
+    public Testable allocate(Pool<Testable> pool) {
+        Testable element = new Element(index++);
+        Testable ce = CachedElement.newInstance(pool, element, new Class[] {
+            Testable.class
+        });
+        return ce;
+    }
+
+    /**
+     * @see org.openecomp.appc.pool.Destructor#destroy(java.io.Closeable, org.openecomp.appc.pool.Pool)
+     */
+    @Override
+    public void destroy(Testable obj, Pool<Testable> pool) {
+        destroyCount++;
+    }
+}
diff --git a/appc-common/src/test/java/org/openecomp/appc/pool/Element.java b/appc-common/src/test/java/org/openecomp/appc/pool/Element.java
new file mode 100644
index 000000000..61c302432
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/pool/Element.java
@@ -0,0 +1,75 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+
+
+package org.openecomp.appc.pool;
+
+import java.io.IOException;
+
+public class Element implements Testable {
+    private boolean closed;
+    private Integer id;
+
+    public Element(int id) {
+        this.id = Integer.valueOf(id);
+        closed = false;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        boolean result = false;
+        if (obj instanceof Element) {
+            Element other = (Element) obj;
+            result = this.id.equals(other.id);
+        }
+
+        return result;
+    }
+
+    @Override
+    public int hashCode() {
+        return id.hashCode();
+    }
+
+    /**
+     * @see java.io.Closeable#close()
+     */
+    @Override
+    public void close() throws IOException {
+        closed = true;
+    }
+
+    @Override
+    public Boolean isClosed() {
+        return Boolean.valueOf(closed);
+    }
+
+    @Override
+    public String toString() {
+        return Integer.toString(id);
+    }
+
+    @Override
+    public Integer getId() {
+        return id;
+    }
+}
diff --git a/appc-common/src/test/java/org/openecomp/appc/pool/PoolTest.java b/appc-common/src/test/java/org/openecomp/appc/pool/PoolTest.java
new file mode 100644
index 000000000..97414804c
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/pool/PoolTest.java
@@ -0,0 +1,320 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+
+
+package org.openecomp.appc.pool;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.openecomp.appc.pool.Allocator;
+import org.openecomp.appc.pool.Destructor;
+import org.openecomp.appc.pool.Pool;
+import org.openecomp.appc.pool.PoolDrainedException;
+import org.openecomp.appc.pool.PoolExtensionException;
+import org.openecomp.appc.pool.PoolSpecificationException;
+import org.openecomp.appc.pool.*;
+
+
+public class PoolTest implements Allocator<Testable>, Destructor<Testable> {
+
+    private Pool<Testable> pool;
+    private static final int MIN = 10;
+    private static final int MAX = 100;
+    private int index = 0;
+    private int destroyCount = 0;
+
+    /**
+     * Set up the test by allocating a pool with MIN-MAX size (bounded pool)
+     *
+     * @throws PoolSpecificationException
+     *             If the minimum size is less than 0, or if the max size is non-zero and less than the min size.
+     */
+    @Before
+    public void setup() throws PoolSpecificationException {
+        pool = new Pool<>(MIN, MAX);
+        index = 0;
+        destroyCount = 0;
+    }
+
+    /**
+     * Test that trying to construct a pool with a bad minimum throws an exception
+     *
+     * @throws PoolSpecificationException
+     *             If the minimum size is less than 0, or if the max size is non-zero and less than the min size.
+     */
+    @Test(expected = PoolSpecificationException.class)
+    public void testInvalidMinSize() throws PoolSpecificationException {
+        pool = new Pool<>(-1, MAX);
+    }
+
+    /**
+     * Test that trying to construct a pool with a bad maximum throws an exception
+     *
+     * @throws PoolSpecificationException
+     *             If the minimum size is less than 0, or if the max size is non-zero and less than the min size.
+     */
+    @Test(expected = PoolSpecificationException.class)
+    public void testInvalidMaxSize() throws PoolSpecificationException {
+        pool = new Pool<>(MIN, -1);
+    }
+
+    /**
+     * Test creation of a pool where max is less than min fails
+     *
+     * @throws PoolSpecificationException
+     *             If the minimum size is less than 0, or if the max size is non-zero and less than the min size.
+     */
+    @Test(expected = PoolSpecificationException.class)
+    public void testInvalidSizeRange() throws PoolSpecificationException {
+        pool = new Pool<>(MAX, MIN);
+    }
+
+    /**
+     * Test state
+     */
+    @Test
+    public void testMinPool() {
+        assertEquals(MIN, pool.getMinPool());
+    }
+
+    /**
+     * Test state
+     */
+    @Test
+    public void testMaxPool() {
+        assertEquals(MAX, pool.getMaxPool());
+    }
+
+    /**
+     * Test state
+     */
+    @Test
+    public void testAllocator() {
+        assertNull(pool.getAllocator());
+        pool.setAllocator(this);
+        assertNotNull(pool.getAllocator());
+    }
+
+    /**
+     * Test state
+     */
+    @Test
+    public void testDestructor() {
+        assertNull(pool.getDestructor());
+        pool.setDestructor(this);
+        assertNotNull(pool.getDestructor());
+    }
+
+    /**
+     * Test that we can allocate and release elements and that the pool maintains them in MRU order
+     *
+     * @throws PoolExtensionException
+     *             If the pool cannot be extended
+     * @throws PoolDrainedException
+     *             If the caller is trying to reserve an element from a drained pool
+     */
+    @Test
+    public void testAllocateAndRelease() throws PoolExtensionException, PoolDrainedException {
+        pool.setAllocator(this);
+
+        assertFalse(pool.isDrained());
+
+        /*
+         * Allocate three elements
+         */
+        Testable value1 = pool.reserve();
+        assertNotNull(value1);
+        assertEquals(Integer.valueOf(MIN - 1), value1.getId());
+        assertEquals(1, pool.getAllocatedSize());
+        assertEquals(MIN - 1, pool.getFreeSize());
+        assertEquals(1, pool.getAllocatedSize());
+
+        Testable value2 = pool.reserve();
+        assertNotNull(value2);
+        assertEquals(Integer.valueOf(MIN - 2), value2.getId());
+        assertEquals(2, pool.getAllocatedSize());
+        assertEquals(MIN - 2, pool.getFreeSize());
+        assertEquals(2, pool.getAllocatedSize());
+
+        Testable value3 = pool.reserve();
+        assertNotNull(value3);
+        assertEquals(Integer.valueOf(MIN - 3), value3.getId());
+        assertEquals(3, pool.getAllocatedSize());
+        assertEquals(MIN - 3, pool.getFreeSize());
+        assertEquals(3, pool.getAllocatedSize());
+
+        /*
+         * Now, release them in the order obtained
+         */
+        pool.release(value1);
+        pool.release(value2);
+        pool.release(value3);
+
+        assertEquals(0, pool.getAllocatedSize());
+        assertEquals(MIN, pool.getFreeSize());
+
+        /*
+         * Now, allocate them again, but their values should be reversed (3, 2, 1) representing the most recently used
+         * to the least recently used.
+         */
+        value1 = pool.reserve();
+        assertNotNull(value1);
+        assertEquals(Integer.valueOf(MIN - 3), value1.getId());
+
+        value2 = pool.reserve();
+        assertNotNull(value2);
+        assertEquals(Integer.valueOf(MIN - 2), value2.getId());
+
+        value3 = pool.reserve();
+        assertNotNull(value3);
+        assertEquals(Integer.valueOf(MIN - 1), value3.getId());
+    }
+
+    /**
+     * Test that we can trim the pool to a desired size
+     *
+     * @throws PoolExtensionException
+     *             If the pool cannot be extended
+     * @throws NoSuchMethodException
+     *             if a matching method is not found.
+     * @throws SecurityException
+     *             if the request is denied.
+     * @throws IllegalAccessException
+     *             if this Method object is enforcing Java language access control and the underlying method is
+     *             inaccessible.
+     * @throws IllegalArgumentException
+     *             if the method is an instance method and the specified object argument is not an instance of the class
+     *             or interface declaring the underlying method (or of a subclass or implementor thereof); if the number
+     *             of actual and formal parameters differ; if an unwrapping conversion for primitive arguments fails; or
+     *             if, after possible unwrapping, a parameter value cannot be converted to the corresponding formal
+     *             parameter type by a method invocation conversion.
+     * @throws InvocationTargetException
+     *             if the underlying method throws an exception.
+     * @throws PoolDrainedException
+     *             If the caller is trying to reserve an element from a drained pool
+     */
+    @SuppressWarnings("nls")
+    @Test
+    public void testTrim() throws PoolExtensionException, NoSuchMethodException, SecurityException,
+        IllegalAccessException, IllegalArgumentException, InvocationTargetException, PoolDrainedException {
+        pool.setAllocator(this);
+        int SIZE = 50;
+        Proxy[] array = new Proxy[SIZE];
+
+        assertEquals(0, pool.getAllocatedSize());
+        for (int i = 0; i < SIZE; i++) {
+            array[i] = (Proxy) pool.reserve();
+        }
+        assertEquals(SIZE, pool.getAllocatedSize());
+
+        for (int i = 0; i < SIZE; i++) {
+            pool.release((Testable) array[i]);
+        }
+        assertEquals(0, pool.getAllocatedSize());
+
+        assertEquals(SIZE, pool.getFreeSize());
+
+        Method trimMethod = Pool.class.getDeclaredMethod("trim", new Class[] {
+            Integer.TYPE
+        });
+        trimMethod.setAccessible(true);
+        trimMethod.invoke(pool, new Object[] {
+            SIZE - MIN
+        });
+
+        assertEquals(MIN, pool.getFreeSize());
+    }
+
+    /**
+     * Test that we can drain a pool containing a mix of free and allocated elements
+     *
+     * @throws PoolExtensionException
+     *             If the pool cannot be extended
+     * @throws PoolDrainedException
+     *             If the caller is trying to reserve an element from a drained pool
+     */
+    @Test
+    public void testDrain() throws PoolExtensionException, PoolDrainedException {
+        int SIZE = 50;
+        int FREE = 20;
+        int ALLOC = SIZE - FREE;
+
+        Proxy[] array = new Proxy[SIZE];
+        pool.setAllocator(this);
+        pool.setDestructor(this);
+
+        assertFalse(pool.isDrained());
+
+        assertEquals(0, pool.getAllocatedSize());
+        for (int i = 0; i < SIZE; i++) {
+            array[i] = (Proxy) pool.reserve();
+        }
+        assertEquals(SIZE, pool.getAllocatedSize());
+
+        for (int i = 0; i < FREE; i++) {
+            pool.release((Testable) array[i]);
+        }
+        assertEquals(ALLOC, pool.getAllocatedSize());
+        assertEquals(FREE, pool.getFreeSize());
+
+        pool.drain();
+        assertEquals(0, pool.getFreeSize());
+        assertEquals(0, pool.getAllocatedSize());
+        assertTrue(pool.isDrained());
+
+        assertEquals(SIZE, destroyCount);
+    }
+
+    /**
+     * @see org.openecomp.appc.pool.Destructor#destroy(java.io.Closeable, org.openecomp.appc.pool.Pool)
+     */
+    @Override
+    public void destroy(Testable obj, Pool<Testable> pool) {
+        destroyCount++;
+        try {
+            obj.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * @see org.openecomp.appc.pool.Allocator#allocate(org.openecomp.appc.pool.Pool)
+     */
+    @Override
+    public Testable allocate(Pool<Testable> pool) {
+        Testable e = new Element(index++);
+
+        return e;
+    }
+}
diff --git a/appc-common/src/test/java/org/openecomp/appc/pool/Testable.java b/appc-common/src/test/java/org/openecomp/appc/pool/Testable.java
new file mode 100644
index 000000000..61adf91d3
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/pool/Testable.java
@@ -0,0 +1,32 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.appc.pool;
+
+import java.io.Closeable;
+
+public interface Testable extends Closeable {
+
+    Integer getId();
+
+    Boolean isClosed();
+}
+
diff --git a/appc-common/src/test/java/org/openecomp/appc/util/TestJsonUtil.java b/appc-common/src/test/java/org/openecomp/appc/util/TestJsonUtil.java
new file mode 100644
index 000000000..d78049e12
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/util/TestJsonUtil.java
@@ -0,0 +1,71 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.appc.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.openecomp.appc.util.JsonUtil;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import static org.junit.Assert.*;
+
+
+
+public class TestJsonUtil {
+
+    @Test
+    public void testConvertJsonStringToFlatMap() {
+        try {
+            String jsonString = "{\"A\":\"A-value\",\"B\":{\"C\":\"B.C-value\",\"D\":\"B.D-value\"}}";
+            Map<String, String> flatMap = JsonUtil.convertJsonStringToFlatMap(jsonString);
+            assertNotNull(flatMap);
+            Map<String, String> expectedMap = new HashMap<>();
+            expectedMap.put("A","A-value");
+            expectedMap.put("B.C","B.C-value");
+            expectedMap.put("B.D","B.D-value");
+            assertEquals(expectedMap,flatMap);
+        } catch (IOException e) {
+            e.printStackTrace();
+            Assert.fail(e.toString());
+        }
+    }
+
+    @Test
+    public void testConvertJsonStringToFlatMapWithInnerJson() {
+        try {
+            String jsonString = "{\"A\":\"A-value\",\"B\":\"{\\\"C\\\":\\\"C-value\\\",\\\"D\\\":\\\"D-value\\\"}\"}";
+            Map<String, String> flatMap = JsonUtil.convertJsonStringToFlatMap(jsonString);
+            assertNotNull(flatMap);
+            Map<String, String> expectedMap = new HashMap<>();
+            expectedMap.put("A","A-value");
+            expectedMap.put("B","{\"C\":\"C-value\",\"D\":\"D-value\"}");
+            assertEquals(expectedMap,flatMap);
+        } catch (IOException e) {
+            e.printStackTrace();
+            Assert.fail(e.toString());
+        }
+    }
+}
diff --git a/appc-common/src/test/java/org/openecomp/appc/util/TestStreamHelper.java b/appc-common/src/test/java/org/openecomp/appc/util/TestStreamHelper.java
new file mode 100644
index 000000000..d0b93a3c1
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/util/TestStreamHelper.java
@@ -0,0 +1,78 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.appc.util;
+
+import static org.junit.Assert.*;
+
+import java.io.ByteArrayInputStream;
+
+import org.junit.Test;
+import org.openecomp.appc.util.StreamHelper;
+
+public class TestStreamHelper {
+
+    private static final String text = "Filler text (also placeholder text or dummy text) is text that shares "
+        + "some characteristics of a real written text, but is random or otherwise generated. It may be used "
+        + "to display a sample of fonts, generate text for testing, or to spoof an e-mail spam filter. The "
+        + "process of using filler text is sometimes called greeking, although the text itself may be nonsense, "
+        + "or largely Latin, as in Lorem ipsum.\nASDF is the sequence of letters that appear on the first four "
+        + "keys on the home row of a QWERTY or QWERTZ keyboard. They are often used as a sample or test case "
+        + "or as random, meaningless nonsense. It is also a common learning tool for keyboard classes, since "
+        + "all four keys are located on Home row.\nETAOIN SHRDLU is the approximate order of frequency of the "
+        + "twelve most commonly used letters in the English language, best known as a nonsense phrase that "
+        + "sometimes appeared in print in the days of \"hot type\" publishing due to a custom of Linotype "
+        + "machine operators.\nLorem ipsum... is one of the most common filler texts, popular with "
+        + "typesetters and graphic designers. \"Li Europan lingues...\" is another similar example.\n"
+        + "Now is the time for all good men to come to the aid of the party\" is a phrase first proposed "
+        + "as a typing drill by instructor Charles E. Weller; its use is recounted in his book The Early "
+        + "History of the Typewriter, p. 21 (1918).[1] Frank E. McGurrin, an expert on the early Remington "
+        + "typewriter, used it in demonstrating his touch typing abilities in January 1889.[2] It has "
+        + "appeared in a number of typing books, often in the form \"Now is the time for all good men to "
+        + "come to the aid of their country.\"\nThe quick brown fox jumps over the lazy dog - A coherent, "
+        + "short phrase that uses every letter of the alphabet. See pangram for more examples.\nNew Petitions"
+        + " and Building Code - Many B movies of the 1940s, 50s, and 60s utilized the \"spinning newspaper\" "
+        + "effect to narrate important plot points that occurred offscreen. The effect necessitated the "
+        + "appearance of a realistic front page, which consisted of a main headline relevant to the plot, "
+        + "and several smaller headlines used as filler. A large number of these spinning newspapers "
+        + "included stories titled \"New Petitions Against Tax\" and \"Building Code Under Fire.\" These "
+        + "phrases have become running jokes among B movie fans, and particularly fans of Mystery "
+        + "Science Theater 3000. \nCharacter Generator Protocol - The Character Generator Protocol "
+        + "(CHARGEN) service is an Internet protocol intended for testing, debugging, and measurement "
+        + "purposes.\n!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefgh\n\""
+        + "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghi\n"
+        + "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghij\n"
+        + "$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijk\n";
+
+    @Test
+    public void testStreamHelperNullStream() {
+        assertNotNull(StreamHelper.getStringFromInputStream(null));
+        assertEquals("", StreamHelper.getStringFromInputStream(null));
+    }
+
+    @Test
+    public void testStreamHelperByteArrayStream() {
+        ByteArrayInputStream in = new ByteArrayInputStream(text.getBytes());
+
+        assertEquals(text, StreamHelper.getStringFromInputStream(in));
+    }
+
+}
diff --git a/appc-common/src/test/java/org/openecomp/appc/util/TestStringHelper.java b/appc-common/src/test/java/org/openecomp/appc/util/TestStringHelper.java
new file mode 100644
index 000000000..0afd4cb43
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/util/TestStringHelper.java
@@ -0,0 +1,104 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+
+
+package org.openecomp.appc.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Properties;
+
+import org.junit.Test;
+import org.openecomp.appc.util.StringHelper;
+
+
+public class TestStringHelper {
+
+    @Test
+    public void testAsListWithNullList() {
+        String value = StringHelper.asList((String[]) null);
+        assertNotNull(value);
+        assertEquals("[]", value);
+    }
+
+    @Test
+    public void testAsListWithEmptyList() {
+        String value = StringHelper.asList(new String[] {});
+        assertNotNull(value);
+        assertEquals("[]", value);
+    }
+
+    @Test
+    public void testAsListWithSingleValue() {
+        String value = StringHelper.asList("one");
+        assertNotNull(value);
+        assertEquals("[one]", value);
+    }
+
+    @Test
+    public void testAsListWithTwoValues() {
+        String value = StringHelper.asList("one", "two");
+        assertNotNull(value);
+        assertEquals("[one,two]", value);
+    }
+
+    @Test
+    public void testAsListWithFiveValues() {
+        String value = StringHelper.asList("one", "two", "three", "four", "five");
+        assertNotNull(value);
+        assertEquals("[one,two,three,four,five]", value);
+    }
+
+    @Test
+    public void testPropertiesToString() {
+        String key1 = "key1";
+        String val1 = "val1";
+        String key2 = "key2";
+        String val2 = "val2";
+
+        assertEquals(null, StringHelper.propertiesToString(null));
+
+        Properties props = new Properties();
+
+        String result = StringHelper.propertiesToString(props);
+        assertNotNull(result);
+        assertEquals("[ ]", result);
+
+        props.setProperty(key1, val1);
+        result = StringHelper.propertiesToString(props);
+        assertNotNull(result);
+        assertTrue(result.contains(key1));
+        assertTrue(result.contains(val1));
+        assertTrue(result.lastIndexOf(",") < result.length() - 3); // No trailing comma
+
+        props.setProperty(key2, val2);
+        result = StringHelper.propertiesToString(props);
+        assertNotNull(result);
+        assertTrue(result.contains(key1));
+        assertTrue(result.contains(val1));
+        assertTrue(result.contains(key2));
+        assertTrue(result.contains(val2));
+        assertTrue(result.lastIndexOf(",") < result.length() - 3); // No trailing comma
+    }
+}
diff --git a/appc-common/src/test/java/org/openecomp/appc/util/TestStructuredPropertyHelper.java b/appc-common/src/test/java/org/openecomp/appc/util/TestStructuredPropertyHelper.java
new file mode 100644
index 000000000..35541277f
--- /dev/null
+++ b/appc-common/src/test/java/org/openecomp/appc/util/TestStructuredPropertyHelper.java
@@ -0,0 +1,233 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * openECOMP : APP-C
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights
+ * 						reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.appc.util;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.openecomp.appc.util.StructuredPropertyHelper;
+import org.openecomp.appc.util.StructuredPropertyHelper.Node;
+
+/**
+ * This class is used to test the structured property helper class.
+ * <p>
+ * A structured property is one where the name is constructed from a compound set of elements, concatenated by a period,
+ * and optionally being enumerated using a sequence number suffix. A java package name is an example of a structured
+ * name, where each element of the name represents a directory or name in the namespace hierarchy. Property names may
+ * also be structured. This class constructs a graph of the structured properties and this test case is used to verify
+ * its operation.
+ * </p>
+ *
+ */
+public class TestStructuredPropertyHelper {
+
+    /**
+     * The properties to be parsed
+     */
+    private Properties properties;
+
+    /**
+     * The result of parsing the properties
+     */
+    private List<Node> nodes = new ArrayList<>();
+
+    /**
+     * Initialize the test environment
+     */
+    @SuppressWarnings("nls")
+    @Before
+    public void setup() {
+        nodes.clear();
+
+        properties = new Properties();
+
+        properties.setProperty("provider1.name", "provider1Name");
+        properties.setProperty("provider1.type", "provider1type");
+        properties.setProperty("provider1.URL", "provider1URL");
+        properties.setProperty("provider2.name", "provider2Name");
+        properties.setProperty("provider2.type", "provider2type");
+        properties.setProperty("provider2.URL", "provider2URL");
+        properties.setProperty("provider003.name", "provider3Name");
+        properties.setProperty("provider003.type", "provider3type");
+        properties.setProperty("provider003.URL", "provider3URL");
+
+        properties.setProperty("node1.level1.value1.key", "1.1.1");
+        properties.setProperty("node1.level1.value2.key", "1.1.2");
+        properties.setProperty("node1.level1.value3.key", "1.1.3");
+        properties.setProperty("node1.level2.value1.key", "1.2.1");
+        properties.setProperty("node1.level2.value2.key", "1.2.2");
+        properties.setProperty("node1.level2.value3.key", "1.2.3");
+        properties.setProperty("node1.level3.value1.key", "1.3.1");
+        properties.setProperty("node1.level3.value2.key", "1.3.2");
+        properties.setProperty("node1.level3.value3.key", "1.3.3");
+        properties.setProperty("node2.level1.value1.key", "2.1.1");
+        properties.setProperty("node2.level1.value2.key", "2.1.2");
+        properties.setProperty("node2.level1.value3.key", "2.1.3");
+        properties.setProperty("node2.level2.value1.key", "2.2.1");
+        properties.setProperty("node2.level2.value2.key", "2.2.2");
+        properties.setProperty("node2.level2.value3.key", "2.2.3");
+        properties.setProperty("node2.level3.value1.key", "2.3.1");
+        properties.setProperty("node2.level3.value2.key", "2.3.2");
+        properties.setProperty("node2.level3.value3.key", "2.3.3");
+        properties.setProperty("node3.level1.value1.key", "3.1.1");
+        properties.setProperty("node3.level1.value2.key", "3.1.2");
+        properties.setProperty("node3.level1.value3.key", "3.1.3");
+        properties.setProperty("node3.level2.value1.key", "3.2.1");
+        properties.setProperty("node3.level2.value2.key", "3.2.2");
+        properties.setProperty("node3.level2.value3.key", "3.2.3");
+        properties.setProperty("node3.level3.value1.key", "3.3.1");
+        properties.setProperty("node3.level3.value2.key", "3.3.2");
+        properties.setProperty("node3.level3.value3.key", "3.3.3");
+
+        properties.setProperty("other.property", "bogus");
+        properties.setProperty("yet.another.property", "bogus");
+        properties.setProperty("simpleProperty", "bogus");
+
+    }
+
+    /**
+     * Test that a simple namespace works
+     */
+    @SuppressWarnings("nls")
+    @Test
+    public void testSimpleNamespace() {
+        nodes = StructuredPropertyHelper.getStructuredProperties(properties, "provider");
+
+        assertNotNull(nodes);
+        assertFalse(nodes.isEmpty());
+
+        assertEquals(3, nodes.size());
+
+        List<Node> children;
+        for (Node node : nodes) {
+            switch (node.getName()) {
+                case "provider1":
+                    assertNull(node.getValue());
+                    children = node.getChildren();
+                    assertNotNull(children);
+                    assertEquals(3, children.size());
+                    for (Node child : children) {
+                        switch (child.getName()) {
+                            case "URL":
+                                assertEquals("provider1URL", child.getValue());
+                                break;
+                            case "type":
+                                assertEquals("provider1type", child.getValue());
+                                break;
+                            case "name":
+                                assertEquals("provider1Name", child.getValue());
+                                break;
+                            default:
+                                fail("Unknown child of " + node.getName() + " with value " + child.toString());
+                        }
+                    }
+                    break;
+                case "provider2":
+                    assertNull(node.getValue());
+                    children = node.getChildren();
+                    assertNotNull(children);
+                    assertEquals(3, children.size());
+                    for (Node child : children) {
+                        switch (child.getName()) {
+                            case "URL":
+                                assertEquals("provider2URL", child.getValue());
+                                break;
+                            case "type":
+                                assertEquals("provider2type", child.getValue());
+                                break;
+                            case "name":
+                                assertEquals("provider2Name", child.getValue());
+                                break;
+                            default:
+                                fail("Unknown child of " + node.getName() + " with value " + child.toString());
+                        }
+                    }
+                    break;
+                case "provider3":
+                    /*
+                     * Note that the helper normalizes any ordinal suffixes (003 became 3)
+                     */
+                    assertNull(node.getValue());
+                    children = node.getChildren();
+                    assertNotNull(children);
+                    assertEquals(3, children.size());
+                    for (Node child : children) {
+                        switch (child.getName()) {
+                            case "URL":
+                                assertEquals("provider3URL", child.getValue());
+                                break;
+                            case "type":
+                                assertEquals("provider3type", child.getValue());
+                                break;
+                            case "name":
+                                assertEquals("provider3Name", child.getValue());
+                                break;
+                            default:
+                                fail("Unknown child of " + node.getName() + " with value " + child.toString());
+                        }
+                    }
+                    break;
+                default:
+                    fail("Unknown provider " + node.toString());
+            }
+        }
+        // System.out.println(nodes);
+    }
+
+    /**
+     * Test a multi-dimensional namespace (3X3X3)
+     */
+    @SuppressWarnings("nls")
+    @Test
+    public void testMultiLevelNamespace() {
+        nodes = StructuredPropertyHelper.getStructuredProperties(properties, "node");
+
+        assertNotNull(nodes);
+        assertFalse(nodes.isEmpty());
+
+        assertEquals(3, nodes.size());
+        for (Node node : nodes) {
+            assertNull(node.getValue());
+            List<Node> children = node.getChildren();
+            assertNotNull(children);
+            assertEquals(3, children.size());
+            for (Node child : children) {
+                assertNull(child.getValue());
+                List<Node> grandChildren = child.getChildren();
+                assertNotNull(grandChildren);
+                assertEquals(3, grandChildren.size());
+                for (Node greatGrandChild : grandChildren) {
+                    assertNull(greatGrandChild.getValue());
+                    List<Node> greatGrandChildren = greatGrandChild.getChildren();
+                    assertNotNull(greatGrandChildren);
+                    assertEquals(1, greatGrandChildren.size());
+                }
+            }
+        }
+        // System.out.println(nodes);
+    }
+}