/***********************************************************************//**
* @brief Test XML attributes
**************************************************************************/
void TestGXml::test_GXml_attributes(void)
{
// Test attribute name-value constructors
GXmlAttribute attr1("test", "1.0");
test_assert(attr1.value() == "1.0", "Test if value()= 1.0",
"Unexpected attribute "+attr1.value());
GXmlAttribute attr2("test", "\"1.0\"");
test_assert(attr2.value() == "1.0", "Test if value()= 1.0",
"Unexpected attribute "+attr2.value());
GXmlAttribute attr3("test", "'1.0'");
test_assert(attr3.value() == "1.0", "Test if value()= 1.0",
"Unexpected attribute "+attr3.value());
GXmlAttribute attr4("test", "''1.0'");
test_assert(attr4.value() == "'1.0", "Test if value()= '1.0",
"Unexpected attribute "+attr4.value());
GXmlAttribute attr5("test", "'1.0");
test_assert(attr5.value() == "'1.0", "Test if value()= '1.0",
"Unexpected attribute "+attr5.value());
GXmlAttribute attr6("test", "1.0'");
test_assert(attr6.value() == "1.0'", "Test if value()= 1.0'",
"Unexpected attribute "+attr6.value());
GXmlAttribute attr7("test", "\"1.0");
test_assert(attr7.value() == "\"1.0", "Test if value()= \"1.0",
"Unexpected attribute "+attr7.value());
GXmlAttribute attr8("test", "1.0\"");
test_assert(attr8.value() == "1.0\"", "Test if value()= 1.0\"",
"Unexpected attribute "+attr8.value());
GXmlAttribute attr9("test", "\"\"1.0\"");
test_assert(attr9.value() == "\"1.0", "Test if value()= \"1.0",
"Unexpected attribute "+attr9.value());
// Return
return;
}
bool derived_obj_t::push_leaf_attr_to_npu (nas_attr_id_t attr_id,
npu_id_t npu_id)
{
t_std_error rc = STD_ERR_OK;
switch (attr_id)
{
case BASE_UT_ATTR1:
if ((rc = ndi_ut_obj_attr1_set (npu_id, ndi_obj_id(npu_id),
attr1()))
!= STD_ERR_OK)
{
throw nas::base_exception {rc, __PRETTY_FUNCTION__,
std::string {"NDI Fail: Set Attr1 in NPU "}
+ std::to_string (npu_id)};
}
break;
case BASE_UT_ATTR2:
if ((rc = ndi_ut_obj_attr2_set (npu_id, ndi_obj_id(npu_id),
attr2()))
!= STD_ERR_OK)
{
throw nas::base_exception {rc, __PRETTY_FUNCTION__,
std::string {"NDI Fail: Set Attr2 in NPU "}
+ std::to_string (npu_id)};
}
break;
default:
STD_ASSERT (0);
}
return true;
}
// The test checks that Boost.Format formatting works
BOOST_AUTO_TEST_CASE_TEMPLATE(formatting, CharT, char_types)
{
typedef logging::attribute_set attr_set;
typedef std::basic_string< CharT > string;
typedef logging::basic_formatting_ostream< CharT > osstream;
typedef logging::record_view record_view;
typedef logging::basic_formatter< CharT > formatter;
typedef format_test_data< CharT > data;
attrs::constant< int > attr1(10);
attrs::constant< double > attr2(5.5);
attr_set set1;
set1[data::attr1()] = attr1;
set1[data::attr2()] = attr2;
record_view rec = make_record_view(set1);
{
string str1, str2;
osstream strm1(str1), strm2(str2);
formatter f = expr::format(data::format1()) % expr::attr< int >(data::attr1()) % expr::attr< double >(data::attr2());
f(rec, strm1);
strm2 << 10 << ", " << 5.5;
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
}
// The test checks that Boost.Format formatting works
BOOST_AUTO_TEST_CASE_TEMPLATE(formatting, CharT, char_types)
{
typedef logging::basic_attribute_set< CharT > attr_set;
typedef std::basic_string< CharT > string;
typedef std::basic_ostringstream< CharT > osstream;
typedef logging::basic_record< CharT > record;
typedef boost::function< void (osstream&, record const&) > formatter;
typedef format_test_data< CharT > data;
attrs::constant< int > attr1(10);
attrs::constant< double > attr2(5.5);
attr_set set1;
set1[data::attr1()] = attr1;
set1[data::attr2()] = attr2;
record rec = make_record(set1);
rec.message() = data::some_test_string();
{
osstream strm1;
formatter f = fmt::format(data::format1()) % fmt::attr< int >(data::attr1()) % fmt::attr< double >(data::attr2());
f(strm1, rec);
osstream strm2;
strm2 << 10 << ", " << 5.5;
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
}
void test_a_dbobject_with_an_object::should_store_unsigned_long_attributes()
{
// Add unsigned long attributes to the object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
unsigned long value1 = 0x12345678;
unsigned long value2 = 0x87654321;
unsigned long value3 = 0x01010101;
unsigned long value4 = 0x10101010;
unsigned long value5 = 0xABCDEF;
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
OSAttribute attr4(value4);
OSAttribute attr5(value5);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_MODULUS_BITS, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_AUTH_PIN_FLAGS, attr3));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SUBPRIME_BITS, attr4));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_KEY_TYPE, attr5));
}
// Now read back the object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_MODULUS_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_PRIME_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_AUTH_PIN_FLAGS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SUBPRIME_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_KEY_TYPE));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_MODULUS_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_AUTH_PIN_FLAGS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBPRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_KEY_TYPE)->isUnsignedLongAttribute());
CPPUNIT_ASSERT_EQUAL(testObject.getAttribute(CKA_MODULUS_BITS)->getUnsignedLongValue(), (unsigned long)0x12345678);
CPPUNIT_ASSERT_EQUAL(testObject.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue(), (unsigned long)0x87654321);
CPPUNIT_ASSERT_EQUAL(testObject.getAttribute(CKA_AUTH_PIN_FLAGS)->getUnsignedLongValue(), (unsigned long)0x01010101);
CPPUNIT_ASSERT_EQUAL(testObject.getAttribute(CKA_SUBPRIME_BITS)->getUnsignedLongValue(), (unsigned long)0x10101010);
CPPUNIT_ASSERT_EQUAL(testObject.getAttribute(CKA_KEY_TYPE)->getUnsignedLongValue(), (unsigned long)0xABCDEF);
unsigned long value6 = 0x90909090;
OSAttribute attr6(value6);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_CLASS, attr6));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_CLASS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT_EQUAL(testObject.getAttribute(CKA_CLASS)->getUnsignedLongValue(), value6);
}
}
void SessionObjectTests::testDoubleAttr()
{
ByteString value3 = "BDEBDBEDBBDBEBDEBE792759537328";
ByteString value3a = "466487346943785684957634";
SessionObject testObject(NULL, 1, 1);
CPPUNIT_ASSERT(testObject.isValid());
bool value1 = true;
unsigned long value2 = 0x87654321;
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VALUE_BITS, attr3));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_TOKEN));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_PRIME_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_VALUE_BITS));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->getBooleanValue() == true);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue() == 0x87654321);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS)->getByteStringValue() == value3);
bool value1a = false;
unsigned long value2a = 0x76767676;
OSAttribute attr1a(value1a);
OSAttribute attr2a(value2a);
OSAttribute attr3a(value3a);
// Change the attributes
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1a));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2a));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VALUE_BITS, attr3a));
// Check the attributes
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->getBooleanValue() == value1a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue() == value2a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS)->getByteStringValue() == value3a);
CPPUNIT_ASSERT(testObject.isValid());
}
// The test checks that message formatting work
BOOST_AUTO_TEST_CASE_TEMPLATE(message_formatting, CharT, char_types)
{
typedef logging::attribute_set attr_set;
typedef std::basic_string< CharT > string;
typedef logging::basic_formatting_ostream< CharT > osstream;
typedef logging::record_view record_view;
typedef logging::basic_formatter< CharT > formatter;
typedef message_test_data< CharT > data;
attrs::constant< int > attr1(10);
attrs::constant< double > attr2(5.5);
attr_set set1;
set1[data::attr1()] = attr1;
set1[data::attr2()] = attr2;
set1[data::message().get_name()] = attrs::constant< string >(data::some_test_string());
record_view rec = make_record_view(set1);
{
string str1, str2;
osstream strm1(str1), strm2(str2);
formatter f = expr::stream << data::message();
f(rec, strm1);
strm2 << data::some_test_string();
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
}
void SessionObjectTests::testMixedAttr()
{
ByteString value3 = "BDEBDBEDBBDBEBDEBE792759537328";
SessionObject testObject(NULL, 1, 1);
CPPUNIT_ASSERT(testObject.isValid());
bool value1 = true;
unsigned long value2 = 0x87654321;
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VALUE_BITS, attr3));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_TOKEN));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_PRIME_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_VALUE_BITS));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->getBooleanValue() == true);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue() == 0x87654321);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS)->getByteStringValue() == value3);
}
void test_a_dbobject_with_an_object::should_store_binary_attributes()
{
ByteString value1 = "010203040506070809";
ByteString value2 = "ABABABABABABABABABABABABABABABABAB";
unsigned long value3 = 0xBDED;
ByteString value4 = "98A7E5D798A7E5D798A7E5D798A7E5D798A7E5D798A7E5D7";
ByteString value5 = "ABCDABCDABCDABCDABCDABCDABCDABCD";
// Create the test object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
OSAttribute attr4(value4);
OSAttribute attr5(value5);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_MODULUS, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_COEFFICIENT, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VALUE_BITS, attr3));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PUBLIC_EXPONENT, attr4));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SUBJECT, attr5));
}
// Now read back the object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_MODULUS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_COEFFICIENT));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_VALUE_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_PUBLIC_EXPONENT));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SUBJECT));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_MODULUS).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_COEFFICIENT).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PUBLIC_EXPONENT).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_MODULUS).getByteStringValue() == value1);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_COEFFICIENT).getByteStringValue() == value2);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() == value3);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PUBLIC_EXPONENT).getByteStringValue() == value4);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT).getByteStringValue() == value5);
ByteString value6 = "909090908080808080807070707070FF";
OSAttribute attr6(value6);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_ISSUER, attr6));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ISSUER).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getByteStringValue(CKA_ISSUER) == value6);
}
}
void test_a_dbobject_with_an_object::should_store_boolean_attributes()
{
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
bool value1 = true;
bool value2 = false;
bool value3 = true;
bool value4 = true;
bool value5 = false;
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
OSAttribute attr4(value4);
OSAttribute attr5(value5);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SENSITIVE, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_EXTRACTABLE, attr3));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_NEVER_EXTRACTABLE, attr4));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SIGN, attr5));
}
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_TOKEN));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SENSITIVE));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_EXTRACTABLE));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_NEVER_EXTRACTABLE));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SIGN));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SENSITIVE).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_EXTRACTABLE).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_NEVER_EXTRACTABLE).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SIGN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).getBooleanValue());
CPPUNIT_ASSERT(!testObject.getAttribute(CKA_SENSITIVE).getBooleanValue());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_EXTRACTABLE).getBooleanValue());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_NEVER_EXTRACTABLE).getBooleanValue());
CPPUNIT_ASSERT(!testObject.getAttribute(CKA_SIGN).getBooleanValue());
bool value6 = true;
OSAttribute attr6(value6);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VERIFY, attr6));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VERIFY).isBooleanAttribute());
CPPUNIT_ASSERT_EQUAL(testObject.getAttribute(CKA_VERIFY).getBooleanValue(), value6);
CPPUNIT_ASSERT_EQUAL(testObject.getBooleanValue(CKA_VERIFY, false), value6);
}
}
void* derived_obj_t::alloc_fill_ndi_obj (nas::mem_alloc_helper_t& mem_trakr)
{
ndi_ut_obj_t* ndi_ut_obj_p = mem_trakr.alloc<ndi_ut_obj_t> (1);
ndi_ut_obj_p->attr1 = attr1();
ndi_ut_obj_p->attr2 = attr2();
return ndi_ut_obj_p;
}
void SessionObjectTests::testBoolAttr()
{
SessionObject testObject(NULL, 1, 1);
CPPUNIT_ASSERT(testObject.isValid());
bool value1 = true;
bool value2 = false;
bool value3 = true;
bool value4 = true;
bool value5 = false;
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
OSAttribute attr4(value4);
OSAttribute attr5(value5);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SENSITIVE, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_EXTRACTABLE, attr3));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_NEVER_EXTRACTABLE, attr4));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SIGN, attr5));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_TOKEN));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SENSITIVE));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_EXTRACTABLE));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_NEVER_EXTRACTABLE));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SIGN));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SENSITIVE)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_EXTRACTABLE)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_NEVER_EXTRACTABLE)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SIGN)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID) == NULL);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->getBooleanValue() == true);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SENSITIVE)->getBooleanValue() == false);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_EXTRACTABLE)->getBooleanValue() == true);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_NEVER_EXTRACTABLE)->getBooleanValue() == true);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SIGN)->getBooleanValue() == false);
bool value6 = true;
OSAttribute attr6(value6);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VERIFY, attr6));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VERIFY)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VERIFY)->getBooleanValue() == value6);
}
void SessionObjectTests::testByteStrAttr()
{
ByteString value1 = "010203040506070809";
ByteString value2 = "ABABABABABABABABABABABABABABABABAB";
ByteString value3 = "BDEBDBEDBBDBEBDEBE792759537328";
ByteString value4 = "98A7E5D798A7E5D798A7E5D798A7E5D798A7E5D798A7E5D7";
ByteString value5 = "ABCDABCDABCDABCDABCDABCDABCDABCD";
SessionObject testObject(NULL, 1, 1);
CPPUNIT_ASSERT(testObject.isValid());
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
OSAttribute attr4(value4);
OSAttribute attr5(value5);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_MODULUS, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_COEFFICIENT, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VALUE_BITS, attr3));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PUBLIC_EXPONENT, attr4));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SUBJECT, attr5));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_MODULUS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_COEFFICIENT));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_VALUE_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_PUBLIC_EXPONENT));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SUBJECT));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_MODULUS)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_COEFFICIENT)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PUBLIC_EXPONENT)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_MODULUS)->getByteStringValue() == value1);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_COEFFICIENT)->getByteStringValue() == value2);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS)->getByteStringValue() == value3);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PUBLIC_EXPONENT)->getByteStringValue() == value4);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT)->getByteStringValue() == value5);
ByteString value6 = "909090908080808080807070707070FF";
OSAttribute attr6(value6);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_ISSUER, attr6));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ISSUER)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ISSUER)->getByteStringValue() == value6);
}
void SessionObjectTests::testULongAttr()
{
SessionObject testObject(NULL, 1, 1);
CPPUNIT_ASSERT(testObject.isValid());
unsigned long value1 = 0x12345678;
unsigned long value2 = 0x87654321;
unsigned long value3 = 0x01010101;
unsigned long value4 = 0x10101010;
unsigned long value5 = 0xABCDEF;
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
OSAttribute attr4(value4);
OSAttribute attr5(value5);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_MODULUS_BITS, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_AUTH_PIN_FLAGS, attr3));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SUBPRIME_BITS, attr4));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_KEY_TYPE, attr5));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_MODULUS_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_PRIME_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_AUTH_PIN_FLAGS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SUBPRIME_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_KEY_TYPE));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_MODULUS_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_AUTH_PIN_FLAGS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBPRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_KEY_TYPE)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_MODULUS_BITS)->getUnsignedLongValue() == 0x12345678);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue() == 0x87654321);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_AUTH_PIN_FLAGS)->getUnsignedLongValue() == 0x01010101);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBPRIME_BITS)->getUnsignedLongValue() == 0x10101010);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_KEY_TYPE)->getUnsignedLongValue() == 0xABCDEF);
unsigned long value6 = 0x90909090;
OSAttribute attr6(value6);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_CLASS, attr6));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_CLASS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_CLASS)->getUnsignedLongValue() == value6);
}
// The test checks invokers specialized on a single attribute value type
BOOST_AUTO_TEST_CASE_TEMPLATE(single_type, CharT, char_types)
{
typedef logging::basic_attribute_set< CharT > attr_set;
typedef logging::basic_attribute_values_view< CharT > values_view;
typedef test_data< CharT > data;
attrs::constant< int > attr1(10);
attrs::constant< double > attr2(5.5);
attrs::constant< std::string > attr3("Hello, world!");
attr_set set1, set2, set3;
set1[data::attr1()] = attr1;
set1[data::attr2()] = attr2;
values_view view1(set1, set2, set3);
view1.freeze();
my_receiver recv;
logging::value_visitor_invoker< CharT, int > invoker1(data::attr1());
logging::value_visitor_invoker< CharT, double > invoker2(data::attr2());
logging::value_visitor_invoker< CharT, std::string > invoker3(data::attr3());
logging::value_visitor_invoker< CharT, char > invoker4(data::attr1());
logging::value_visitor_invoker< CharT, int > invoker5(data::attr2());
// These two extractors will find their values in the view
recv.set_expected(10);
BOOST_CHECK(invoker1(view1, recv));
recv.set_expected(5.5);
BOOST_CHECK(invoker2(view1, recv));
// This one will not
recv.set_expected();
BOOST_CHECK(!invoker3(view1, recv));
// But it will find it in this view
set1[data::attr3()] = attr3;
values_view view2(set1, set2, set3);
view2.freeze();
recv.set_expected("Hello, world!");
BOOST_CHECK(invoker3(view2, recv));
// This one will find the sought attribute value, but it will have an incorrect type
recv.set_expected();
BOOST_CHECK(!invoker4(view1, recv));
// This one is the same, but there is a value of the requested type in the view
BOOST_CHECK(!invoker5(view1, recv));
}
void test_a_dbobject_with_an_object::should_store_array_attributes()
{
bool value1 = true;
unsigned long value2 = 0x87654321;
ByteString value3 = "BDEBDBEDBBDBEBDEBE792759537328";
// Create the test object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
std::map<CK_ATTRIBUTE_TYPE,OSAttribute> mattr;
mattr.insert(std::pair<CK_ATTRIBUTE_TYPE,OSAttribute> (CKA_TOKEN, attr1));
mattr.insert(std::pair<CK_ATTRIBUTE_TYPE,OSAttribute> (CKA_PRIME_BITS, attr2));
mattr.insert(std::pair<CK_ATTRIBUTE_TYPE,OSAttribute> (CKA_VALUE_BITS, attr3));
OSAttribute attra(mattr);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_WRAP_TEMPLATE, attra));
}
// Now read back the object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_WRAP_TEMPLATE));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_UNWRAP_TEMPLATE));
std::map<CK_ATTRIBUTE_TYPE,OSAttribute> mattrb = testObject.getAttribute(CKA_WRAP_TEMPLATE).getArrayValue();
CPPUNIT_ASSERT(mattrb.size() == 3);
CPPUNIT_ASSERT(mattrb.find(CKA_TOKEN) != mattrb.end());
CPPUNIT_ASSERT(mattrb.at(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(mattrb.at(CKA_TOKEN).getBooleanValue() == true);
CPPUNIT_ASSERT(mattrb.find(CKA_PRIME_BITS) != mattrb.end());
CPPUNIT_ASSERT(mattrb.at(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(mattrb.at(CKA_PRIME_BITS).getUnsignedLongValue() == 0x87654321);
CPPUNIT_ASSERT(mattrb.find(CKA_VALUE_BITS) != mattrb.end());
CPPUNIT_ASSERT(mattrb.at(CKA_VALUE_BITS).isByteStringAttribute());
CPPUNIT_ASSERT(mattrb.at(CKA_VALUE_BITS).getByteStringValue() == value3);
}
}
// The test checks invokers specialized with type lists
BOOST_AUTO_TEST_CASE_TEMPLATE(multiple_types, CharT, char_types)
{
typedef logging::basic_attribute_set< CharT > attr_set;
typedef logging::basic_attribute_values_view< CharT > values_view;
typedef test_data< CharT > data;
typedef mpl::vector< int, double, std::string, char >::type types;
attrs::constant< int > attr1(10);
attrs::constant< double > attr2(5.5);
attrs::constant< std::string > attr3("Hello, world!");
attr_set set1, set2, set3;
set1[data::attr1()] = attr1;
set1[data::attr2()] = attr2;
values_view view1(set1, set2, set3);
view1.freeze();
my_receiver recv;
logging::value_visitor_invoker< CharT, types > invoker1(data::attr1());
logging::value_visitor_invoker< CharT, types > invoker2(data::attr2());
logging::value_visitor_invoker< CharT, types > invoker3(data::attr3());
// These two extractors will find their values in the view
recv.set_expected(10);
BOOST_CHECK(invoker1(view1, recv));
recv.set_expected(5.5);
BOOST_CHECK(invoker2(view1, recv));
// This one will not
recv.set_expected();
BOOST_CHECK(!invoker3(view1, recv));
// But it will find it in this view
set1[data::attr3()] = attr3;
values_view view2(set1, set2, set3);
view2.freeze();
recv.set_expected("Hello, world!");
BOOST_CHECK(invoker3(view2, recv));
}
void test_a_dbobject_with_an_object::should_store_mixed_attributes()
{
bool value1 = true;
unsigned long value2 = 0x87654321;
unsigned long value3 = 0xBDEBDBED;
// Create the test object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VALUE_BITS, attr3));
}
// Now read back the object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_TOKEN));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_PRIME_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_VALUE_BITS));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).getBooleanValue());
CPPUNIT_ASSERT_EQUAL(testObject.getAttribute(CKA_PRIME_BITS).getUnsignedLongValue(), value2);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() == value3);
}
}
// The test checks that conditional formatting work
BOOST_AUTO_TEST_CASE_TEMPLATE(conditional_formatting, CharT, char_types)
{
typedef logging::attribute_set attr_set;
typedef std::basic_string< CharT > string;
typedef logging::basic_formatting_ostream< CharT > osstream;
typedef logging::record_view record_view;
typedef logging::basic_formatter< CharT > formatter;
typedef test_data< CharT > data;
attrs::constant< int > attr1(10);
attrs::constant< double > attr2(5.5);
attr_set set1;
set1[data::attr1()] = attr1;
set1[data::attr2()] = attr2;
record_view rec = make_record_view(set1);
// Check for various modes of attribute value type specification
{
string str1, str2;
osstream strm1(str1), strm2(str2);
formatter f = expr::stream <<
expr::if_(expr::has_attr< int >(data::attr1()))
[
expr::stream << expr::attr< int >(data::attr1())
];
f(rec, strm1);
strm2 << 10;
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
{
string str1;
osstream strm1(str1);
formatter f = expr::stream <<
expr::if_(expr::has_attr< int >(data::attr2()))
[
expr::stream << expr::attr< int >(data::attr2())
];
f(rec, strm1);
BOOST_CHECK(equal_strings(strm1.str(), string()));
}
{
string str1, str2;
osstream strm1(str1), strm2(str2);
formatter f = expr::stream <<
expr::if_(expr::has_attr< int >(data::attr1()))
[
expr::stream << expr::attr< int >(data::attr1())
]
.else_
[
expr::stream << expr::attr< double >(data::attr2())
];
f(rec, strm1);
strm2 << 10;
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
{
string str1, str2;
osstream strm1(str1), strm2(str2);
formatter f = expr::stream <<
expr::if_(expr::has_attr< int >(data::attr2()))
[
expr::stream << expr::attr< int >(data::attr1())
]
.else_
[
expr::stream << expr::attr< double >(data::attr2())
];
f(rec, strm1);
strm2 << 5.5;
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
}
void main()
{
std::cout<< "\n PNode<T> class demonstration";
std::cout<< "\n ============================\n";
//initialize
PNode<std::string > root("root");
PNode<std::string > child1("child1");
PNode<std::string > child2("child2");
PNode<std::string > grandchild11("grandchild11");
PNode<std::string > grandchild21("grandchild21");
PNode<std::string > grandchild22("grandchild22");
PNode<std::string > grandgrandchild211("grandgrandchild211");
PNode<std::string > child3("child3");
//test adding
child1.add(&grandchild11);
grandchild21.add(&grandgrandchild211);
child2.add(&grandchild21);
child2.add(&grandchild22);
root.add(&child1);
root.add(&child2);
root.add(&child3);
WalkTree(&root);
//test removing, mark operation
std::cout<<"\n\n removing first child";
root.remove(&child1);
std::cout<<"\n unmarked all nodes";
root.setMarkState(true);
child1.setMarkState(true);
grandchild11.setMarkState(true);
child2.setMarkState(true);
grandchild21.setMarkState(true);
grandchild22.setMarkState(true);
grandgrandchild211.setMarkState(true);
child3.setMarkState(true);
//show the tree
WalkTree(&root);
std::cout<<"\n\n";
std::cout<<"===========================XMLValues Test==================================="<<std::endl;
XMLValue xmlv(XMLValue::TAG, "MyTag");
Attribute attr1("ATTR1","1");
Attribute attr2("ATTR2","2");
Attribute attr3("ATTR3","3");
xmlv.AddAttr("ATTR1","1");
xmlv.AddAttr("ATTR2","2");
xmlv.AddAttr("ATTR3","3");
//test == operator
std::cout<<"Attribute Compare:\n"<<"attr1 == attr1: "<< (attr1 == attr1) <<"; attr2 == attr1: "<< (attr2 == attr1)<<std::endl;
//test search and find attributes
for(size_t i=0; i< xmlv.attributes().size();++i)
std::cout<<xmlv.attributes().at(i).AttrName.c_str()<<" "<<xmlv.attributes().at(i).AttrValue.c_str() <<std::endl;
std::cout<<"Find ATTR2's index: "<<xmlv.Find("ATTR2","2")<<std::endl;
std::cout<<"Find ATTR4's index: "<<xmlv.Find("ATTR4","4")<<std::endl;
//test removing attributes
xmlv.RemoveAttr("ATTR2","2");
std::cout<<"====================ATTR2 Removed==========================\n";
for(size_t i=0; i< xmlv.attributes().size();++i)
std::cout<<xmlv.attributes().at(i).AttrName.c_str()<<" "<<xmlv.attributes().at(i).AttrValue.c_str() <<std::endl;
std::cout<<"=================Nodes with XMLValues======================"<<std::endl;
PNode<XMLValue> xmlroot(xmlv);
PNode<XMLValue> xmlcld1(XMLValue(XMLValue::TAG,"xmlChild1"));
PNode<XMLValue> xmlcld2(XMLValue(XMLValue::TAG,"xmlChild2"));
xmlroot.add(&xmlcld1);
xmlroot.add(&xmlcld2);
PNode<XMLValue> *pTemp;
//test searching through the tree
while (pTemp = xmlroot.nextUnmarkedChild())
{
std::cout<<"The child of root: "<<pTemp->value().TagName()<<std::endl;
pTemp->setMarkState(true);
}
std::cout<<"=================Children of Nodes======================"<<std::endl;
for (size_t i = 0; i < xmlroot.getChildren().size(); i++)
std::cout<<"a Child of ROOT: "<<xmlroot.getChildren()[i].TagName()<<std::endl;
::system("pause");
}
/// Creates a suitable HTML fragment for a definition
wxString wxRichTextStyleListBox::CreateHTML(wxRichTextStyleDefinition* def) const
{
// TODO: indicate list format for list style types
wxString str;
bool isCentred = false;
wxRichTextAttr attr(def->GetStyleMergedWithBase(GetStyleSheet()));
if (attr.HasAlignment() && attr.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
isCentred = true;
str << wxT("<html><head></head>");
str << wxT("<body");
if (attr.GetBackgroundColour().Ok())
str << wxT(" bgcolor=\"#") << ColourToHexString(attr.GetBackgroundColour()) << wxT("\"");
str << wxT(">");
if (isCentred)
str << wxT("<center>");
str << wxT("<table");
if (attr.GetBackgroundColour().Ok())
str << wxT(" bgcolor=\"#") << ColourToHexString(attr.GetBackgroundColour()) << wxT("\"");
str << wxT("><tr>");
if (attr.GetLeftIndent() > 0)
{
wxClientDC dc((wxWindow*) this);
str << wxT("<td width=") << wxMin(50, (ConvertTenthsMMToPixels(dc, attr.GetLeftIndent())/2)) << wxT("></td>");
}
if (isCentred)
str << wxT("<td nowrap align=\"center\">");
else
str << wxT("<td nowrap>");
#ifdef __WXMSW__
int size = 2;
#else
int size = 3;
#endif
// Guess a standard font size
int stdFontSize = 0;
// First see if we have a default/normal style to base the size on
wxString normalTranslated(_("normal"));
wxString defaultTranslated(_("default"));
size_t i;
for (i = 0; i < GetStyleSheet()->GetParagraphStyleCount(); i++)
{
wxRichTextStyleDefinition* d = GetStyleSheet()->GetParagraphStyle(i);
wxString name = d->GetName().Lower();
if (name.Find(wxT("normal")) != wxNOT_FOUND || name.Find(normalTranslated) != wxNOT_FOUND ||
name.Find(wxT("default")) != wxNOT_FOUND || name.Find(defaultTranslated) != wxNOT_FOUND)
{
wxRichTextAttr attr2(d->GetStyleMergedWithBase(GetStyleSheet()));
if (attr2.HasFontPointSize())
{
stdFontSize = attr2.GetFontSize();
break;
}
}
}
if (stdFontSize == 0)
{
// Look at sizes up to 20 points, and see which is the most common
wxArrayInt sizes;
size_t maxSize = 20;
for (i = 0; i <= maxSize; i++)
sizes.Add(0);
for (i = 0; i < m_styleNames.GetCount(); i++)
{
wxRichTextStyleDefinition* d = GetStyle(i);
if (d)
{
wxRichTextAttr attr2(d->GetStyleMergedWithBase(GetStyleSheet()));
if (attr2.HasFontPointSize())
{
if (attr2.GetFontSize() <= (int) maxSize)
sizes[attr2.GetFontSize()] ++;
}
}
}
int mostCommonSize = 0;
for (i = 0; i <= maxSize; i++)
{
if (sizes[i] > mostCommonSize)
mostCommonSize = i;
}
if (mostCommonSize > 0)
stdFontSize = mostCommonSize;
}
if (stdFontSize == 0)
stdFontSize = 12;
int thisFontSize = attr.HasFontPointSize() ? attr.GetFontSize() : stdFontSize;
if (thisFontSize < stdFontSize)
size --;
else if (thisFontSize > stdFontSize)
size ++;
str += wxT("<font");
str << wxT(" size=") << size;
if (!attr.GetFontFaceName().IsEmpty())
str << wxT(" face=\"") << attr.GetFontFaceName() << wxT("\"");
if (attr.GetTextColour().IsOk() && attr.GetTextColour() != attr.GetBackgroundColour() && !(!attr.HasBackgroundColour() && attr.GetTextColour() == *wxWHITE))
str << wxT(" color=\"#") << ColourToHexString(attr.GetTextColour()) << wxT("\"");
if (attr.GetBackgroundColour().Ok())
str << wxT(" bgcolor=\"#") << ColourToHexString(attr.GetBackgroundColour()) << wxT("\"");
str << wxT(">");
bool hasBold = false;
bool hasItalic = false;
bool hasUnderline = false;
if (attr.GetFontWeight() == wxFONTWEIGHT_BOLD)
hasBold = true;
if (attr.GetFontStyle() == wxFONTSTYLE_ITALIC)
hasItalic = true;
if (attr.GetFontUnderlined())
hasUnderline = true;
if (hasBold)
str << wxT("<b>");
if (hasItalic)
str << wxT("<i>");
if (hasUnderline)
str << wxT("<u>");
wxString name(def->GetName());
if (attr.HasTextEffects() && (attr.GetTextEffects() & (wxTEXT_ATTR_EFFECT_CAPITALS|wxTEXT_ATTR_EFFECT_SMALL_CAPITALS)))
name = name.Upper();
str += name;
if (hasUnderline)
str << wxT("</u>");
if (hasItalic)
str << wxT("</i>");
if (hasBold)
str << wxT("</b>");
if (isCentred)
str << wxT("</centre>");
str << wxT("</font>");
str << wxT("</td></tr></table>");
if (isCentred)
str << wxT("</center>");
str << wxT("</body></html>");
return str;
}
IMPLEMENT_TEST(SQLiteObjectDbiUnitTests, removeMsaObject) {
U2OpStatusImpl os;
U2MsaDbi* msaDbi = SQLiteObjectDbiTestData::getMsaDbi();
// FIRST ALIGNMENT
// Create an alignment
U2DataId msaId = msaDbi->createMsaObject("", "Test name", BaseDNAAlphabetIds::NUCL_DNA_DEFAULT(), os);
CHECK_NO_ERROR(os);
// Add alignment info
U2StringAttribute attr(msaId, "MSA1 info key", "MSA1 info value");
U2AttributeDbi* attrDbi = SQLiteObjectDbiTestData::getAttributeDbi();
attrDbi->createStringAttribute(attr, os);
CHECK_NO_ERROR(os);
// Create sequences
U2SequenceDbi* sequenceDbi = SQLiteObjectDbiTestData::getSequenceDbi();
U2Sequence seq1;
U2Sequence seq2;
sequenceDbi->createSequenceObject(seq1, "", os);
CHECK_NO_ERROR(os);
sequenceDbi->createSequenceObject(seq2, "", os);
CHECK_NO_ERROR(os);
// Add rows
U2MsaRow row1;
row1.rowId = 0;
row1.sequenceId = seq1.id;
row1.gstart = 0;
row1.gend = 5;
U2MsaGap row1gap1(0, 2);
U2MsaGap row1gap2(3, 1);
QList<U2MsaGap> row1gaps;
row1gaps << row1gap1 << row1gap2;
row1.gaps = row1gaps;
U2MsaRow row2;
row2.rowId = 1;
row2.sequenceId = seq2.id;
row2.gstart = 2;
row2.gend = 4;
U2MsaGap row2gap(1, 2);
QList<U2MsaGap> row2gaps;
row2gaps << row2gap;
row2.gaps = row2gaps;
QList<U2MsaRow> rows;
rows << row1 << row2;
msaDbi->addRows(msaId, rows, os);
CHECK_NO_ERROR(os);
// SECOND ALIGNMENT
// Create an alignment
U2DataId msaId2 = msaDbi->createMsaObject("", "Test name 2", BaseDNAAlphabetIds::AMINO_DEFAULT(), os);
CHECK_NO_ERROR(os);
// Add alignment info
U2StringAttribute attr2(msaId2, "MSA2 info key", "MSA2 info value");
attrDbi->createStringAttribute(attr2, os);
CHECK_NO_ERROR(os);
// Create sequences
U2Sequence al2Seq;
sequenceDbi->createSequenceObject(al2Seq, "", os);
CHECK_NO_ERROR(os);
// Add rows
U2MsaRow al2Row;
al2Row.rowId = 0;
al2Row.sequenceId = al2Seq.id;
al2Row.gstart = 0;
al2Row.gend = 15;
U2MsaGap al2RowGap(1, 12);
QList<U2MsaGap> al2RowGaps;
al2RowGaps << al2RowGap;
al2Row.gaps = al2RowGaps;
QList<U2MsaRow> al2Rows;
al2Rows << al2Row;
msaDbi->addRows(msaId2, al2Rows, os);
CHECK_NO_ERROR(os);
// REMOVE THE FIRST ALIGNMENT OBJECT
SQLiteObjectDbi* sqliteObjectDbi = SQLiteObjectDbiTestData::getSQLiteObjectDbi();
sqliteObjectDbi->removeObject(msaId, os);
// VERIFY THAT THERE IS ONLY THE SECOND ALIGNMENT'S RECORDS LEFT IN TABLES
SQLiteDbi* sqliteDbi = SQLiteObjectDbiTestData::getSQLiteDbi();
// "Attribute"
SQLiteReadQuery qAttr("SELECT COUNT(*) FROM Attribute WHERE name = ?1", sqliteDbi->getDbRef(), os);
qAttr.bindString(1, "MSA1 info key");
qint64 msa1AttrNum = qAttr.selectInt64();
CHECK_EQUAL(0, msa1AttrNum, "MSA1 attributes number");
qAttr.reset(true);
qAttr.bindString(1, "MSA2 info key");
qint64 msa2AttrNum = qAttr.selectInt64();
CHECK_EQUAL(1, msa2AttrNum, "MSA2 attributes number");
// "StringAttribute"
SQLiteReadQuery qStringAttr("SELECT COUNT(*) FROM StringAttribute WHERE value = ?1", sqliteDbi->getDbRef(), os);
qStringAttr.bindString(1, "MSA1 info value");
qint64 msa1StrAttrNum = qStringAttr.selectInt64();
CHECK_EQUAL(0, msa1StrAttrNum, "MSA1 string attributes number");
qStringAttr.reset(true);
qStringAttr.bindString(1, "MSA2 info value");
qint64 msa2StrAttrNum = qStringAttr.selectInt64();
CHECK_EQUAL(1, msa2StrAttrNum, "MSA2 string attributes number");
// "MsaRow"
SQLiteReadQuery qMsaRow("SELECT COUNT(*) FROM MsaRow WHERE msa = ?1", sqliteDbi->getDbRef(), os);
qMsaRow.bindDataId(1, msaId);
qint64 msa1Rows = qMsaRow.selectInt64();
CHECK_EQUAL(0, msa1Rows, "number of rows in MSA1");
qMsaRow.reset(true);
qMsaRow.bindDataId(1, msaId2);
qint64 msa2Rows = qMsaRow.selectInt64();
CHECK_EQUAL(1, msa2Rows, "number of rows in MSA2");
// "MsaRowGap"
SQLiteReadQuery qMsaRowGap("SELECT COUNT(*) FROM MsaRowGap WHERE msa = ?1", sqliteDbi->getDbRef(), os);
qMsaRowGap.bindDataId(1, msaId);
qint64 msa1Gaps = qMsaRowGap.selectInt64();
CHECK_EQUAL(0, msa1Gaps, "number of gaps in MSA1 rows");
qMsaRowGap.reset(true);
qMsaRowGap.bindDataId(1, msaId2);
qint64 msa2Gaps = qMsaRowGap.selectInt64();
CHECK_EQUAL(1, msa2Gaps, "number of gaps in MSA2 rows");
// "Sequence"
SQLiteReadQuery qSeq("SELECT COUNT(*) FROM Sequence WHERE object = ?1", sqliteDbi->getDbRef(), os);
qSeq.bindDataId(1, seq1.id);
qint64 msa1seq1 = qSeq.selectInt64();
CHECK_EQUAL(0, msa1seq1, "seq1 of msa1");
qSeq.reset(true);
qSeq.bindDataId(1, seq2.id);
qint64 msa1seq2 = qSeq.selectInt64();
CHECK_EQUAL(0, msa1seq2, "seq2 of msa1");
qSeq.reset(true);
qSeq.bindDataId(1, al2Seq.id);
qint64 msa2seq = qSeq.selectInt64();
CHECK_EQUAL(1, msa2seq, "seq of msa2");
// "Msa"
SQLiteReadQuery qMsa("SELECT COUNT(*) FROM Msa WHERE object = ?1", sqliteDbi->getDbRef(), os);
qMsa.bindDataId(1, msaId);
qint64 msa1records = qMsa.selectInt64();
CHECK_EQUAL(0, msa1records, "number of MSA1 records");
qMsa.reset(true);
qMsa.bindDataId(1, msaId2);
qint64 msa2records = qMsa.selectInt64();
CHECK_EQUAL(1, msa2records, "number of MSA2 records");
// "Object"
SQLiteReadQuery qObj("SELECT COUNT(*) FROM Object WHERE id = ?1", sqliteDbi->getDbRef(), os);
qObj.bindDataId(1, msaId);
qint64 msa1objects = qObj.selectInt64();
CHECK_EQUAL(0, msa1objects, "number of MSA1 objects");
qObj.reset(true);
qObj.bindDataId(1, msaId2);
qint64 msa2objects = qObj.selectInt64();
CHECK_EQUAL(1, msa2objects, "number of MSA2 objects");
// Remove the second alignment
sqliteObjectDbi->removeObject(msaId2, os);
}
// Test node attribute functionality
void ManipulateNodeEdgeAttributes() {
int NNodes = 1000;
int NEdges = 1000;
const char *FName = "demo.graph.dat";
PNEANet Graph;
PNEANet Graph1;
int i;
int x, y;
bool t;
Graph = TNEANet::New();
t = Graph->Empty();
// create the nodes
for (i = 0; i < NNodes; i++) {
Graph->AddNode(i);
}
// create the edges
for (i = 0; i < NEdges; i++) {
x = rand() % NNodes;
y = rand() % NNodes;
Graph->AddEdge(x, y, i);
}
// create attributes and fill all nodes
TStr attr1 = "str";
TStr attr2 = "int";
TStr attr3 = "float";
TStr attr4 = "default";
// Test vertical int iterator for node 3, 50, 700, 900
// Check if we can set defaults to 0 for Int data.
Graph->AddIntAttrN(attr2, 0);
Graph->AddIntAttrDatN(3, 3*2, attr2);
Graph->AddIntAttrDatN(50, 50*2, attr2);
Graph->AddIntAttrDatN(700, 700*2, attr2);
Graph->AddIntAttrDatN(900, 900*2, attr2);
int NodeId = 0;
for (TNEANet::TAIntI NI = Graph->BegNAIntI(attr2);
NI < Graph->EndNAIntI(attr2); NI++) {
// Check if defaults are now 0.
if (NI.GetDat()() != 0) {
printf("Attribute: %s, Node: %i, Val: %i\n", attr2(), NodeId, NI.GetDat()());
NodeId++;
}
}
// Test vertical flt iterator for node 3, 50, 700, 900
Graph->AddFltAttrDatN(5, 3.41, attr3);
Graph->AddFltAttrDatN(50, 2.718, attr3);
Graph->AddFltAttrDatN(300, 150.0, attr3);
Graph->AddFltAttrDatN(653, 653, attr3);
NodeId = 0;
for (TNEANet::TAFltI NI = Graph->BegNAFltI(attr3);
NI < Graph->EndNAFltI(attr3); NI++) {
if (NI.GetDat() != TFlt::Mn) {
printf("Attribute: %s, Node: %i, Val: %f\n", attr3(), NodeId, NI.GetDat()());
NodeId++;
}
}
// Test vertical str iterator for node 3, 50, 700, 900
Graph->AddStrAttrDatN(10, "abc", attr1);
Graph->AddStrAttrDatN(20, "def", attr1);
Graph->AddStrAttrDatN(400, "ghi", attr1);
// this does not show since ""=null
Graph->AddStrAttrDatN(455, "", attr1);
NodeId = 0;
for (TNEANet::TAStrI NI = Graph->BegNAStrI(attr1);
NI < Graph->EndNAStrI(attr1); NI++) {
if (NI.GetDat() != TStr::GetNullStr()) {
printf("Attribute: %s, Node: %i, Val: %s\n", attr1(), NodeId, NI.GetDat()());
NodeId++;
}
}
// Test vertical iterator over many types (must skip default/deleted attr)
int NId = 55;
Graph->AddStrAttrDatN(NId, "aaa", attr1);
Graph->AddIntAttrDatN(NId, 3*2, attr2);
Graph->AddFltAttrDatN(NId, 3.41, attr3);
Graph->AddStrAttrDatN(80, "dont appear", attr4); // should not show up
TStrV NIdAttrName;
Graph->AttrNameNI(NId, NIdAttrName);
int AttrLen = NIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Node: %i, Attr: %s\n", NId, NIdAttrName[i]());
}
Graph->DelAttrDatN(NId, attr2);
Graph->AttrNameNI(NId, NIdAttrName);
AttrLen = NIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Node (no int) : %i, Attr: %s\n", NId, NIdAttrName[i]());
}
Graph->AddIntAttrDatN(NId, 3*2, attr2);
Graph->DelAttrN(attr1);
Graph->AttrNameNI(NId, NIdAttrName);
AttrLen = NIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Node (no str) : %i, Attr: %s\n", NId, NIdAttrName[i]());
}
TStrV NIdAttrValue;
Graph->AttrValueNI(NId, NIdAttrValue);
AttrLen = NIdAttrValue.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Node (no str) : %i, Attr_Val: %s\n", NId, NIdAttrValue[i]());
}
for (i = 0; i <NNodes; i++) {
Graph->AddIntAttrDatN(i, 70, attr2);
}
{
TFOut FOut(FName);
Graph->Save(FOut);
FOut.Flush();
}
{
TFIn FIn(FName);
Graph1 = TNEANet::Load(FIn);
}
int total = 0;
for (TNEANet::TAIntI NI = Graph1->BegNAIntI(attr2);
NI < Graph1->EndNAIntI(attr2); NI++) {
total += NI.GetDat();
}
printf("Average: %i (should be 70)\n", total/NNodes);
Graph1->Clr();
// Test vertical int iterator for edge
Graph->AddIntAttrDatE(3, 3*2, attr2);
Graph->AddIntAttrDatE(55, 55*2, attr2);
Graph->AddIntAttrDatE(705, 705*2, attr2);
Graph->AddIntAttrDatE(905, 905*2, attr2);
int EdgeId = 0;
for (TNEANet::TAIntI EI = Graph->BegEAIntI(attr2);
EI < Graph->EndEAIntI(attr2); EI++) {
if (EI.GetDat() != TInt::Mn) {
printf("E Attribute: %s, Edge: %i, Val: %i\n", attr2(), EdgeId, EI.GetDat()());
EdgeId++;
}
}
// Test vertical flt iterator for edge
Graph->AddFltAttrE(attr3, 0.00);
Graph->AddFltAttrDatE(5, 4.41, attr3);
Graph->AddFltAttrDatE(50, 3.718, attr3);
Graph->AddFltAttrDatE(300, 151.0, attr3);
Graph->AddFltAttrDatE(653, 654, attr3);
EdgeId = 0;
for (TNEANet::TAFltI EI = Graph->BegEAFltI(attr3);
EI < Graph->EndEAFltI(attr3); EI++) {
// Check if defaults are set to 0.
if (EI.GetDat() != 0.00) {
printf("E Attribute: %s, Edge: %i, Val: %f\n", attr3(), EdgeId, EI.GetDat()());
EdgeId++;
}
}
// Test vertical str iterator for edge
Graph->AddStrAttrDatE(10, "abc", attr1);
Graph->AddStrAttrDatE(20, "def", attr1);
Graph->AddStrAttrDatE(400, "ghi", attr1);
// this does not show since ""=null
Graph->AddStrAttrDatE(455, "", attr1);
EdgeId = 0;
for (TNEANet::TAStrI EI = Graph->BegEAStrI(attr1);
EI < Graph->EndEAStrI(attr1); EI++) {
if (EI.GetDat() != TStr::GetNullStr()) {
printf("E Attribute: %s, Edge: %i, Val: %s\n", attr1(), EdgeId, EI.GetDat()());
EdgeId++;
}
}
// Test vertical iterator over many types (must skip default/deleted attr)
int EId = 55;
Graph->AddStrAttrDatE(EId, "aaa", attr1);
Graph->AddIntAttrDatE(EId, 3*2, attr2);
Graph->AddFltAttrDatE(EId, 3.41, attr3);
Graph->AddStrAttrDatE(80, "dont appear", attr4); // should not show up
TStrV EIdAttrName;
Graph->AttrNameEI(EId, EIdAttrName);
AttrLen = EIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Edge: %i, Attr: %s\n", EId, EIdAttrName[i]());
}
Graph->DelAttrDatE(EId, attr2);
Graph->AttrNameEI(EId, EIdAttrName);
AttrLen = EIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Edge (no int) : %i, Attr: %s\n", EId, EIdAttrName[i]());
}
Graph->AddIntAttrDatE(EId, 3*2, attr2);
Graph->DelAttrE(attr1);
Graph->AttrNameEI(EId, EIdAttrName);
AttrLen = EIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Edge (no str) : %i, Attr: %s\n", EId, EIdAttrName[i]());
}
TStrV EIdAttrValue;
Graph->AttrValueEI(EId, EIdAttrValue);
AttrLen = EIdAttrValue.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Edge (no str) : %i, Attr_Val: %s\n", EId, EIdAttrValue[i]());
}
for (i = 0; i <NEdges; i++) {
Graph->AddIntAttrDatE(i, 70, attr2);
}
{
TFOut FOut(FName);
Graph->Save(FOut);
FOut.Flush();
Graph->Clr();
}
{
TFIn FIn(FName);
Graph1 = TNEANet::Load(FIn);
}
total = 0;
for (TNEANet::TAIntI EI = Graph1->BegNAIntI(attr2);
EI < Graph1->EndNAIntI(attr2); EI++) {
total += EI.GetDat();
}
printf("Average: %i (should be 70)\n", total/NEdges);
//Graph1->Dump();
Graph1->Clr();
}
void test_a_dbobject_with_an_object::can_refresh_attributes()
{
bool value1 = true;
bool value1a = false;
unsigned long value2 = 0x87654321;
unsigned long value2a = 0x76767676;
unsigned long value2b = 0x89898989;
ByteString value3 = "BDEBDBEDBBDBEBDEBE792759537328";
ByteString value3a = "466487346943785684957634";
ByteString value4 = "0102010201020102010201020102010201020102";
// Create the test object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SUBJECT, attr3));
}
// Now read back the object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_TOKEN));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_PRIME_BITS));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SUBJECT));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->getBooleanValue());
CPPUNIT_ASSERT_EQUAL(testObject.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue(), value2);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT)->getByteStringValue() == value3);
OSAttribute attr1(value1a);
OSAttribute attr2(value2a);
OSAttribute attr3(value3a);
// Change the attributes
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SUBJECT, attr3));
// Check the attributes
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN)->getBooleanValue() == value1a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue() == value2a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT)->getByteStringValue() == value3a);
// Open the object a second time
DBObject testObject2(connection);
CPPUNIT_ASSERT(testObject2.find(1));
CPPUNIT_ASSERT(testObject2.isValid());
// Check the attributes on the second instance
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_TOKEN)->isBooleanAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_SUBJECT)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_TOKEN)->getBooleanValue() == value1a);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue() == value2a);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_SUBJECT)->getByteStringValue() == value3a);
// Add an attribute on the second object
OSAttribute attr4(value4);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_ID, attr4));
// Check the attribute
CPPUNIT_ASSERT(testObject2.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID)->getByteStringValue() == value4);
// Now check that the first instance also knows about it
CPPUNIT_ASSERT(testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID)->isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID)->getByteStringValue() == value4);
// Now change another attribute
OSAttribute attr2b(value2b);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2b));
// Check the attribute
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue() == value2b);
// Now check that the second instance also knows about the change
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS)->isUnsignedLongAttribute());
// Note that the CKA_PRIME_BITS attribute cannot officially be modified.
// We optimize inside DBObject to only propagate to the database modifiable attributes.
// Therefore we don't expect changes to CKA_PRIME_BITS to propagate to testObject2.
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS)->getUnsignedLongValue() != value2b);
}
}
void test_a_dbobject_with_an_object::should_use_transactions()
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
bool value1 = true;
unsigned long value2 = 0x87654321;
unsigned long value3 = 0xBDEBDBED;
ByteString value4 = "AAAAAAAAAAAAAAAFFFFFFFFFFFFFFF";
OSAttribute attr1(value1);
OSAttribute attr2(value2);
OSAttribute attr3(value3);
OSAttribute attr4(value4);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VALUE_BITS, attr3));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_ID, attr4));
// Create secondary instance for the same object.
// This needs to have a different connection to the database to simulate
// another process accessing the data.
DBObject testObject2(connection2);
CPPUNIT_ASSERT(testObject2.find(1));
CPPUNIT_ASSERT(testObject2.isValid());
// Check that it has the same attributes
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID).isByteStringAttribute());
// Check that the attributes have the same values as set on testObject.
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_TOKEN).getBooleanValue() == value1);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS).getUnsignedLongValue() == value2);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() == value3);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID).getByteStringValue() == value4);
// New values
bool value1a = false;
unsigned long value2a = 0x12345678;
unsigned long value3a = 0xABABABAB;
ByteString value4a = "EDEDEDEDEDEDEDEDEDEDEDEDEDEDED";
OSAttribute attr1a(value1a);
OSAttribute attr2a(value2a);
OSAttribute attr3a(value3a);
OSAttribute attr4a(value4a);
// Start transaction on object
CPPUNIT_ASSERT(testObject.startTransaction(DBObject::ReadWrite));
// Change the attributes
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1a));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2a));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VALUE_BITS, attr3a));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_ID, attr4a));
// Verify that the attributes were set
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).getBooleanValue() == value1a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS).getUnsignedLongValue() == value2a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() == value3a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID).getByteStringValue() == value4a);
// Verify that they are unchanged on the other instance
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID).isByteStringAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_TOKEN).getBooleanValue() == value1);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS).getUnsignedLongValue() == value2);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() == value3);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID).getByteStringValue() == value4);
// Commit the transaction
CPPUNIT_ASSERT(testObject.commitTransaction());
// Verify that non-modifiable attributes did not propagate but modifiable attributes
// have now changed on the other instance
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID).isByteStringAttribute());
// NOTE: 3 attributes below cannot be modified after creation and therefore are not required to propagate.
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_TOKEN).getBooleanValue() != value1a);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_PRIME_BITS).getUnsignedLongValue() != value2a);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() != value3a);
// CKA_ID attribute can be modified after creation and therefore should have propagated.
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID).getByteStringValue() == value4a);
// Start transaction on object
CPPUNIT_ASSERT(testObject.startTransaction(DBObject::ReadWrite));
// Change the attributes
CPPUNIT_ASSERT(testObject.setAttribute(CKA_TOKEN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_PRIME_BITS, attr2));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_VALUE_BITS, attr3));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_ID, attr4));
// Verify that the attributes were set
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).getBooleanValue() == value1);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS).getUnsignedLongValue() == value2);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() == value3);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID).getByteStringValue() == value4);
// Create a fresh third instance for the same object to force the data to be retrieved from the database.
DBObject testObject3(connection2);
CPPUNIT_ASSERT(testObject3.find(1));
CPPUNIT_ASSERT(testObject3.isValid());
// Verify that they are unchanged on the other instance, while the transaction is still in progress.
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_ID).isByteStringAttribute());
// Verify that the attributes from the database are still hodling the same value as when the transaction started.
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_TOKEN).getBooleanValue() == value1a);
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_PRIME_BITS).getUnsignedLongValue() == value2a);
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() == value3a);
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_ID).getByteStringValue() == value4a);
// Abort the transaction
CPPUNIT_ASSERT(testObject.abortTransaction());
// Verify that after aborting the transaction the values in testObject have reverted back to their
// original state.
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID).isByteStringAttribute());
// After aborting a transaction the testObject should be back to pre transaction state.
CPPUNIT_ASSERT(testObject.getAttribute(CKA_TOKEN).getBooleanValue() == value1a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_PRIME_BITS).getUnsignedLongValue() == value2a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() == value3a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID).getByteStringValue() == value4a);
// Verify that testObject3 still has the original values.
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_TOKEN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_PRIME_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_VALUE_BITS).isUnsignedLongAttribute());
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_ID).isByteStringAttribute());
// Verify that testObject3 still has the original values.
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_TOKEN).getBooleanValue() == value1a);
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_PRIME_BITS).getUnsignedLongValue() == value2a);
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_VALUE_BITS).getUnsignedLongValue() == value3a);
CPPUNIT_ASSERT(testObject3.getAttribute(CKA_ID).getByteStringValue() == value4a);
}
// The test checks that default formatting work
BOOST_AUTO_TEST_CASE_TEMPLATE(default_formatting, CharT, char_types)
{
typedef logging::record_view record_view;
typedef logging::attribute_set attr_set;
typedef std::basic_string< CharT > string;
typedef logging::basic_formatting_ostream< CharT > osstream;
typedef logging::basic_formatter< CharT > formatter;
typedef test_data< CharT > data;
attrs::constant< int > attr1(10);
attrs::constant< double > attr2(5.5);
attrs::constant< my_class > attr3(my_class(77));
attr_set set1;
set1[data::attr1()] = attr1;
set1[data::attr2()] = attr2;
set1[data::attr3()] = attr3;
record_view rec = make_record_view(set1);
// Check for various modes of attribute value type specification
{
string str1, str2;
osstream strm1(str1), strm2(str2);
formatter f = expr::stream << expr::attr< int >(data::attr1()) << expr::attr< double >(data::attr2());
f(rec, strm1);
strm2 << 10 << 5.5;
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
{
string str1, str2;
osstream strm1(str1), strm2(str2);
formatter f = expr::stream << expr::attr< logging::numeric_types >(data::attr1()) << expr::attr< logging::numeric_types >(data::attr2());
f(rec, strm1);
strm2 << 10 << 5.5;
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
// Check that custom types as attribute values are also supported
{
string str1, str2;
osstream strm1(str1), strm2(str2);
formatter f = expr::stream << expr::attr< my_class >(data::attr3());
f(rec, strm1);
strm2 << my_class(77);
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
// Check how missing attribute values are handled
{
string str1;
osstream strm1(str1);
formatter f = expr::stream
<< expr::attr< int >(data::attr1())
<< expr::attr< int >(data::attr4()).or_throw()
<< expr::attr< double >(data::attr2());
BOOST_CHECK_THROW(f(rec, strm1), logging::runtime_error);
}
{
string str1, str2;
osstream strm1(str1), strm2(str2);
formatter f = expr::stream
<< expr::attr< int >(data::attr1())
<< expr::attr< int >(data::attr4())
<< expr::attr< double >(data::attr2());
f(rec, strm1);
strm2 << 10 << 5.5;
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
}
}
void test_a_dbobject_with_an_object::can_refresh_attributes()
{
bool value1 = true;
bool value1a = false;
ByteString value2 = "BDEBDBEDBBDBEBDEBE792759537328";
ByteString value2a = "466487346943785684957634";
ByteString value3 = "0102010201020102010201020102010201020102";
// Create the test object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
OSAttribute attr1(value1);
OSAttribute attr2(value2);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SIGN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SUBJECT, attr2));
}
// Now read back the object
{
DBObject testObject(connection);
CPPUNIT_ASSERT(testObject.find(1));
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SIGN));
CPPUNIT_ASSERT(testObject.attributeExists(CKA_SUBJECT));
CPPUNIT_ASSERT(!testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SIGN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SIGN).getBooleanValue());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT).getByteStringValue() == value2);
OSAttribute attr1(value1a);
OSAttribute attr2(value2a);
// Change the attributes
CPPUNIT_ASSERT(testObject.isValid());
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SIGN, attr1));
CPPUNIT_ASSERT(testObject.setAttribute(CKA_SUBJECT, attr2));
// Check the attributes
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SIGN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SIGN).getBooleanValue() == value1a);
CPPUNIT_ASSERT(testObject.getAttribute(CKA_SUBJECT).getByteStringValue() == value2a);
// Open the object a second time
DBObject testObject2(connection);
CPPUNIT_ASSERT(testObject2.find(1));
CPPUNIT_ASSERT(testObject2.isValid());
// Check the attributes on the second instance
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_SIGN).isBooleanAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_SUBJECT).isByteStringAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_SIGN).getBooleanValue() == value1a);
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_SUBJECT).getByteStringValue() == value2a);
// Add an attribute on the second object
OSAttribute attr3(value3);
CPPUNIT_ASSERT(testObject.setAttribute(CKA_ID, attr3));
// Check the attribute
CPPUNIT_ASSERT(testObject2.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID).isByteStringAttribute());
CPPUNIT_ASSERT(testObject2.getAttribute(CKA_ID).getByteStringValue() == value3);
// Now check that the first instance also knows about it
CPPUNIT_ASSERT(testObject.attributeExists(CKA_ID));
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID).isByteStringAttribute());
CPPUNIT_ASSERT(testObject.getAttribute(CKA_ID).getByteStringValue() == value3);
}
}
