summaryrefslogtreecommitdiffstats
path: root/appc-common/src/test/java
diff options
context:
space:
mode:
Diffstat (limited to 'appc-common/src/test/java')
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/concurrent/TestSignal.java132
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/encryption/TestEncryption.java43
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/pool/CachedElementTest.java273
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/pool/Element.java75
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/pool/PoolTest.java320
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/pool/Testable.java32
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/util/TestJsonUtil.java71
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/util/TestStreamHelper.java78
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/util/TestStringHelper.java104
-rw-r--r--appc-common/src/test/java/org/openecomp/appc/util/TestStructuredPropertyHelper.java233
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);
+ }
+}