storage.cpp

00001 /*
00002  * Copyright (C) 2015 Pavel Kirienko <pavel.kirienko@gmail.com>
00003  */
00004 
00005 #include <gtest/gtest.h>
00006 #include <uavcan/protocol/dynamic_node_id_server/centralized/storage.hpp>
00007 #include "../../helpers.hpp"
00008 #include "../memory_storage_backend.hpp"
00009 
00010 
00011 TEST(dynamic_node_id_server_centralized_Storage, Initialization)
00012 {
00013     using namespace uavcan::dynamic_node_id_server::centralized;
00014     using namespace uavcan::dynamic_node_id_server;
00015 
00016     // No data in the storage - initializing empty
00017     {
00018         MemoryStorageBackend storage;
00019         Storage stor(storage);
00020 
00021         ASSERT_EQ(0, storage.getNumKeys());
00022         ASSERT_LE(0, stor.init());
00023 
00024         ASSERT_EQ(0, storage.getNumKeys());
00025         ASSERT_EQ(0, stor.getSize());
00026 
00027         ASSERT_FALSE(stor.isNodeIDOccupied(1));
00028         ASSERT_FALSE(stor.isNodeIDOccupied(0));
00029     }
00030     // Nonempty storage, many items
00031     {
00032         MemoryStorageBackend storage;
00033         Storage stor(storage);
00034 
00035         storage.set("occupation_mask", "0e000000000000000000000000000000"); // node ID 1, 2, 3
00036         ASSERT_LE(0, stor.init());     // OK
00037 
00038         ASSERT_EQ(1, storage.getNumKeys());
00039         ASSERT_EQ(3, stor.getSize());
00040 
00041         ASSERT_TRUE(stor.isNodeIDOccupied(1));
00042         ASSERT_TRUE(stor.isNodeIDOccupied(2));
00043         ASSERT_TRUE(stor.isNodeIDOccupied(3));
00044         ASSERT_FALSE(stor.isNodeIDOccupied(0));
00045         ASSERT_FALSE(stor.isNodeIDOccupied(4));
00046 
00047         UniqueID uid_1;
00048         uid_1[0] = 1;
00049 
00050         UniqueID uid_2;
00051         uid_2[0] = 2;
00052 
00053         UniqueID uid_3;
00054         uid_3[0] = 3;
00055 
00056         ASSERT_FALSE(stor.getNodeIDForUniqueID(uid_1).isValid());
00057         ASSERT_FALSE(stor.getNodeIDForUniqueID(uid_2).isValid());
00058         ASSERT_FALSE(stor.getNodeIDForUniqueID(uid_3).isValid());
00059         ASSERT_FALSE(stor.isNodeIDOccupied(127));
00060 
00061         storage.set("01000000000000000000000000000000", "1");
00062         storage.set("02000000000000000000000000000000", "2");
00063         storage.set("03000000000000000000000000000000", "3");
00064 
00065         ASSERT_EQ(1, stor.getNodeIDForUniqueID(uid_1).get());
00066         ASSERT_EQ(2, stor.getNodeIDForUniqueID(uid_2).get());
00067         ASSERT_EQ(3, stor.getNodeIDForUniqueID(uid_3).get());
00068         ASSERT_FALSE(stor.isNodeIDOccupied(127));
00069     }
00070 }
00071 
00072 
00073 TEST(dynamic_node_id_server_centralized_Storage, Basic)
00074 {
00075     using namespace uavcan::dynamic_node_id_server::centralized;
00076 
00077     MemoryStorageBackend storage;
00078     Storage stor(storage);
00079 
00080     ASSERT_EQ(0, storage.getNumKeys());
00081     ASSERT_LE(0, stor.init());
00082     storage.print();
00083     ASSERT_EQ(0, storage.getNumKeys());
00084 
00085     /*
00086      * Adding one entry to the log, making sure it appears in the storage
00087      */
00088     uavcan::dynamic_node_id_server::UniqueID unique_id;
00089     unique_id[0] = 1;
00090     ASSERT_LE(0, stor.add(1, unique_id));
00091 
00092     ASSERT_EQ("02000000000000000000000000000000", storage.get("occupation_mask"));
00093     ASSERT_EQ("1",                                storage.get("01000000000000000000000000000000"));
00094 
00095     ASSERT_EQ(2, storage.getNumKeys());
00096     ASSERT_EQ(1, stor.getSize());
00097 
00098     /*
00099      * Adding another entry while storage is failing
00100      */
00101     storage.failOnSetCalls(true);
00102 
00103     ASSERT_EQ(2, storage.getNumKeys());
00104 
00105     unique_id[0] = 2;
00106     ASSERT_GT(0, stor.add(2, unique_id));
00107 
00108     ASSERT_EQ(2, storage.getNumKeys());  // No new entries, we failed
00109 
00110     ASSERT_EQ(1, stor.getSize());
00111 
00112     /*
00113      * Adding a lot of entries
00114      */
00115     storage.failOnSetCalls(false);
00116 
00117     uavcan::NodeID node_id(2);
00118     while (stor.getSize() < 127)
00119     {
00120         ASSERT_LE(0, stor.add(node_id, unique_id));
00121 
00122         ASSERT_TRUE(stor.getNodeIDForUniqueID(unique_id).isValid());
00123         ASSERT_TRUE(stor.isNodeIDOccupied(node_id));
00124 
00125         node_id = uint8_t(uavcan::min(node_id.get() + 1U, 127U));
00126         unique_id[0] = uint8_t(unique_id[0] + 1U);
00127     }
00128 
00129     storage.print();
00130 }