TEST_FIXTURE(XmlFixture, CreateChild2)
{
MSXML2::IXMLDOMNode *node = 0;
HRESULT hr = XMLHelper::CreateChild(root, &node, _T("test"));
CHECK_OK(hr);
CHECK(node);
node->Release();
node = 0;
BSTR query = SysAllocString(_T("//test"));
MSXML2::IXMLDOMNodeList *nodeList = 0;
hr = doc->selectNodes(query, &nodeList);
SysFreeString(query);
CHECK_OK(hr);
CHECK(nodeList);
long length = 0;
hr = nodeList->get_length(&length);
CHECK_OK(hr);
CHECK_EQUAL(1, length);
hr = nodeList->nextNode(&node);
CHECK_OK(hr);
CHECK(node);
BSTR name = 0;
hr = node->get_nodeName(&name);
CHECK_OK(hr);
CHECK_EQUAL(0, _tcscmp(name, _T("test")));
SysFreeString(name);
}
TEST_FIXTURE(XmlFixture, GetIntAttribute)
{
HRESULT hr = XMLHelper::SetAttribute(root, _T("attr1"), 1);
CHECK_OK(hr);
int attrValue = 0;
hr = XMLHelper::GetAttribute(root, _T("attr1"), &attrValue);
CHECK_OK(hr);
CHECK_EQUAL(1, attrValue);
}
void set_centroid(leveldb::DB* work_db, const leveldb::Slice& key,
int oldc, int newc, int K) {
if (oldc == newc) return;
auto rawkey = key.ToString();
auto keystr = get_centroid_prefix(-1, K) + rawkey;
CHECK_OK(work_db->Put({}, key, std::to_string(newc)));
CHECK_OK(work_db->Delete({}, get_centroid_prefix(oldc, K) + rawkey));
CHECK_OK(work_db->Put({}, get_centroid_prefix(newc, K) + rawkey, key));
}
TEST_FIXTURE(XmlFixture, GetI64Attribute)
{
HRESULT hr = XMLHelper::SetAttributeI64(root, _T("attr1"), 1);
CHECK_OK(hr);
unsigned __int64 value = 0;
hr = XMLHelper::GetAttributeI64(root, _T("attr1"), &value);
CHECK_OK(hr);
CHECK_EQUAL(1, value);
}
static yf_int_t yf_select_del(yf_fd_poll_t* poller, yf_fd_evt_in_t* fd_evt)
{
if (fd_evt->read.polled)
CHECK_OK(yf_select_deactivate(poller, &fd_evt->read));
if (fd_evt->write.polled)
CHECK_OK(yf_select_deactivate(poller, &fd_evt->write));
return YF_OK;
}
TEST_FIXTURE(XmlFixture, GetStringAttribute)
{
HRESULT hr = XMLHelper::SetAttribute(root, _T("attr1"), _T("value"));
CHECK_OK(hr);
BSTR attrValue = 0;
hr = XMLHelper::GetAttribute(root, _T("attr1"), &attrValue);
CHECK_OK(hr);
CHECK_EQUAL(0, _tcscmp(attrValue, _T("value")));
SysFreeString(attrValue);
}
errcode_t init_test(test_t * test, const char * programfile, const char * testfile)
{
errcode_t retval;
FILE * in;
uint16_t i;
uint16_t next_gpio_value;
char filename[256];
retval = init_vm(&test->uut);
CHECK_OK(retval, "Failed to init vm\n");
retval = load_program(&test->uut, programfile);
CHECK_OK(retval, "Failed to load program\n");
in = fopen(testfile, "r");
CHECK_NOT_NULL(in, IO, "Failed to open test file\n");
fscanf(in, "%u", &test->test_length);
CHECK_NOT_FERROR(in);
/*
test->uart_in = fopen("uartin.dat", "w");
CHECK_NOT_NULL(test->uart_in, IO, "Failed to open UART in file\n");
test->uart_out = fopen("uartout.dat", "w");
CHECK_NOT_NULL(test->uart_out, IO, "Failed to open UART out file\n");
*/
for (i = 0; i < TEST_PIN_COUNT; i++)
{
sprintf(filename, "gpio_%u.dat", i);
test->gpio_files[i] = fopen(filename, "w");
CHECK_NOT_NULL(test->gpio_files[i], IO, "Failed to open GPIO file\n");
}
test->input_size = 0;
while (!feof(in))
{
fscanf(in, "%u %u %hu", &test->gpio_input[test->input_size].time, &test->gpio_input[test->input_size].pin, &next_gpio_value);
test->gpio_input[test->input_size].value = (uint8_t)next_gpio_value;
test->input_size++;
}
test->input_size--; /* discard excessive read */
fclose(in);
for (i = 0; i < test->uut.proc_table_size; i++)
{
sprintf(filename, "sched_%u.dat", i);
test->schedules[i] = fopen(filename, "w");
CHECK_NOT_NULL(test->schedules[i], IO, "Failed to open schedule file\n");
}
return OK;
}
int main(int argc, char* argv[]) {
if (argc != 2 && argc != 3) {
std::cout
<< "Usage: leveldb_feeder dbpath [concurrency]\n"
<< "Reads file paths from stdin, one per line, and writes rows from\n"
<< "the files into the db in parallel." << std::endl;
return 1;
}
int concurrency = std::thread::hardware_concurrency();
if (argc == 3) concurrency = std::atoi(argv[2]);
std::cout << "Using concurrency " << concurrency << std::endl;
leveldb::DB* db;
leveldb::Options options;
options.create_if_missing = true;
CHECK_OK(leveldb::DB::Open(options, argv[1], &db));
std::cout << "Database open" << std::endl;
auto filenames = read_all();
put_all_files(db, filenames, concurrency);
delete db;
std::cout << "Database closed" << std::endl;
return 0;
}
int get_centroid(leveldb::DB* work_db, const leveldb::Slice& key, int K) {
std::string str;
auto keystr = get_centroid_prefix(-1, K) + key.ToString();
auto status = work_db->Get({}, keystr, &str);
if (status.IsNotFound()) return -1;
CHECK_OK(status);
return std::stoi(str);
}
TEST_FIXTURE(XmlFixture, CreateChild)
{
MSXML2::IXMLDOMNode *node = 0;
HRESULT hr = XMLHelper::CreateChild(root, &node, _T("test"));
CHECK_OK(hr);
CHECK(node);
node->Release();
}
TEST_FIXTURE(XmlFixture, NewTask)
{
__int64 id = 1;
MSXML2::IXMLDOMNode *taskNode = 0;
HRESULT hr = XMLHelper::CreateChild(root, &taskNode, _T("task"));
CHECK_OK(hr);
CTaskModel * tm = new(id) CTaskModel(taskNode, id, 0, _T("Test"), _T("Test"), _T("Test"), 0, 0, 0, 0, 0, false, 3, TASK_STATE_OPEN);
CHECK(tm);
delete tm;
CHECK_EQUAL(0, TaskModelInternalTester::GetAllocationMapCount());
}
static void lookup(leveldb::DB* db, const leveldb::Slice& key, GDELTMini& val) {
std::string strval;
leveldb::Status status = db->Get({}, key, &strval);
if (status.IsNotFound()) {
std::cerr << "Key " << key.ToString() << " not found." << std::endl;
}
CHECK_OK(status);
std::stringstream sstr;
sstr.str(std::move(strval));
sstr >> val;
}
TEST_FIXTURE(XmlFixture, AllocationMapCleaned)
{
MSXML2::IXMLDOMNode *taskNode = 0;
for(unsigned __int64 id = 1; id < 100; ++id)
{
HRESULT hr = XMLHelper::CreateChild(root, &taskNode, _T("task"));
CHECK_OK(hr);
CTaskModel * tm = new(id) CTaskModel(taskNode, id, 0, _T("Test"), _T("Test"), _T("Test"), 0, 0, 0, 0, 0, false, 3, TASK_STATE_OPEN);
CHECK(tm);
delete tm;
taskNode->Release();
taskNode = 0;
}
CHECK_EQUAL(0, TaskModelInternalTester::GetAllocationMapCount());
}
static SECStatus
gf_populate_params(ECCurveName name, ECFieldType field_type, ECParams *params)
{
SECStatus rv = SECFailure;
const ECCurveParams *curveParams;
/* 2 ['0'+'4'] + MAX_ECKEY_LEN * 2 [x,y] * 2 [hex string] + 1 ['\0'] */
char genenc[3 + 2 * 2 * MAX_ECKEY_LEN];
if ((name < ECCurve_noName) || (name > ECCurve_pastLastCurve))
goto cleanup;
params->name = name;
curveParams = ecCurve_map[params->name];
CHECK_OK(curveParams);
params->fieldID.size = curveParams->size;
params->fieldID.type = field_type;
params->pointSize = curveParams->pointSize;
if (field_type == ec_field_GFp ||
field_type == ec_field_plain) {
CHECK_OK(hexString2SECItem(params->arena, ¶ms->fieldID.u.prime,
curveParams->irr));
} else {
CHECK_OK(hexString2SECItem(params->arena, ¶ms->fieldID.u.poly,
curveParams->irr));
}
CHECK_OK(hexString2SECItem(params->arena, ¶ms->curve.a,
curveParams->curvea));
CHECK_OK(hexString2SECItem(params->arena, ¶ms->curve.b,
curveParams->curveb));
genenc[0] = '0';
genenc[1] = '4';
genenc[2] = '\0';
strcat(genenc, curveParams->genx);
strcat(genenc, curveParams->geny);
CHECK_OK(hexString2SECItem(params->arena, ¶ms->base, genenc));
CHECK_OK(hexString2SECItem(params->arena, ¶ms->order,
curveParams->order));
params->cofactor = curveParams->cofactor;
rv = SECSuccess;
cleanup:
return rv;
}
void doit(void)
{
if (debug) {
printf("GnuTLS header version %s.\n", GNUTLS_VERSION);
printf("GnuTLS library version %s.\n",
gnutls_check_version(NULL));
}
if (!gnutls_check_version_numeric(GNUTLS_VERSION_MAJOR, GNUTLS_VERSION_MINOR, GNUTLS_VERSION_PATCH)) {
fail("error in gnutls_check_version_numeric 1\n");
exit(1);
}
CHECK_FAIL(99, 9, 9)
CHECK_FAIL(90, 1, 0)
CHECK_FAIL(90, 0, 0)
CHECK_OK(2, 0, 0)
CHECK_OK(2, 99, 99)
CHECK_OK(3, 0, 0)
if (!gnutls_check_version(GNUTLS_VERSION))
fail("gnutls_check_version ERROR\n");
{
const gnutls_pk_algorithm_t *algs;
size_t i;
int pk;
algs = gnutls_pk_list();
if (!algs)
fail("gnutls_pk_list return NULL\n");
for (i = 0; algs[i]; i++) {
if (debug)
printf("pk_list[%d] = %d = %s = %d\n",
(int) i, algs[i],
gnutls_pk_algorithm_get_name(algs
[i]),
gnutls_pk_get_id
(gnutls_pk_algorithm_get_name
(algs[i])));
if (gnutls_pk_get_id
(gnutls_pk_algorithm_get_name(algs[i]))
!= algs[i])
fail("gnutls_pk id's doesn't match\n");
}
pk = gnutls_pk_get_id("foo");
if (pk != GNUTLS_PK_UNKNOWN)
fail("gnutls_pk unknown test failed (%d)\n", pk);
if (debug)
success("gnutls_pk_list ok\n");
}
{
const gnutls_sign_algorithm_t *algs;
size_t i;
int pk;
algs = gnutls_sign_list();
if (!algs)
fail("gnutls_sign_list return NULL\n");
for (i = 0; algs[i]; i++) {
if (debug)
printf("sign_list[%d] = %d = %s = %d\n",
(int) i, algs[i],
gnutls_sign_algorithm_get_name(algs
[i]),
gnutls_sign_get_id
(gnutls_sign_algorithm_get_name
(algs[i])));
if (gnutls_sign_get_id
(gnutls_sign_algorithm_get_name(algs[i])) !=
algs[i])
fail("gnutls_sign id's doesn't match\n");
}
pk = gnutls_sign_get_id("foo");
if (pk != GNUTLS_PK_UNKNOWN)
fail("gnutls_sign unknown test failed (%d)\n", pk);
if (debug)
success("gnutls_sign_list ok\n");
}
}
TEST_FIXTURE(XmlFixture, SetI64Attribute)
{
HRESULT hr = XMLHelper::SetAttributeI64(root, _T("attr1"), 1);
CHECK_OK(hr);
}
int main(int argc, char* argv[]) {
if (argc != 5 && argc != 7 && argc != 8) {
std::cout
<< "Usage: leveldb_kmedoids dbpath K intravariance-out-file "
<< "kmedoids-out-file [start end] [concurrency]\n"
<< "Runs K-Medoid on the key range [start, end].\n"
<< "Prints intermediate centroids per iteration to the out files, "
<< "as well as within-cluster total distances (\"intravariances\")."
<< std::endl;
return 1;
}
int concurrency = std::thread::hardware_concurrency();
if (argc == 8) concurrency = std::atoi(argv[7]);
std::cout << "Using concurrency " << concurrency << std::endl;
int K = std::atoi(argv[2]);
leveldb::DB* db;
CHECK_OK(leveldb::DB::Open({}, argv[1], &db));
std::cout << "Database open" << std::endl;
leveldb::DB* work_db;
leveldb::Options options;
options.create_if_missing = true;
CHECK_OK(leveldb::DB::Open(options, "/tmp/kmedoids-work", &work_db));
std::cout << "Work database open" << std::endl;
std::string start_base, end_base;
leveldb::Slice start, end;
if (argc > 5) {
start = argv[5];
end = argv[6];
} else {
auto it = iter(db);
it->SeekToFirst();
CHECK(it->Valid());
start_base = it->key().ToString();
it->SeekToLast();
CHECK(it->Valid());
end_base = it->key().ToString();
start = start_base;
end = end_base;
}
std::cout << "Running K-medoids on range [" << start.ToString()
<< ", " << end.ToString()
<< "]" << std::endl;
std::ofstream ivar_out(argv[3]);
std::ofstream cent_out(argv[4]);
RunKMedoids(start, end, K, db, work_db,
concurrency, ivar_out, cent_out);
delete work_db;
CHECK_OK(leveldb::DestroyDB("/tmp/kmedoids-work", {}));
std::cout << "Closing databases" << std::endl;
delete db;
}
errcode_t test_step(test_t * test)
{
errcode_t retval;
uint16_t i;
uint8_t pin_val;
/*
char uart_out_char = 0;
*/
retval = reschedule(&test->uut);
CHECK_OK(retval, "Failed to do scheduling\n");
test->uut.PP = test->uut.NPP;
for (i = 0; i < test->uut.proc_table_size; i++)
{
if (test->uut.PP == i)
{
fprintf(test->schedules[i], "%u 1\n", test->uut.time);
}
else
{
fprintf(test->schedules[i], "%u 0\n", test->uut.time);
}
}
for (i = 0; i < test->input_size; i++)
{
if (test->gpio_input[i].time == test->uut.time)
{
retval = gpio_set(test->gpio_input[i].pin, test->gpio_input[i].value);
CHECK_OK(retval, "Failed to set test pin\n");
}
/*
if (test->timings[i] == test->uut.time)
{
retval = enqueue(&test->uut.uart.in, test->input[i]);
CHECK_OK(retval, "Failed to enqueue a test input\n");
fprintf(test->uart_in, "%hu %hd\n", test->uut.time, (int16_t)test->input[i]);
CHECK_NOT_FERROR(test->uart_in);
break;
}
*/
}
for (i = 0; i < TEST_PIN_COUNT; i++)
{
retval = gpio_get(i, &pin_val);
CHECK_OK(retval, "Failed to get test pin\n");
fprintf(test->gpio_files[i], "%u %u\n", test->uut.time, pin_val);
}
/*
if (i == test->input_size) / * i.e. there is no input this time * /
{
fprintf(test->uart_in, "%hu 0\n", test->uut.time);
CHECK_NOT_FERROR(test->uart_in);
}
retval = dequeue(&test->uut.uart.out, &uart_out_char);
CHECK_OK(retval, "Failed to dequeue from UART out\n");
fprintf(test->uart_out, "%hu %hd\n", test->uut.time, (int16_t)uart_out_char);
CHECK_NOT_FERROR(test->uart_out);
*/
test->uut.proc_table[test->uut.PP].current_observed_time++;
retval = step(&test->uut);
test->uut.time++;
CHECK_OK(retval, "Failed to execute instruction\n");
if (test->uut.time >= test->test_length)
{
finish_test(test);
}
return OK;
}
TEST_FIXTURE(XmlFixture, SetStringAttribute)
{
HRESULT hr = XMLHelper::SetAttribute(root, _T("attr1"), _T("value"));
CHECK_OK(hr);
}
static void buffer_column_if_needed(drizzle_result_st *self_ptr)
{
if(self_ptr->options & DRIZZLE_RESULT_BUFFER_COLUMN)
return;
CHECK_OK(drizzle_column_buffer(self_ptr));
}
