/*
 * 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.protocol.bgp.linkstate;

/**
 * TODO: Remove, instead use Common Rib Support test
 */
public class LinkstateRIBSupportTest {
/*
    private static final Ipv4Address ipv4 = new Ipv4Address("42.42.42.42");
    private static final NodeIdentifier ROUTES_NODE_ID = new NodeIdentifier(Routes.QNAME);
    final LinkstateRIBSupport link = LinkstateRIBSupport.getInstance();
    final List<MapEntryNode> linkList = new ArrayList<>();
    private List<YangInstanceIdentifier> routes;

    @Mock
    private DOMDataWriteTransaction tx;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        routes = new ArrayList<>();
        Mockito.doAnswer(new Answer<Object>() {
            @Override
            public Object answer(final InvocationOnMock invocation) throws Throwable {
                final Object[] args = invocation.getArguments();
                LinkstateRIBSupportTest.this.routes.add((YangInstanceIdentifier) args[1]);
                return args[1];
            }
        }).when(this.tx).put(Mockito.any(LogicalDatastoreType.class), Mockito.any(YangInstanceIdentifier.class), Mockito.any(NormalizedNode.class));

        Mockito.doAnswer(new Answer<Object>() {
            @Override
            public Object answer(final InvocationOnMock invocation) throws Throwable {
                final Object[] args = invocation.getArguments();
                LinkstateRIBSupportTest.this.routes.remove(args[1]);
                return args[1];
            }
        }).when(this.tx).delete(Mockito.any(LogicalDatastoreType.class), Mockito.any(YangInstanceIdentifier.class));
    }

    @Test
    public void testbuildReach() throws BGPParsingException {
        final CNextHop hop = new Ipv4NextHopCaseBuilder().setIpv4NextHop(new Ipv4NextHopBuilder().setGlobal(ipv4).build()).build();
        final MpReachNlri result = link.buildReach(linkList, hop);
        assertEquals(LinkstateAddressFamily.class, result.getAfi());
        assertEquals(LinkstateSubsequentAddressFamily.class, result.getSafi());
        assertEquals(new Ipv4NextHopCaseBuilder().setIpv4NextHop(new Ipv4NextHopBuilder().setGlobal(new Ipv4Address("42.42.42.42")).build()).build(), result.getCNextHop());
    }

    @Test
    public void testBuildUnreach() {
        final MpUnreachNlri result = link.buildUnreach(linkList);
        assertEquals(LinkstateAddressFamily.class, result.getAfi());
        assertEquals(LinkstateSubsequentAddressFamily.class, result.getSafi());
    }

    @Test
    public void testDestinationRoutes() {
        final YangInstanceIdentifier yangIdentifier = YangInstanceIdentifier.of(Routes.QNAME);

        final NodeNlriParser nodeParser = new NodeNlriParser();
        SimpleNlriTypeRegistry.getInstance().registerNlriTypeSerializer(NodeCase.class, nodeParser);

        final DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> linkstateBI = ImmutableUnkeyedListEntryNodeBuilder.create();
        linkstateBI.withNodeIdentifier(new NodeIdentifier(CLinkstateDestination.QNAME));

        final ImmutableLeafNodeBuilder<String> protocolId = new ImmutableLeafNodeBuilder<>();
        protocolId.withNodeIdentifier(LinkstateNlriParser.PROTOCOL_ID_NID);
        protocolId.withValue("isis-level2");
        linkstateBI.addChild(protocolId.build());

        final ImmutableLeafNodeBuilder<BigInteger> identifier = new ImmutableLeafNodeBuilder<>();
        identifier.withNodeIdentifier(LinkstateNlriParser.IDENTIFIER_NID);
        identifier.withValue(BigInteger.ONE);
        linkstateBI.addChild(identifier.build());

        final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> objectType = Builders.choiceBuilder();
        objectType.withNodeIdentifier(LinkstateNlriParser.OBJECT_TYPE_NID);

        final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> nodeDescriptors = Builders.containerBuilder();
        nodeDescriptors.withNodeIdentifier(LinkstateNlriParser.NODE_DESCRIPTORS_NID);

        final ImmutableLeafNodeBuilder<Long> asNumber = new ImmutableLeafNodeBuilder<>();
        asNumber.withNodeIdentifier(NodeNlriParser.AS_NUMBER_NID);
        asNumber.withValue(72L);
        nodeDescriptors.addChild(asNumber.build());

        final ImmutableLeafNodeBuilder<Long> areaID = new ImmutableLeafNodeBuilder<>();
        areaID.withNodeIdentifier(NodeNlriParser.AREA_NID);
        areaID.withValue(2697513L);
        nodeDescriptors.addChild(areaID.build());

        final ImmutableLeafNodeBuilder<Long> domainID = new ImmutableLeafNodeBuilder<>();
        domainID.withNodeIdentifier(NodeNlriParser.DOMAIN_NID);
        domainID.withValue(0x28282828L);
        nodeDescriptors.addChild(domainID.build());

        final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> crouterId = Builders.choiceBuilder();
        crouterId.withNodeIdentifier(new NodeIdentifier(CRouterIdentifier.QNAME));

        final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> isisNode = Builders.containerBuilder();
        isisNode.withNodeIdentifier(NodeNlriParser.ISIS_PSEUDONODE_NID);

        final ImmutableLeafNodeBuilder<byte[]> isoSystemID = new ImmutableLeafNodeBuilder<>();
        isoSystemID.withNodeIdentifier(NodeNlriParser.ISO_SYSTEM_NID);
        isoSystemID.withValue(new byte[]{0, 0, 0, 0, 0, (byte) 0x39});

        final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> isisRouter = Builders.containerBuilder();
        isisRouter.withNodeIdentifier(NodeNlriParser.ISIS_ROUTER_NID);
        isisRouter.addChild(isoSystemID.build());

        isisNode.addChild(isisRouter.build());
        isisNode.addChild(Builders.leafBuilder().withNodeIdentifier(NodeNlriParser.PSN_NID).withValue((short) 5).build());
        crouterId.addChild(isisNode.build());

        nodeDescriptors.addChild(crouterId.build());
        objectType.addChild(nodeDescriptors.build());
        linkstateBI.addChild(objectType.build());

        final UnkeyedListNode routes = ImmutableUnkeyedListNodeBuilder.create()
            .withNodeIdentifier(new NodeIdentifier(CLinkstateDestination.QNAME))
            .addChild(linkstateBI.build())
            .build();

        final ContainerNode destination = ImmutableContainerNodeBuilder.create().
            addChild(routes)
            .withNodeIdentifier(new NodeIdentifier(CLinkstateDestination.QNAME))
            .build();

        final ContainerNode attributes = ImmutableContainerNodeBuilder.create()
            .withNodeIdentifier(new NodeIdentifier(Attributes.QNAME))
            .build();

        link.putDestinationRoutes(tx, yangIdentifier, destination, attributes, ROUTES_NODE_ID);

        Assert.assertEquals(1, this.routes.size());

        link.deleteDestinationRoutes(tx, yangIdentifier, destination, ROUTES_NODE_ID);

        Assert.assertEquals(0, this.routes.size());
    }
*/
}