gerrit.fd Code Review - hc2vpp.git/blob

   1 package io.fd.honeycomb.v3po.translate.util.write.registry;
   2
   3 import static org.hamcrest.CoreMatchers.anyOf;
   4 import static org.hamcrest.CoreMatchers.equalTo;
   5 import static org.hamcrest.CoreMatchers.hasItems;
   6 import static org.hamcrest.CoreMatchers.instanceOf;
   7 import static org.hamcrest.CoreMatchers.is;
   8 import static org.junit.Assert.assertEquals;
   9 import static org.junit.Assert.assertThat;
  10 import static org.mockito.Mockito.mock;
  11 import static org.mockito.Mockito.when;
  12
  13 import com.google.common.collect.ImmutableMap;
  14 import com.google.common.collect.Lists;
  15 import com.google.common.collect.Sets;
  16 import io.fd.honeycomb.v3po.translate.write.Writer;
  17 import java.util.ArrayList;
  18 import java.util.List;
  19 import org.junit.Test;
  20 import org.opendaylight.yangtools.yang.binding.ChildOf;
  21 import org.opendaylight.yangtools.yang.binding.DataObject;
  22 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  23
  24 public class FlatWriterRegistryBuilderTest {
  25
  26
  27     @Test
  28     public void testRelationsBefore() throws Exception {
  29         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  30         /*
  31             1   ->  2   ->  3
  32                         ->  4
  33          */
  34         flatWriterRegistryBuilder.add(mockWriter(DataObject3.class));
  35         flatWriterRegistryBuilder.add(mockWriter(DataObject4.class));
  36         flatWriterRegistryBuilder.addBefore(mockWriter(DataObject2.class),
  37                 Lists.newArrayList(DataObject3.IID, DataObject4.IID));
  38         flatWriterRegistryBuilder.addBefore(mockWriter(DataObject1.class), DataObject2.IID);
  39         final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters =
  40                 flatWriterRegistryBuilder.getMappedHandlers();
  41
  42         final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet());
  43         assertEquals(DataObject1.IID, typesInList.get(0));
  44         assertEquals(DataObject2.IID, typesInList.get(1));
  45         assertThat(typesInList.get(2), anyOf(equalTo(DataObject3.IID), equalTo(DataObject4.IID)));
  46         assertThat(typesInList.get(3), anyOf(equalTo(DataObject3.IID), equalTo(DataObject4.IID)));
  47     }
  48
  49     @Test
  50     public void testRelationsAfter() throws Exception {
  51         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  52         /*
  53             1   ->  2   ->  3
  54                         ->  4
  55          */
  56         flatWriterRegistryBuilder.add(mockWriter(DataObject1.class));
  57         flatWriterRegistryBuilder.addAfter(mockWriter(DataObject2.class), DataObject1.IID);
  58         flatWriterRegistryBuilder.addAfter(mockWriter(DataObject3.class), DataObject2.IID);
  59         flatWriterRegistryBuilder.addAfter(mockWriter(DataObject4.class), DataObject2.IID);
  60         final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters =
  61                 flatWriterRegistryBuilder.getMappedHandlers();
  62
  63         final List<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet());
  64         assertEquals(DataObject1.IID, typesInList.get(0));
  65         assertEquals(DataObject2.IID, typesInList.get(1));
  66         assertThat(typesInList.get(2), anyOf(equalTo(DataObject3.IID), equalTo(DataObject4.IID)));
  67         assertThat(typesInList.get(3), anyOf(equalTo(DataObject3.IID), equalTo(DataObject4.IID)));
  68     }
  69
  70     @Test(expected = IllegalArgumentException.class)
  71     public void testRelationsLoop() throws Exception {
  72         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  73         /*
  74             1   ->  2   ->  1
  75          */
  76         flatWriterRegistryBuilder.add(mockWriter(DataObject1.class));
  77         flatWriterRegistryBuilder.addAfter(mockWriter(DataObject2.class), DataObject1.IID);
  78         flatWriterRegistryBuilder.addAfter(mockWriter(DataObject1.class), DataObject2.IID);
  79     }
  80
  81     @Test(expected = IllegalArgumentException.class)
  82     public void testAddWriterTwice() throws Exception {
  83         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  84         flatWriterRegistryBuilder.add(mockWriter(DataObject1.class));
  85         flatWriterRegistryBuilder.add(mockWriter(DataObject1.class));
  86     }
  87
  88     @Test
  89     public void testAddSubtreeWriter() throws Exception {
  90         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  91         flatWriterRegistryBuilder.subtreeAdd(
  92                 Sets.newHashSet(DataObject4.DataObject5.IID,
  93                                 DataObject4.DataObject5.IID),
  94                 mockWriter(DataObject4.class));
  95         final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters =
  96                 flatWriterRegistryBuilder.getMappedHandlers();
  97         final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet());
  98
  99         assertEquals(DataObject4.IID, typesInList.get(0));
 100         assertEquals(1, typesInList.size());
 101     }
 102
 103     @Test
 104     public void testCreateSubtreeWriter() throws Exception {
 105         final Writer<?> forWriter = SubtreeWriter.createForWriter(Sets.newHashSet(
 106                 DataObject4.DataObject5.IID,
 107                 DataObject4.DataObject5.DataObject51.IID,
 108                 DataObject4.DataObject6.IID),
 109                 mockWriter(DataObject4.class));
 110         assertThat(forWriter, instanceOf(SubtreeWriter.class));
 111         assertThat(((SubtreeWriter<?>) forWriter).getHandledChildTypes().size(), is(3));
 112         assertThat(((SubtreeWriter<?>) forWriter).getHandledChildTypes(), hasItems(DataObject4.DataObject5.IID,
 113                 DataObject4.DataObject6.IID, DataObject4.DataObject5.DataObject51.IID));
 114     }
 115
 116     @Test(expected = IllegalArgumentException.class)
 117     public void testCreateInvalidSubtreeWriter() throws Exception {
 118         SubtreeWriter.createForWriter(Sets.newHashSet(
 119                 InstanceIdentifier.create(DataObject3.class).child(DataObject3.DataObject31.class)),
 120                 mockWriter(DataObject4.class));
 121     }
 122
 123     @SuppressWarnings("unchecked")
 124     private Writer<? extends DataObject> mockWriter(final Class<? extends DataObject> doClass)
 125             throws NoSuchFieldException, IllegalAccessException {
 126         final Writer mock = mock(Writer.class);
 127         when(mock.getManagedDataObjectType()).thenReturn((InstanceIdentifier<?>) doClass.getDeclaredField("IID").get(null));
 128         return mock;
 129     }
 130
 131     private abstract static class DataObject1 implements DataObject {
 132         static InstanceIdentifier<DataObject1> IID = InstanceIdentifier.create(DataObject1.class);
 133     }
 134     private abstract static class DataObject2 implements DataObject {
 135         static InstanceIdentifier<DataObject2> IID = InstanceIdentifier.create(DataObject2.class);
 136     }
 137     private abstract static class DataObject3 implements DataObject {
 138         static InstanceIdentifier<DataObject3> IID = InstanceIdentifier.create(DataObject3.class);
 139         private abstract static class DataObject31 implements DataObject, ChildOf<DataObject3> {
 140             static InstanceIdentifier<DataObject31> IID = DataObject3.IID.child(DataObject31.class);
 141         }
 142     }
 143     private abstract static class DataObject4 implements DataObject {
 144         static InstanceIdentifier<DataObject4> IID = InstanceIdentifier.create(DataObject4.class);
 145         private abstract static class DataObject5 implements DataObject, ChildOf<DataObject4> {
 146             static InstanceIdentifier<DataObject5> IID = DataObject4.IID.child(DataObject5.class);
 147             private abstract static class DataObject51 implements DataObject, ChildOf<DataObject5> {
 148                 static InstanceIdentifier<DataObject51> IID = DataObject5.IID.child(DataObject51.class);
 149             }
 150         }
 151         private abstract static class DataObject6 implements DataObject, ChildOf<DataObject4> {
 152             static InstanceIdentifier<DataObject6> IID = DataObject4.IID.child(DataObject6.class);
 153         }
 154     }
 155
 156 }