static void test_stSortedSet_searchGreaterThan(CuTest* testCase) {
sonLibSortedSetTestSetup();
for(int32_t i=0; i<size; i++) {
stSortedSet_insert(sortedSet, stIntTuple_construct(1, input[i]));
}
//static int32_t sortedInput[] = { -10, -1, 1, 3, 5, 10, 12 };
CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet,
stIntTuple_construct(1, -11)) == stSortedSet_search(sortedSet, stIntTuple_construct(1, -10)));
CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet,
stIntTuple_construct(1, -10)) == stSortedSet_search(sortedSet, stIntTuple_construct(1, -1)));
CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet,
stIntTuple_construct(1, -5)) == stSortedSet_search(sortedSet, stIntTuple_construct(1, -1)));
CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet,
stIntTuple_construct(1, 1)) == stSortedSet_search(sortedSet, stIntTuple_construct(1, 3)));
CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet,
stIntTuple_construct(1, 13)) == NULL);
CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet,
stIntTuple_construct(1, 12)) == NULL);
for(int32_t i=0; i<100; i++) {
stSortedSet_insert(sortedSet, stIntTuple_construct(1, st_randomInt(-1000, 1000)));
}
stList *list = stSortedSet_getList(sortedSet);
for(int32_t i=1; i<stList_length(list); i++) {
stIntTuple *p = stList_get(list, i-1);
stIntTuple *j = stList_get(list, i);
stIntTuple *k = stIntTuple_construct(1, st_randomInt(stIntTuple_getPosition(p, 0), stIntTuple_getPosition(j, 0)));
CuAssertTrue(testCase, stSortedSet_searchGreaterThan(sortedSet, k) == j);
stIntTuple_destruct(k);
}
stList_destruct(list);
sonLibSortedSetTestTeardown();
}
static stSortedSet *getOddToEvenAdjacencyEdges2(stSortedSet *oddNodes,
stSortedSet *adjacencyEdges) {
/*
* Like getOddToEvenAdjacencyEdges, but with a set instead.
*/
stList *adjacencyEdgesList = stSortedSet_getList(adjacencyEdges);
stList *oddToEvenAdjacencyEdgesList = getOddToEvenAdjacencyEdges(oddNodes,
adjacencyEdgesList);
stSortedSet *oddToEvenAdjacencyEdges = stList_getSortedSet(
oddToEvenAdjacencyEdgesList,
(int(*)(const void *, const void *)) stIntTuple_cmpFn);
stList_destruct(adjacencyEdgesList);
stList_destruct(oddToEvenAdjacencyEdgesList);
return oddToEvenAdjacencyEdges;
}
static void testBreakUpComponentGreedily(CuTest *testCase) {
//return;
for (int64_t test = 0; test < 100; test++) {
st_logInfo("Starting break up giant components random test %" PRIi64 "\n", test);
setup();
stList *edgesToDelete = stCaf_breakupComponentGreedily(nodes, edges, maxComponentSize);
stSortedSet *edgesSet = stList_getSortedSet(edges, (int(*)(const void *, const void *)) stIntTuple_cmpFn);
stSortedSet *edgesToDeleteSet = stList_getSortedSet(edgesToDelete, (int(*)(const void *, const void *)) stIntTuple_cmpFn);
stSortedSet *filteredEdgesSet = stSortedSet_getDifference(edgesSet, edgesToDeleteSet);
stList *filteredEdges = stSortedSet_getList(filteredEdgesSet);
assert(stSortedSet_size(edgesToDeleteSet) + stSortedSet_size(filteredEdgesSet) == stSortedSet_size(edgesSet));
checkComponents(testCase, filteredEdges);
stSortedSet_destruct(edgesSet);
stSortedSet_destruct(edgesToDeleteSet);
stSortedSet_destruct(filteredEdgesSet);
stList_destruct(filteredEdges);
stList_destruct(edgesToDelete);
teardown();
}
}
stList *getComponents(stList *edges) {
/*
* Gets a list of connected components, each connected component
* being represented as a list of the edges, such that each edge is in exactly one
* connected component. Allows for multi-graphs (multiple edges connecting two nodes).
*/
stHash *nodesToEdges = getNodesToEdgesHash(edges);
/*
* Traverse the edges greedily
*/
stList *components =
stList_construct3(0, (void(*)(void *)) stList_destruct);
stList *nodes = stHash_getKeys(nodesToEdges);
while (stList_length(nodes) > 0) {
stIntTuple *node = stList_pop(nodes);
stList *edges = stHash_search(nodesToEdges, node);
if (edges != NULL) { //We have a component to build
stSortedSet *component = stSortedSet_construct();
stHash_remove(nodesToEdges, node);
for (int64_t i = 0; i < stList_length(edges); i++) {
stIntTuple *edge = stList_get(edges, i);
getComponentsP(nodesToEdges, stIntTuple_get(edge, 0),
component);
getComponentsP(nodesToEdges, stIntTuple_get(edge, 1),
component);
}
stList_append(components, stSortedSet_getList(component));
//Cleanup
stSortedSet_destruct(component);
stList_destruct(edges);
}
stIntTuple_destruct(node);
}
assert(stHash_size(nodesToEdges) == 0);
stHash_destruct(nodesToEdges);
stList_destruct(nodes);
return components;
}
