void test_geometry(std::string const& wkt,
typename bgi::detail::default_content_result<Geometry>::type expected_value)
{
Geometry geometry;
bg::read_wkt(wkt, geometry);
test_content(geometry, expected_value);
}
int main(int argc , char ** argv) {
test_create_data();
test_create_vector();
test_get_vector();
test_content();
exit(0);
}
int main()
{
test_failed();
test_right_failed();
test_content();
test_unallocated();
return 0;
}
int main(void)
{
srand(time(0));
//for (int i = 0; i < 10; ++i) {
//test_length();
test_content();
//~ test_copy();
//}
}
int test_main(int, char* [])
{
typedef bg::model::point<int, 2, bg::cs::cartesian> P2ic;
typedef bg::model::point<float, 2, bg::cs::cartesian> P2fc;
typedef bg::model::point<double, 2, bg::cs::cartesian> P2dc;
typedef bg::model::point<int, 3, bg::cs::cartesian> P3ic;
typedef bg::model::point<float, 3, bg::cs::cartesian> P3fc;
typedef bg::model::point<double, 3, bg::cs::cartesian> P3dc;
test_content(P2ic(0, 0), 0);
test_content(P2fc(0, 0), 0);
test_content(P2dc(0, 0), 0);
test_content(P3ic(0, 0, 0), 0);
test_content(P3fc(0, 0, 0), 0);
test_content(P3dc(0, 0, 0), 0);
test_geometry<bg::model::box<P2ic> >("POLYGON((0 1,2 4))", 6.0);
test_geometry<bg::model::box<P2fc> >("POLYGON((0 1,2 4))", 6.0);
test_geometry<bg::model::box<P2dc> >("POLYGON((0 1,2 4))", 6.0);
test_geometry<bg::model::box<P3ic> >("POLYGON((0 1 2,2 4 6))", 24.0);
test_geometry<bg::model::box<P3fc> >("POLYGON((0 1 2,2 4 6))", 24.0);
test_geometry<bg::model::box<P3dc> >("POLYGON((0 1 2,2 4 6))", 24.0);
#ifdef HAVE_TTMATH
typedef bg::model::point<ttmath_big, 2, bg::cs::cartesian> P2ttmc;
typedef bg::model::point<ttmath_big, 3, bg::cs::cartesian> P3ttmc;
test_geometry<bg::model::box<P2ttmc> >("POLYGON((0 1,2 4))", 6.0);
test_geometry<bg::model::box<P3ttmc> >("POLYGON((0 1 2,2 4 6))", 24.0);
#endif
test_large_integers();
return 0;
}
static int do_test(const char *cert_file, const char *key_file,
const char *ca_file, const char *cipher) {
struct sockaddr_in sa;
socklen_t slen;
SSL_CTX *ctx;
SSL *ssl;
int ret = 0;
int fd, cfd;
ctx = setup_ctx(cert_file, key_file, ca_file, cipher);
if (NULL == ctx) goto out;
ssl = SSL_new(ctx);
if (NULL == ssl) goto out_ctx;
fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd < 0) {
fprintf(stderr, "socket: %s\n", strerror(errno));
goto out_ssl;
}
do {
int val = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
} while (0);
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
sa.sin_port = htons(TEST_PORT);
if (bind(fd, (struct sockaddr *) &sa, sizeof(sa))) {
fprintf(stderr, "bind: %s\n", strerror(errno));
goto out_close;
}
if (listen(fd, 128)) {
fprintf(stderr, "bind: %s\n", strerror(errno));
goto out_close;
}
slen = sizeof(sa);
printf("Waiting for a connection...\n");
cfd = accept(fd, (struct sockaddr *) &sa, &slen);
if (cfd < 0) {
fprintf(stderr, "accept: %s\n", strerror(errno));
goto out_close;
}
ns_set_non_blocking_mode(cfd);
if (!SSL_set_fd(ssl, cfd)) goto out_close_cl;
printf("Got connection\n");
if (do_accept(ssl) <= 0) {
goto shutdown;
}
if (!test_content(ssl)) {
goto shutdown;
}
ret = 1;
shutdown:
if (do_shutdown(ssl) > 0 && ret) {
printf("SUCCESS\n");
} else {
printf("shutdown failed\n");
ret = 0;
}
out_close_cl:
close(cfd);
out_close:
close(fd);
out_ssl:
SSL_free(ssl);
out_ctx:
SSL_CTX_free(ctx);
out:
return ret;
}
void
hierarchy(test_batch_runner *runner)
{
cmark_node *bquote1 = cmark_node_new(CMARK_NODE_BLOCK_QUOTE);
cmark_node *bquote2 = cmark_node_new(CMARK_NODE_BLOCK_QUOTE);
cmark_node *bquote3 = cmark_node_new(CMARK_NODE_BLOCK_QUOTE);
OK(runner, cmark_node_append_child(bquote1, bquote2),
"append bquote2");
OK(runner, cmark_node_append_child(bquote2, bquote3),
"append bquote3");
OK(runner, !cmark_node_append_child(bquote3, bquote3),
"adding a node as child of itself fails");
OK(runner, !cmark_node_append_child(bquote3, bquote1),
"adding a parent as child fails");
cmark_node_free(bquote1);
int max_node_type = CMARK_NODE_LAST_BLOCK > CMARK_NODE_LAST_INLINE
? CMARK_NODE_LAST_BLOCK : CMARK_NODE_LAST_INLINE;
OK(runner, max_node_type < 32, "all node types < 32");
int list_item_flag = 1 << CMARK_NODE_ITEM;
int top_level_blocks =
(1 << CMARK_NODE_BLOCK_QUOTE) |
(1 << CMARK_NODE_LIST) |
(1 << CMARK_NODE_CODE_BLOCK) |
(1 << CMARK_NODE_HTML) |
(1 << CMARK_NODE_PARAGRAPH) |
(1 << CMARK_NODE_HEADER) |
(1 << CMARK_NODE_HRULE);
int all_inlines =
(1 << CMARK_NODE_TEXT) |
(1 << CMARK_NODE_SOFTBREAK) |
(1 << CMARK_NODE_LINEBREAK) |
(1 << CMARK_NODE_CODE) |
(1 << CMARK_NODE_INLINE_HTML) |
(1 << CMARK_NODE_EMPH) |
(1 << CMARK_NODE_STRONG) |
(1 << CMARK_NODE_LINK) |
(1 << CMARK_NODE_IMAGE);
test_content(runner, CMARK_NODE_DOCUMENT, top_level_blocks);
test_content(runner, CMARK_NODE_BLOCK_QUOTE, top_level_blocks);
test_content(runner, CMARK_NODE_LIST, list_item_flag);
test_content(runner, CMARK_NODE_ITEM, top_level_blocks);
test_content(runner, CMARK_NODE_CODE_BLOCK , 0);
test_content(runner, CMARK_NODE_HTML, 0);
test_content(runner, CMARK_NODE_PARAGRAPH, all_inlines);
test_content(runner, CMARK_NODE_HEADER, all_inlines);
test_content(runner, CMARK_NODE_HRULE, 0);
test_content(runner, CMARK_NODE_TEXT, 0);
test_content(runner, CMARK_NODE_SOFTBREAK, 0);
test_content(runner, CMARK_NODE_LINEBREAK, 0);
test_content(runner, CMARK_NODE_CODE, 0);
test_content(runner, CMARK_NODE_INLINE_HTML, 0);
test_content(runner, CMARK_NODE_EMPH, all_inlines);
test_content(runner, CMARK_NODE_STRONG, all_inlines);
test_content(runner, CMARK_NODE_LINK, all_inlines);
test_content(runner, CMARK_NODE_IMAGE, all_inlines);
}
