From c8cede0f405b6f6ee65fca48a8c5e4261e93fb04 Mon Sep 17 00:00:00 2001 From: Nikola Dancejic <26731235+Ndancejic@users.noreply.github.com> Date: Thu, 30 May 2024 09:30:20 -0700 Subject: [PATCH] [syncd] Enable bulk api for neighbor entries (#1373) * [syncd] Enable bulk api for neighbor entries SAI 1.11.0 added support for bulk neighbor entries. Adding support for neighbor bulk operations to syncd. * added neighbor entry capability to bulk operations in syncd * added unit tests for neighbor bulk operations * added code coverage for neighbor bulk operations --- saiplayer/SaiPlayer.cpp | 52 ++++++++ syncd/Syncd.cpp | 64 ++++++++++ syncd/tests.cpp | 141 ++++++++++++++++++++++ syncd/tests/TestSyncdBrcm.cpp | 146 +++++++++++++++++++++++ tests/BCM56850.pl | 8 ++ tests/BCM56850/bulk_neighbor.rec | 12 ++ unittest/lib/test_sai_redis_neighbor.cpp | 30 +++++ unittest/vslib/test_sai_vs_neighbor.cpp | 30 +++++ 8 files changed, 483 insertions(+) create mode 100644 tests/BCM56850/bulk_neighbor.rec create mode 100644 unittest/lib/test_sai_redis_neighbor.cpp create mode 100644 unittest/vslib/test_sai_vs_neighbor.cpp diff --git a/saiplayer/SaiPlayer.cpp b/saiplayer/SaiPlayer.cpp index 3710a2de8..4437f2906 100644 --- a/saiplayer/SaiPlayer.cpp +++ b/saiplayer/SaiPlayer.cpp @@ -1698,6 +1698,23 @@ sai_status_t SaiPlayer::handle_bulk_entry( } break; + case SAI_OBJECT_TYPE_NEIGHBOR_ENTRY: + { + std::vector entries(object_count); + + for (size_t it = 0; it < object_count; it++) + { + sai_deserialize_neighbor_entry(object_ids[it], entries[it]); + + entries[it].switch_id = translate_local_to_redis(entries[it].switch_id); + entries[it].rif_id = translate_local_to_redis(entries[it].rif_id); + } + + CALL_BULK_CREATE_API_WITH_TIMER("neighbor_entry"); + + } + break; + case SAI_OBJECT_TYPE_FDB_ENTRY: { @@ -1876,6 +1893,23 @@ sai_status_t SaiPlayer::handle_bulk_entry( } break; + case SAI_OBJECT_TYPE_NEIGHBOR_ENTRY: + { + std::vector entries(object_count); + + for (size_t it = 0; it < object_count; it++) + { + sai_deserialize_neighbor_entry(object_ids[it], entries[it]); + + entries[it].switch_id = translate_local_to_redis(entries[it].switch_id); + entries[it].rif_id = translate_local_to_redis(entries[it].rif_id); + } + + CALL_BULK_REMOVE_API_WITH_TIMER("neighbor_entry"); + + } + break; + case SAI_OBJECT_TYPE_FDB_ENTRY: { @@ -2061,6 +2095,23 @@ sai_status_t SaiPlayer::handle_bulk_entry( } break; + case SAI_OBJECT_TYPE_NEIGHBOR_ENTRY: + { + std::vector entries(object_count); + + for (size_t it = 0; it < object_count; it++) + { + sai_deserialize_neighbor_entry(object_ids[it], entries[it]); + + entries[it].switch_id = translate_local_to_redis(entries[it].switch_id); + entries[it].rif_id = translate_local_to_redis(entries[it].rif_id); + } + + CALL_BULK_SET_API_WITH_TIMER("neighbor_entry"); + + } + break; + case SAI_OBJECT_TYPE_FDB_ENTRY: { @@ -2452,6 +2503,7 @@ void SaiPlayer::processBulk( switch ((int)object_type) { case SAI_OBJECT_TYPE_ROUTE_ENTRY: + case SAI_OBJECT_TYPE_NEIGHBOR_ENTRY: case SAI_OBJECT_TYPE_FDB_ENTRY: case SAI_OBJECT_TYPE_NAT_ENTRY: case SAI_OBJECT_TYPE_DIRECTION_LOOKUP_ENTRY: diff --git a/syncd/Syncd.cpp b/syncd/Syncd.cpp index 09f066a9e..980886f8f 100644 --- a/syncd/Syncd.cpp +++ b/syncd/Syncd.cpp @@ -1015,6 +1015,27 @@ sai_status_t Syncd::processBulkCreateEntry( } break; + case SAI_OBJECT_TYPE_NEIGHBOR_ENTRY: + { + std::vector entries(object_count); + for (uint32_t it = 0; it < object_count; it++) + { + sai_deserialize_neighbor_entry(objectIds[it], entries[it]); + + entries[it].switch_id = m_translator->translateVidToRid(entries[it].switch_id); + entries[it].rif_id = m_translator->translateVidToRid(entries[it].rif_id); + } + + status = m_vendorSai->bulkCreate( + object_count, + entries.data(), + attr_counts.data(), + attr_lists.data(), + mode, + statuses.data()); + } + break; + case SAI_OBJECT_TYPE_FDB_ENTRY: { std::vector entries(object_count); @@ -1301,6 +1322,25 @@ sai_status_t Syncd::processBulkRemoveEntry( } break; + case SAI_OBJECT_TYPE_NEIGHBOR_ENTRY: + { + std::vector entries(object_count); + for (uint32_t it = 0; it < object_count; it++) + { + sai_deserialize_neighbor_entry(objectIds[it], entries[it]); + + entries[it].switch_id = m_translator->translateVidToRid(entries[it].switch_id); + entries[it].rif_id = m_translator->translateVidToRid(entries[it].rif_id); + } + + status = m_vendorSai->bulkRemove( + object_count, + entries.data(), + mode, + statuses.data()); + } + break; + case SAI_OBJECT_TYPE_FDB_ENTRY: { std::vector entries(object_count); @@ -1574,6 +1614,26 @@ sai_status_t Syncd::processBulkSetEntry( } break; + case SAI_OBJECT_TYPE_NEIGHBOR_ENTRY: + { + std::vector entries(object_count); + for (uint32_t it = 0; it < object_count; it++) + { + sai_deserialize_neighbor_entry(objectIds[it], entries[it]); + + entries[it].switch_id = m_translator->translateVidToRid(entries[it].switch_id); + entries[it].rif_id = m_translator->translateVidToRid(entries[it].rif_id); + } + + status = m_vendorSai->bulkSet( + object_count, + entries.data(), + attr_lists.data(), + mode, + statuses.data()); + } + break; + case SAI_OBJECT_TYPE_FDB_ENTRY: { std::vector entries(object_count); @@ -1730,6 +1790,10 @@ sai_status_t Syncd::processBulkEntry( sai_deserialize_route_entry(objectIds[idx], metaKey.objectkey.key.route_entry); break; + case SAI_OBJECT_TYPE_NEIGHBOR_ENTRY: + sai_deserialize_neighbor_entry(objectIds[idx], metaKey.objectkey.key.neighbor_entry); + break; + case SAI_OBJECT_TYPE_NAT_ENTRY: sai_deserialize_nat_entry(objectIds[idx], metaKey.objectkey.key.nat_entry); break; diff --git a/syncd/tests.cpp b/syncd/tests.cpp index a150f935e..27b89dfa7 100644 --- a/syncd/tests.cpp +++ b/syncd/tests.cpp @@ -671,6 +671,145 @@ void test_bulk_route_set() ASSERT_SUCCESS("Failed to bulk remove route entry"); } +void test_bulk_neighbor_set() +{ + SWSS_LOG_ENTER(); + + + sai_reinit(); + + + sai_status_t status; + + sai_neighbor_api_t *sai_neighbor_api = NULL; + sai_switch_api_t *sai_switch_api = NULL; + sai_virtual_router_api_t * sai_virtual_router_api = NULL; + sai_lag_api_t *sai_lag_api = NULL; + sai_router_interface_api_t *sai_rif_api = NULL; + + sai_api_query(SAI_API_NEIGHBOR, (void**)&sai_neighbor_api); + sai_api_query(SAI_API_SWITCH, (void**)&sai_switch_api); + sai_api_query(SAI_API_VIRTUAL_ROUTER, (void**)&sai_virtual_router_api); + sai_api_query(SAI_API_ROUTER_INTERFACE, (void **)&sai_rif_api); + sai_api_query(SAI_API_LAG, (void**)&sai_lag_api); + + uint32_t count = 3; + + std::vector neighbors; + std::vector attrs; + + sai_attribute_t swattr; + + swattr.id = SAI_SWITCH_ATTR_INIT_SWITCH; + swattr.value.booldata = true; + + sai_object_id_t switch_id; + status = sai_switch_api->create_switch(&switch_id, 1, &swattr); + + ASSERT_SUCCESS("Failed to create switch"); + + std::vector> neighbor_attrs; + std::vector neighbor_attrs_array; + std::vector neighbor_attrs_count; + + for (uint32_t i = 0; i < count; ++i) + { + sai_neighbor_entry_t neighbor_entry; + + // virtual router + sai_object_id_t vr; + + status = sai_virtual_router_api->create_virtual_router(&vr, switch_id, 0, NULL); + + ASSERT_SUCCESS("failed to create virtual router"); + + // create lag + sai_object_id_t lag; + status = sai_lag_api->create_lag(&lag, switch_id, 0, NULL); + + // create router interface + sai_object_id_t rif; + sai_attribute_t rifattr[3]; + rifattr[0].id = SAI_ROUTER_INTERFACE_ATTR_VIRTUAL_ROUTER_ID; + rifattr[0].value.oid = vr; + rifattr[1].id = SAI_ROUTER_INTERFACE_ATTR_TYPE; + rifattr[1].value.s32 = SAI_ROUTER_INTERFACE_TYPE_PORT; + rifattr[2].id = SAI_ROUTER_INTERFACE_ATTR_PORT_ID; + rifattr[2].value.oid = lag; + status = sai_rif_api->create_router_interface(&rif, switch_id, 3, rifattr); + ASSERT_SUCCESS("Failed to create router interface"); + + neighbor_entry.ip_address.addr_family = SAI_IP_ADDR_FAMILY_IPV4; + neighbor_entry.ip_address.addr.ip4 = 0x10000001 + i; + neighbor_entry.rif_id = rif; + neighbor_entry.switch_id = switch_id; + neighbors.push_back(neighbor_entry); + + std::vector list(1); + sai_attribute_t &attr = list[0]; + + sai_mac_t mac = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + attr.id = SAI_NEIGHBOR_ENTRY_ATTR_DST_MAC_ADDRESS; + memcpy(attr.value.mac, mac, 6); + neighbor_attrs.push_back(list); + neighbor_attrs_count.push_back(1); + } + + for (size_t j = 0; j < neighbor_attrs.size(); j++) + { + neighbor_attrs_array.push_back(neighbor_attrs[j].data()); + } + + std::vector statuses(count); + status = sai_neighbor_api->create_neighbor_entries(count, neighbors.data(), neighbor_attrs_count.data(), neighbor_attrs_array.data(), SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR, statuses.data()); + ASSERT_SUCCESS("Failed to create neighbor"); + for (size_t j = 0; j < statuses.size(); j++) + { + status = statuses[j]; + ASSERT_SUCCESS("Failed to create neighbor # %zu", j); + } + + for (uint32_t i = 0; i < count; ++i) + { + sai_attribute_t attr; + attr.id = SAI_NEIGHBOR_ENTRY_ATTR_PACKET_ACTION; + attr.value.s32 = SAI_PACKET_ACTION_FORWARD; + + status = sai_neighbor_api->set_neighbor_entry_attribute(&neighbors[i], &attr); + + attrs.push_back(attr); + + ASSERT_SUCCESS("Failed to set neighbor"); + } + + statuses.clear(); + statuses.resize(attrs.size()); + + for (auto &attr: attrs) + { + attr.value.s32 = SAI_PACKET_ACTION_FORWARD; + } + + status = sai_neighbor_api->set_neighbor_entries_attribute( + count, + neighbors.data(), + attrs.data(), + SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR, + statuses.data()); + + ASSERT_SUCCESS("Failed to bulk set neighbor"); + + for (auto s: statuses) + { + status = s; + + ASSERT_SUCCESS("Failed to bulk set neighbor on one of the neighbors"); + } + + status = sai_neighbor_api->remove_neighbor_entries(count, neighbors.data(), SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR, statuses.data()); + ASSERT_SUCCESS("Failed to bulk remove neighbor entry"); +} + void syncdThread() { SWSS_LOG_ENTER(); @@ -765,6 +904,8 @@ int main() test_bulk_fdb_create(); + test_bulk_neighbor_set(); + test_bulk_route_set(); sai_api_uninitialize(); diff --git a/syncd/tests/TestSyncdBrcm.cpp b/syncd/tests/TestSyncdBrcm.cpp index b776d45e8..892a3ca0e 100644 --- a/syncd/tests/TestSyncdBrcm.cpp +++ b/syncd/tests/TestSyncdBrcm.cpp @@ -243,3 +243,149 @@ TEST_F(SyncdBrcmTest, routeBulkCreate) status = m_sairedis->set(SAI_OBJECT_TYPE_SWITCH, SAI_NULL_OBJECT_ID, attrs); ASSERT_EQ(status, SAI_STATUS_SUCCESS); } + +TEST_F(SyncdBrcmTest, neighborBulkTest) +{ + sai_object_id_t switchId; + sai_object_id_t rif; + sai_object_id_t port; + sai_attribute_t attrs[3]; + + // init view + + attrs[0].id = SAI_REDIS_SWITCH_ATTR_NOTIFY_SYNCD; + attrs[0].value.s32 = SAI_REDIS_NOTIFY_SYNCD_INIT_VIEW; + + auto status = m_sairedis->set(SAI_OBJECT_TYPE_SWITCH, SAI_NULL_OBJECT_ID, attrs); + ASSERT_EQ(status, SAI_STATUS_SUCCESS); + + // create switch + + attrs[0].id = SAI_SWITCH_ATTR_INIT_SWITCH; + attrs[0].value.booldata = true; + + status = m_sairedis->create(SAI_OBJECT_TYPE_SWITCH, &switchId, SAI_NULL_OBJECT_ID, 1, attrs); + ASSERT_EQ(status, SAI_STATUS_SUCCESS); + + attrs[0].id = SAI_SWITCH_ATTR_DEFAULT_VIRTUAL_ROUTER_ID; + status = m_sairedis->get(SAI_OBJECT_TYPE_SWITCH, switchId, 1, attrs); + ASSERT_EQ(status, SAI_STATUS_SUCCESS); + + sai_object_id_t vr = attrs[0].value.oid; + + // create port + static uint32_t id = 1; + id++; + + uint32_t hw_lane_list[1] = { id }; + + attrs[0].id = SAI_PORT_ATTR_HW_LANE_LIST; + attrs[0].value.u32list.count = 1; + attrs[0].value.u32list.list = hw_lane_list; + + attrs[1].id = SAI_PORT_ATTR_SPEED; + attrs[1].value.u32 = 10000; + + status = m_sairedis->create(SAI_OBJECT_TYPE_PORT, &port, switchId, 2, attrs); + EXPECT_EQ(SAI_STATUS_SUCCESS, status); + + // create rif + attrs[0].id = SAI_ROUTER_INTERFACE_ATTR_VIRTUAL_ROUTER_ID; + attrs[0].value.oid = vr; + + attrs[1].id = SAI_ROUTER_INTERFACE_ATTR_TYPE; + attrs[1].value.s32 = SAI_ROUTER_INTERFACE_TYPE_PORT; + + attrs[2].id = SAI_ROUTER_INTERFACE_ATTR_PORT_ID; + attrs[2].value.oid = port; + + status = m_sairedis->create(SAI_OBJECT_TYPE_ROUTER_INTERFACE, &rif, switchId, 3, attrs); + EXPECT_EQ(SAI_STATUS_SUCCESS, status); + + // create neighbor bulk neighbors in init view mode + + std::vector> neighbor_attrs; + std::vector neighbor_attrs_array; + std::vector neighbor_attrs_count; + std::vector neighbors; + + uint32_t count = 3; + for (uint32_t i = 0; i < count; ++i) + { + sai_neighbor_entry_t neighbor_entry; + + neighbor_entry.ip_address.addr_family = SAI_IP_ADDR_FAMILY_IPV4; + neighbor_entry.ip_address.addr.ip4 = 0x10000001 + i; + neighbor_entry.rif_id = rif; + neighbor_entry.switch_id = switchId; + + neighbors.push_back(neighbor_entry); + + std::vector list(1); // no attributes + sai_attribute_t &neigh_attr = list[0]; + + sai_mac_t mac = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + neigh_attr.id = SAI_NEIGHBOR_ENTRY_ATTR_DST_MAC_ADDRESS; + memcpy(neigh_attr.value.mac, mac, 6); + + neighbor_attrs.push_back(list); + neighbor_attrs_count.push_back(1); + } + + for (size_t j = 0; j < neighbor_attrs.size(); j++) + { + neighbor_attrs_array.push_back(neighbor_attrs[j].data()); + } + + std::vector statuses(count); + + status = m_sairedis->bulkCreate( + count, + neighbors.data(), + neighbor_attrs_count.data(), + neighbor_attrs_array.data(), + SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR, + statuses.data()); + ASSERT_EQ(status, SAI_STATUS_SUCCESS); + + for (size_t j = 0; j < statuses.size(); j++) + { + status = statuses[j]; + ASSERT_EQ(status, SAI_STATUS_SUCCESS); + } + + statuses.clear(); + + for (uint32_t i = 0; i < count; ++i) + { + attrs[i].id = SAI_NEIGHBOR_ENTRY_ATTR_PACKET_ACTION; + attrs[i].value.s32 = SAI_PACKET_ACTION_FORWARD; + } + + status = m_sairedis->bulkSet( + count, + neighbors.data(), + attrs, + SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR, + statuses.data()); + + for (size_t j = 0; j < statuses.size(); j++) + { + status = statuses[j]; + ASSERT_EQ(status, SAI_STATUS_SUCCESS); + } + + statuses.clear(); + + status = m_sairedis->bulkRemove( + count, + neighbors.data(), + SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR, + statuses.data()); + + for (size_t j = 0; j < statuses.size(); j++) + { + status = statuses[j]; + ASSERT_EQ(status, SAI_STATUS_SUCCESS); + } +} diff --git a/tests/BCM56850.pl b/tests/BCM56850.pl index 5127757c7..7dd6ea0a8 100755 --- a/tests/BCM56850.pl +++ b/tests/BCM56850.pl @@ -580,6 +580,13 @@ sub test_bulk_route play "bulk_route.rec" } +sub test_bulk_neighbor +{ + fresh_start; + + play "bulk_neighbor.rec" +} + sub test_bulk_fdb { fresh_start; @@ -862,6 +869,7 @@ sub test_acl_pre_match_999 test_acl_mask; test_empty_lag_buffer_acl; test_bulk_route; +test_bulk_neighbor; test_bulk_fdb; test_bulk_object; test_brcm_config_acl; diff --git a/tests/BCM56850/bulk_neighbor.rec b/tests/BCM56850/bulk_neighbor.rec new file mode 100644 index 000000000..4d0887031 --- /dev/null +++ b/tests/BCM56850/bulk_neighbor.rec @@ -0,0 +1,12 @@ +2024-05-22.01:55:46.541806|#|recording on: ./sairedis.2024-05-22.01:55:46.541389.rec +2024-05-22.01:55:46.543987|a|INIT_VIEW +2024-05-22.01:55:46.551164|A|SAI_STATUS_SUCCESS +2024-05-22.01:55:46.555975|c|SAI_OBJECT_TYPE_SWITCH:oid:0x21000000000000|SAI_SWITCH_ATTR_INIT_SWITCH=true|SAI_SWITCH_ATTR_FDB_EVENT_NOTIFY=0x417890|SAI_SWITCH_ATTR_PORT_STATE_CHANGE_NOTIFY=0x4179f0|SAI_SWITCH_ATTR_SWITCH_SHUTDOWN_REQUEST_NOTIFY=0x417b50 +2024-05-22.01:56:05.508992|c|SAI_OBJECT_TYPE_VIRTUAL_ROUTER:oid:0x3000000000004 +2024-05-22.01:56:05.708992|c|SAI_OBJECT_TYPE_PORT:oid:0x20000000006ee|SAI_PORT_ATTR_SPEED=10000|SAI_PORT_ATTR_HW_LANE_LIST=1:202 +2024-05-22.01:56:05.805336|c|SAI_OBJECT_TYPE_ROUTER_INTERFACE:oid:0x6000000000727|SAI_ROUTER_INTERFACE_ATTR_VIRTUAL_ROUTER_ID=oid:0x3000000000004|SAI_ROUTER_INTERFACE_ATTR_SRC_MAC_ADDRESS=00:E0:EC:C2:AF:7A|SAI_ROUTER_INTERFACE_ATTR_TYPE=SAI_ROUTER_INTERFACE_TYPE_PORT|SAI_ROUTER_INTERFACE_ATTR_PORT_ID=oid:0x20000000006ee|SAI_ROUTER_INTERFACE_ATTR_MTU=9100|SAI_ROUTER_INTERFACE_ATTR_NAT_ZONE_ID=0 +2024-05-22.01:56:06.105336|C|SAI_OBJECT_TYPE_NEIGHBOR_ENTRY||{"ip":"10.0.0.57","rif":"oid:0x6000000000727","switch_id":"oid:0x21000000000000"}|SAI_NEIGHBOR_ENTRY_ATTR_DST_MAC_ADDRESS=FF:FF:FF:FF:FF:FF||{"ip":"10.0.0.59","rif":"oid:0x6000000000727","switch_id":"oid:0x21000000000000"}|SAI_NEIGHBOR_ENTRY_ATTR_DST_MAC_ADDRESS=FF:FF:FF:FF:FF:FF +2024-05-22.01:56:06.205336|S|SAI_OBJECT_TYPE_NEIGHBOR_ENTRY||{"ip":"10.0.0.57","rif":"oid:0x6000000000727","switch_id":"oid:0x21000000000000"}|SAI_NEIGHBOR_ENTRY_ATTR_DST_MAC_ADDRESS=FF:FF:FF:FF:FF:00||{"ip":"10.0.0.59","rif":"oid:0x6000000000727","switch_id":"oid:0x21000000000000"}|SAI_NEIGHBOR_ENTRY_ATTR_DST_MAC_ADDRESS=FF:FF:FF:FF:FF:00 +2024-05-22.01:56:06.205336|R|SAI_OBJECT_TYPE_NEIGHBOR_ENTRY||{"ip":"10.0.0.57","rif":"oid:0x6000000000727","switch_id":"oid:0x21000000000000"}||{"ip":"10.0.0.59","rif":"oid:0x6000000000727","switch_id":"oid:0x21000000000000"} +2024-05-22.01:56:06.151337|a|APPLY_VIEW +2024-05-22.01:56:06.156740|A|SAI_STATUS_SUCCESS \ No newline at end of file diff --git a/unittest/lib/test_sai_redis_neighbor.cpp b/unittest/lib/test_sai_redis_neighbor.cpp new file mode 100644 index 000000000..9a7852410 --- /dev/null +++ b/unittest/lib/test_sai_redis_neighbor.cpp @@ -0,0 +1,30 @@ +#include + +extern "C" { +#include "sai.h" +} + +#include "swss/logger.h" + +TEST(libsairedis, neighbor) +{ + sai_neighbor_api_t *api = nullptr; + + sai_api_query(SAI_API_NEIGHBOR, (void**)&api); + + EXPECT_NE(api, nullptr); + + sai_neighbor_entry_t id ; + + EXPECT_NE(SAI_STATUS_SUCCESS, api->create_neighbor_entry(&id,0,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->remove_neighbor_entry(0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->set_neighbor_entry_attribute(0,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->get_neighbor_entry_attribute(0,0,0)); + + EXPECT_NE(SAI_STATUS_SUCCESS, api->create_neighbor_entries(0,0,0,0,SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->remove_neighbor_entries(0,0,SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->set_neighbor_entries_attribute(0,0,0,SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->get_neighbor_entries_attribute(0,0,0,0,SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR,0)); + + EXPECT_EQ(SAI_STATUS_NOT_IMPLEMENTED, api->remove_all_neighbor_entries(0)); +} diff --git a/unittest/vslib/test_sai_vs_neighbor.cpp b/unittest/vslib/test_sai_vs_neighbor.cpp new file mode 100644 index 000000000..3ad85a077 --- /dev/null +++ b/unittest/vslib/test_sai_vs_neighbor.cpp @@ -0,0 +1,30 @@ +#include + +extern "C" { +#include "sai.h" +} + +#include "swss/logger.h" + +TEST(libsaivs, neighbor) +{ + sai_neighbor_api_t *api = nullptr; + + sai_api_query(SAI_API_NEIGHBOR, (void**)&api); + + EXPECT_NE(api, nullptr); + + sai_neighbor_entry_t id ; + + EXPECT_NE(SAI_STATUS_SUCCESS, api->create_neighbor_entry(&id,0,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->remove_neighbor_entry(0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->set_neighbor_entry_attribute(0,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->get_neighbor_entry_attribute(0,0,0)); + + EXPECT_NE(SAI_STATUS_SUCCESS, api->create_neighbor_entries(0,0,0,0,SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->remove_neighbor_entries(0,0,SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->set_neighbor_entries_attribute(0,0,0,SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR,0)); + EXPECT_NE(SAI_STATUS_SUCCESS, api->get_neighbor_entries_attribute(0,0,0,0,SAI_BULK_OP_ERROR_MODE_IGNORE_ERROR,0)); + + EXPECT_EQ(SAI_STATUS_NOT_IMPLEMENTED, api->remove_all_neighbor_entries(0)); +}