Bug 3701 - UT GBP - 12 - groupbasedpolicy-base

SetUtils.java (81.5%)
IidFactory.java (98.3%)
DataStoreHelper.java (94.2%)

Change-Id: I7b2d03e80e7216da5d7edc5a9f1ea0a4ac95293c
Signed-off-by: Kinsey Nietzsche <knietzsc@cisco.com>

diff --git a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/DataStoreHelperTest.java b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/DataStoreHelperTest.java
new file mode 100644 (file)
index 0000000..b8f1987
--- /dev/null
+++ b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/DataStoreHelperTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ * 
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.util;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+
+public class DataStoreHelperTest {
+
+    private ReadOnlyTransaction readTransaction;
+    private WriteTransaction writeTransaction;
+    private ReadWriteTransaction readWriteTransaction;
+
+    private CheckedFuture<Optional<?>, ReadFailedException> readFuture;
+    private CheckedFuture<Void, TransactionCommitFailedException> submitFuture;
+
+    @SuppressWarnings("unchecked")
+    @Before
+    public void initialise() {
+        readTransaction = mock(ReadOnlyTransaction.class);
+        readFuture = mock(CheckedFuture.class);
+        when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
+                readFuture);
+
+        writeTransaction = mock(WriteTransaction.class);
+        submitFuture = mock(CheckedFuture.class);
+        when(writeTransaction.submit()).thenReturn(submitFuture);
+
+        readWriteTransaction = mock(ReadWriteTransaction.class);
+        when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
+                readFuture);
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    @Test
+    public void readFromDsTest() throws Exception {
+        Optional<?> optional = mock(Optional.class);
+        when(readFuture.checkedGet()).thenReturn((Optional) optional);
+        Assert.assertEquals(optional, DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+                mock(InstanceIdentifier.class), readTransaction));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void readFromDsTestException() throws Exception {
+        @SuppressWarnings("unused")
+        Optional<?> optional = mock(Optional.class);
+        doThrow(mock(ReadFailedException.class)).when(readFuture).checkedGet();
+        Assert.assertEquals(Optional.absent(), DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+                mock(InstanceIdentifier.class), readTransaction));
+    }
+
+    @Test
+    public void submitToDsTest() {
+        Assert.assertTrue(DataStoreHelper.submitToDs(writeTransaction));
+    }
+
+    @Test
+    public void submitToDsTestException() throws Exception {
+        doThrow(mock(TransactionCommitFailedException.class)).when(submitFuture).checkedGet();
+        Assert.assertFalse(DataStoreHelper.submitToDs(writeTransaction));
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    @Test
+    public void removeIfExistsTest() throws Exception {
+        Optional<?> optional = mock(Optional.class);
+        when(optional.isPresent()).thenReturn(true);
+        when(readFuture.checkedGet()).thenReturn((Optional) optional);
+        DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, mock(InstanceIdentifier.class),
+                readWriteTransaction);
+        verify(readWriteTransaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    @Test
+    public void removeIfExistsTestException() throws Exception {
+        Optional<?> optional = mock(Optional.class);
+        when(optional.isPresent()).thenReturn(false);
+        when(readFuture.checkedGet()).thenReturn((Optional) optional);
+        DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, mock(InstanceIdentifier.class),
+                readWriteTransaction);
+        verify(readWriteTransaction, never()).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
+    }
+}

diff --git a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/IidFactoryTest.java b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/IidFactoryTest.java
new file mode 100644 (file)
index 0000000..29088f6
--- /dev/null
+++ b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/IidFactoryTest.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.util;
+
+import static org.mockito.Mockito.mock;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClauseName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SelectorName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.TenantKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.Contract;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.ContractKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.EndpointGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.EndpointGroupKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2BridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2FloodDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.Subnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.SubnetKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.contract.Clause;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.contract.Subject;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.contract.SubjectKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.contract.subject.Rule;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.contract.subject.RuleKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.endpoint.group.ConsumerNamedSelector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.endpoint.group.ProviderNamedSelector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.subject.feature.instances.ActionInstance;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.subject.feature.instances.ClassifierInstance;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class IidFactoryTest {
+
+    private TenantId tenantId;
+    private EndpointGroupId epgId;
+    private ContractId contractId;
+    private SubjectName subjectName;
+    private RuleName ruleName;
+
+    @Before
+    public void initialise() {
+        tenantId = mock(TenantId.class);
+        epgId = mock(EndpointGroupId.class);
+        contractId = mock(ContractId.class);
+        subjectName = mock(SubjectName.class);
+        ruleName = mock(RuleName.class);
+    }
+
+    @Test
+    public void tenantIdTest() {
+        InstanceIdentifier<Tenant> identifier = IidFactory.tenantIid(tenantId);
+        Assert.assertEquals(tenantId, InstanceIdentifier.keyOf(identifier).getId());
+    }
+
+    @Test
+    public void endpointGroupIidTest() {
+        InstanceIdentifier<EndpointGroup> identifier = IidFactory.endpointGroupIid(tenantId, epgId);
+        Assert.assertEquals(epgId, InstanceIdentifier.keyOf(identifier).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void contractIidTest() {
+        InstanceIdentifier<Contract> identifier = IidFactory.contractIid(tenantId, contractId);
+        Assert.assertEquals(contractId, InstanceIdentifier.keyOf(identifier).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void subjectIidTest() {
+        SubjectName subjectName = mock(SubjectName.class);
+        InstanceIdentifier<Subject> identifier = IidFactory.subjectIid(tenantId, contractId, subjectName);
+        Assert.assertEquals(subjectName, InstanceIdentifier.keyOf(identifier).getName());
+        Assert.assertEquals(contractId, identifier.firstKeyOf(Contract.class, ContractKey.class).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void providerNamedSelectorIidTest() {
+        SelectorName providerSelectorName = mock(SelectorName.class);
+        InstanceIdentifier<ProviderNamedSelector> identifier = IidFactory.providerNamedSelectorIid(tenantId, epgId,
+                providerSelectorName);
+        Assert.assertEquals(providerSelectorName, InstanceIdentifier.keyOf(identifier).getName());
+        Assert.assertEquals(epgId, identifier.firstKeyOf(EndpointGroup.class, EndpointGroupKey.class).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void consumerNamedSelectorIidTest() {
+        SelectorName consumerSelectorName = mock(SelectorName.class);
+        InstanceIdentifier<ConsumerNamedSelector> identifier = IidFactory.consumerNamedSelectorIid(tenantId, epgId,
+                consumerSelectorName);
+        Assert.assertEquals(consumerSelectorName, InstanceIdentifier.keyOf(identifier).getName());
+        Assert.assertEquals(epgId, identifier.firstKeyOf(EndpointGroup.class, EndpointGroupKey.class).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void clauseIidTest() {
+        ClauseName clauseName = mock(ClauseName.class);
+        InstanceIdentifier<Clause> identifier = IidFactory.clauseIid(tenantId, contractId, clauseName);
+        Assert.assertEquals(clauseName, InstanceIdentifier.keyOf(identifier).getName());
+        Assert.assertEquals(contractId, identifier.firstKeyOf(Contract.class, ContractKey.class).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void ruleIdTest() {
+        InstanceIdentifier<Rule> identifier = IidFactory.ruleIid(tenantId, contractId, subjectName, ruleName);
+        Assert.assertEquals(ruleName, InstanceIdentifier.keyOf(identifier).getName());
+        Assert.assertEquals(subjectName, identifier.firstKeyOf(Subject.class, SubjectKey.class).getName());
+        Assert.assertEquals(contractId, identifier.firstKeyOf(Contract.class, ContractKey.class).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void actionInstanceIidTest() {
+        ActionName actionName = mock(ActionName.class);
+        InstanceIdentifier<ActionInstance> identifier = IidFactory.actionInstanceIid(tenantId, actionName);
+        Assert.assertEquals(actionName, InstanceIdentifier.keyOf(identifier).getName());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void classifierInstanceIidTest() {
+        ClassifierName classifierName = mock(ClassifierName.class);
+        InstanceIdentifier<ClassifierInstance> identifier = IidFactory.classifierInstanceIid(tenantId, classifierName);
+        Assert.assertEquals(classifierName, InstanceIdentifier.keyOf(identifier).getName());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void classifierRefIidTest() {
+        ClassifierName classifierRefName = mock(ClassifierName.class);
+        InstanceIdentifier<ClassifierRef> identifier = IidFactory.classifierRefIid(tenantId, contractId, subjectName,
+                ruleName, classifierRefName);
+        Assert.assertEquals(classifierRefName, InstanceIdentifier.keyOf(identifier).getName());
+        Assert.assertEquals(ruleName, identifier.firstKeyOf(Rule.class, RuleKey.class).getName());
+        Assert.assertEquals(subjectName, identifier.firstKeyOf(Subject.class, SubjectKey.class).getName());
+        Assert.assertEquals(contractId, identifier.firstKeyOf(Contract.class, ContractKey.class).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void l2FloodDomainIidTest() {
+        L2FloodDomainId l2FloodDomainId = mock(L2FloodDomainId.class);
+        InstanceIdentifier<L2FloodDomain> identifier = IidFactory.l2FloodDomainIid(tenantId, l2FloodDomainId);
+        Assert.assertEquals(l2FloodDomainId, InstanceIdentifier.keyOf(identifier).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void l2BridgeDomainIidTest() {
+        L2BridgeDomainId l2BridgeDomainId = mock(L2BridgeDomainId.class);
+        InstanceIdentifier<L2BridgeDomain> identifier = IidFactory.l2BridgeDomainIid(tenantId, l2BridgeDomainId);
+        Assert.assertEquals(l2BridgeDomainId, InstanceIdentifier.keyOf(identifier).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void l3ContextIidTest() {
+        L3ContextId l3ContextId = mock(L3ContextId.class);
+        InstanceIdentifier<L3Context> identifier = IidFactory.l3ContextIid(tenantId, l3ContextId);
+        Assert.assertEquals(l3ContextId, InstanceIdentifier.keyOf(identifier).getId());
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+    }
+
+    @Test
+    public void endpointIidTest() {
+        L2BridgeDomainId l2Context = mock(L2BridgeDomainId.class);
+        MacAddress macAddress = mock(MacAddress.class);
+        InstanceIdentifier<Endpoint> identifier = IidFactory.endpointIid(l2Context, macAddress);
+        Assert.assertEquals(l2Context, InstanceIdentifier.keyOf(identifier).getL2Context());
+        Assert.assertEquals(macAddress, InstanceIdentifier.keyOf(identifier).getMacAddress());
+    }
+
+    @Test
+    public void l3EndpointIidTest() {
+        L3ContextId l3ContextId = mock(L3ContextId.class);
+        IpAddress ipAddress = mock(IpAddress.class);
+        InstanceIdentifier<EndpointL3> identifier = IidFactory.l3EndpointIid(l3ContextId, ipAddress);
+        Assert.assertEquals(l3ContextId, InstanceIdentifier.keyOf(identifier).getL3Context());
+        Assert.assertEquals(ipAddress, InstanceIdentifier.keyOf(identifier).getIpAddress());
+    }
+
+    @Test
+    public void l3EndpointIidWildcardTest() {
+        InstanceIdentifier<EndpointL3> identifier = IidFactory.l3EndpointsIidWildcard();
+        Assert.assertNotNull(identifier);
+    }
+
+    @Test
+    public void endpointL3PrefixIidTest() {
+        L3ContextId l3Context = mock(L3ContextId.class);
+        IpPrefix ipPrefix = mock(IpPrefix.class);
+        InstanceIdentifier<EndpointL3Prefix> identifier = IidFactory.endpointL3PrefixIid(l3Context, ipPrefix);
+        Assert.assertEquals(l3Context, InstanceIdentifier.keyOf(identifier).getL3Context());
+        Assert.assertEquals(ipPrefix, InstanceIdentifier.keyOf(identifier).getIpPrefix());
+    }
+
+    @Test
+    public void endpointIidWildcardTest() {
+        InstanceIdentifier<Endpoints> identifier = IidFactory.endpointsIidWildcard();
+        Assert.assertNotNull(identifier);
+    }
+
+    @Test
+    public void subnetIidTest() {
+        SubnetId subnetId = mock(SubnetId.class);
+        InstanceIdentifier<Subnet> identifier = IidFactory.subnetIid(tenantId, subnetId);
+        Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class, TenantKey.class).getId());
+        Assert.assertEquals(subnetId, identifier.firstKeyOf(Subnet.class, SubnetKey.class).getId());
+    }
+
+}

diff --git a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/SetUtilsTest.java b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/SetUtilsTest.java
new file mode 100644 (file)
index 0000000..539d9d0
--- /dev/null
+++ b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/SetUtilsTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.util;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class SetUtilsTest {
+
+    private Object key;
+    private Object value;
+    private Set<Object> nestedSet;
+    private ConcurrentMap<Object, Set<Object>> concurrentMap;
+
+    @Before
+    public void initialise() {
+        key = new Object();
+        value = new Object();
+        nestedSet = new HashSet<Object>(Arrays.asList(value));
+        concurrentMap = new ConcurrentHashMap<Object, Set<Object>>();
+    }
+
+    @Test
+    public void getNestedSetTest() {
+        concurrentMap.put(key, nestedSet);
+        Set<Object> inner = SetUtils.getNestedSet(key, concurrentMap);
+        Assert.assertEquals(nestedSet, inner);
+    }
+
+    @Test
+    public void getNestedSetTestInnerNull() {
+        Set<Object> inner = SetUtils.getNestedSet(key, concurrentMap);
+        Assert.assertTrue(inner.isEmpty());
+    }
+}