global_data_type_registry.cpp

00001 /*
00002  * Copyright (C) 2014 Pavel Kirienko <pavel.kirienko@gmail.com>
00003  */
00004 
00005 #include <gtest/gtest.h>
00006 #include <uavcan/node/global_data_type_registry.hpp>
00007 
00008 namespace
00009 {
00010 
00011 struct DataTypeAMessage
00012 {
00013     enum { DefaultDataTypeID = 0 };
00014     enum { DataTypeKind = uavcan::DataTypeKindMessage };
00015     static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(123); }
00016     static const char* getDataTypeFullName() { return "my_namespace.DataTypeA"; }
00017 };
00018 
00019 struct DataTypeAService
00020 {
00021     enum { DefaultDataTypeID = 0 };
00022     enum { DataTypeKind = uavcan::DataTypeKindService };
00023     static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(789); }
00024     static const char* getDataTypeFullName() { return "my_namespace.DataTypeA"; }
00025 };
00026 
00027 struct DataTypeB
00028 {
00029     enum { DefaultDataTypeID = 42 };
00030     enum { DataTypeKind = uavcan::DataTypeKindMessage };
00031     static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(456); }
00032     static const char* getDataTypeFullName() { return "my_namespace.DataTypeB"; }
00033 };
00034 
00035 struct DataTypeC
00036 {
00037     enum { DefaultDataTypeID = 1023 };
00038     enum { DataTypeKind = uavcan::DataTypeKindMessage };
00039     static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(654); }
00040     static const char* getDataTypeFullName() { return "foo.DataTypeC"; }
00041 };
00042 
00043 struct DataTypeD
00044 {
00045     enum { DefaultDataTypeID = 43 };
00046     enum { DataTypeKind = uavcan::DataTypeKindService };
00047     static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(987); }
00048     static const char* getDataTypeFullName() { return "foo.DataTypeD"; }
00049 };
00050 
00051 template <typename Type>
00052 uavcan::DataTypeDescriptor extractDescriptor(uint16_t dtid = Type::DefaultDataTypeID)
00053 {
00054     return uavcan::DataTypeDescriptor(uavcan::DataTypeKind(Type::DataTypeKind), dtid,
00055                                       Type::getDataTypeSignature(), Type::getDataTypeFullName());
00056 }
00057 
00058 }
00059 
00060 
00061 TEST(GlobalDataTypeRegistry, Basic)
00062 {
00063     using uavcan::GlobalDataTypeRegistry;
00064     using uavcan::DataTypeSignature;
00065 
00066     GlobalDataTypeRegistry::instance().reset();
00067     ASSERT_FALSE(GlobalDataTypeRegistry::instance().isFrozen());
00068     ASSERT_EQ(0, GlobalDataTypeRegistry::instance().getNumMessageTypes());
00069     ASSERT_EQ(0, GlobalDataTypeRegistry::instance().getNumServiceTypes());
00070 
00071     /*
00072      * Static registrations
00073      */
00074     uavcan::DefaultDataTypeRegistrator<DataTypeAMessage> reg_DataTypeAMessage;
00075     uavcan::DefaultDataTypeRegistrator<DataTypeB> reg_DataTypeB;
00076 
00077     ASSERT_EQ(2, GlobalDataTypeRegistry::instance().getNumMessageTypes());
00078     ASSERT_EQ(0, GlobalDataTypeRegistry::instance().getNumServiceTypes());
00079 
00080     /*
00081      * Runtime registrations
00082      */
00083     ASSERT_EQ(GlobalDataTypeRegistry::RegistrationResultOk,
00084               GlobalDataTypeRegistry::instance().registerDataType<DataTypeAService>(
00085                   DataTypeAService::DefaultDataTypeID));
00086 
00087     ASSERT_EQ(2, GlobalDataTypeRegistry::instance().getNumMessageTypes());
00088     ASSERT_EQ(1, GlobalDataTypeRegistry::instance().getNumServiceTypes());
00089 
00090     /*
00091      * Runtime re-registration
00092      */
00093     ASSERT_EQ(GlobalDataTypeRegistry::RegistrationResultOk,
00094               GlobalDataTypeRegistry::instance().registerDataType<DataTypeAService>(147));
00095     ASSERT_EQ(GlobalDataTypeRegistry::RegistrationResultOk,
00096               GlobalDataTypeRegistry::instance().registerDataType<DataTypeB>(741));
00097 
00098     ASSERT_EQ(2, GlobalDataTypeRegistry::instance().getNumMessageTypes());
00099     ASSERT_EQ(1, GlobalDataTypeRegistry::instance().getNumServiceTypes());
00100 
00101     /*
00102      * These types will be necessary for the aggregate signature test
00103      */
00104     ASSERT_EQ(GlobalDataTypeRegistry::RegistrationResultCollision,
00105               GlobalDataTypeRegistry::instance().registerDataType<DataTypeC>(741));                   // ID COLLISION
00106 
00107     ASSERT_EQ(GlobalDataTypeRegistry::RegistrationResultOk,
00108               GlobalDataTypeRegistry::instance().registerDataType<DataTypeC>(DataTypeC::DefaultDataTypeID));
00109     uavcan::DefaultDataTypeRegistrator<DataTypeD> reg_DataTypeD;
00110 
00111     /*
00112      * Frozen state
00113      */
00114     GlobalDataTypeRegistry::instance().freeze();
00115 
00116     ASSERT_EQ(GlobalDataTypeRegistry::RegistrationResultFrozen,
00117               GlobalDataTypeRegistry::instance().registerDataType<DataTypeAService>(555)); // Rejected
00118 
00119     ASSERT_EQ(GlobalDataTypeRegistry::RegistrationResultFrozen,
00120               GlobalDataTypeRegistry::instance().registerDataType<DataTypeAMessage>(999)); // Rejected
00121 
00122     ASSERT_EQ(GlobalDataTypeRegistry::RegistrationResultFrozen,
00123               GlobalDataTypeRegistry::instance().registerDataType<DataTypeB>(888));        // Rejected
00124 
00125     /*
00126      * Searching
00127      */
00128     const uavcan::DataTypeDescriptor* pdtd = UAVCAN_NULLPTR;
00129     ASSERT_FALSE(GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindMessage, "Nonexistent"));
00130     ASSERT_FALSE(GlobalDataTypeRegistry::instance().find("Nonexistent"));
00131     ASSERT_FALSE(GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindMessage, 987));
00132     // Asking for service, but this is a message:
00133     ASSERT_FALSE(GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindService, "my_namespace.DataTypeB"));
00134     ASSERT_FALSE(GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindService, 42));
00135 
00136     ASSERT_TRUE((pdtd = GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindMessage,
00137                                                                 "my_namespace.DataTypeB")));
00138     ASSERT_TRUE((pdtd = GlobalDataTypeRegistry::instance().find("my_namespace.DataTypeB")));
00139     ASSERT_EQ(extractDescriptor<DataTypeB>(741), *pdtd);
00140     ASSERT_TRUE((pdtd = GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindMessage, 741)));
00141     ASSERT_EQ(extractDescriptor<DataTypeB>(741), *pdtd);
00142 
00143     ASSERT_TRUE((pdtd = GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindMessage,
00144                                                                 "my_namespace.DataTypeA")));
00145     ASSERT_TRUE((pdtd = GlobalDataTypeRegistry::instance().find("my_namespace.DataTypeA")));
00146     ASSERT_EQ(extractDescriptor<DataTypeAMessage>(), *pdtd);
00147     ASSERT_TRUE((pdtd = GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindMessage, uavcan::DataTypeID(0))));
00148     ASSERT_EQ(extractDescriptor<DataTypeAMessage>(), *pdtd);
00149 
00150     ASSERT_TRUE((pdtd = GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindService,
00151                                                                 "my_namespace.DataTypeA")));
00152     ASSERT_EQ(extractDescriptor<DataTypeAService>(147), *pdtd);
00153     ASSERT_TRUE((pdtd = GlobalDataTypeRegistry::instance().find(uavcan::DataTypeKindService, 147)));
00154     ASSERT_EQ(extractDescriptor<DataTypeAService>(147), *pdtd);
00155 }
00156 
00157 
00158 TEST(GlobalDataTypeRegistry, Reset)
00159 {
00160     using uavcan::GlobalDataTypeRegistry;
00161 
00162     /*
00163      * Since we're dealing with singleton, we need to reset it for other tests to use
00164      */
00165     ASSERT_TRUE(GlobalDataTypeRegistry::instance().isFrozen());
00166     GlobalDataTypeRegistry::instance().reset();
00167     ASSERT_FALSE(GlobalDataTypeRegistry::instance().isFrozen());
00168 }