summaryrefslogtreecommitdiff
path: root/test/lib/testobject.c
blob: 8f27445e0b42fb88652789d48f13fca4e61cd443 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
/*
 * This file is part of libdom test suite.
 * Licensed under the MIT License,
 *                http://www.opensource.org/licenses/mit-license.php
 * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org>
 */

#include <stdio.h>
#include <stdlib.h>

#include <dom/bootstrap/init_fini.h>

#include "bindings/xml/xmlbinding.h"
#include "bindings/xml/xmlparser.h"

#include "testassert.h"
#include "testobject.h"
#include "utils.h"

static bool xml_parser_initialised;

struct TestObject {
	dom_xml_parser *parser;
	struct dom_document *doc;
};

static void test_object_cleanup(void);

TestObject *test_object_create(int argc, char **argv,
		const char *uri, bool will_be_modified)
{
	char fnbuf[1024];
#define CHUNK_SIZE 4096
	uint8_t buf[CHUNK_SIZE];
	FILE *fp;
	size_t len;
	TestObject *ret;

	UNUSED(will_be_modified);

	if (argc != 2) {
		printf("Usage: %s <datapath>\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	if (xml_parser_initialised == false) {
		assert(dom_initialise(myrealloc, NULL) == DOM_NO_ERR);

		assert(dom_xml_binding_initialise(myrealloc, NULL) == XML_OK);

		atexit(test_object_cleanup);

		xml_parser_initialised = true;
	}

	snprintf(fnbuf, sizeof fnbuf, "%s/%s", argv[1], uri);

	ret = malloc(sizeof(TestObject));
	if (ret == NULL)
		return NULL;

	ret->parser = dom_xml_parser_create(NULL, "UTF-8", myrealloc, NULL,
			mymsg, NULL);
	if (ret->parser == NULL) {
		free(ret);
		return NULL;
	}

	fp = fopen(fnbuf, "r");
	if (fp == NULL) {
		dom_xml_parser_destroy(ret->parser);
		free(ret);
		return NULL;
	}

	fseek(fp, 0, SEEK_END);
	len = ftell(fp);
	fseek(fp, 0, SEEK_SET);

	while (len > CHUNK_SIZE) {
		fread(buf, 1, CHUNK_SIZE, fp);

		assert(dom_xml_parser_parse_chunk(ret->parser, buf,
				CHUNK_SIZE) == XML_OK);

		len -= CHUNK_SIZE;
	}

	if (len > 0) {
		fread(buf, 1, len, fp);

		assert(dom_xml_parser_parse_chunk(ret->parser, buf,
				len) == XML_OK);

		len = 0;
	}

	assert(dom_xml_parser_completed(ret->parser) == XML_OK);

	fclose(fp);

	ret->doc = dom_xml_parser_get_document(ret->parser);

	dom_xml_parser_destroy(ret->parser);
	ret->parser = NULL;

	return ret;

#undef CHUNK_SIZE
}

struct dom_document *test_object_get_doc(TestObject *obj)
{
	return obj->doc;
}

const char *test_object_get_mimetype(TestObject *obj)
{
	UNUSED(obj);

	return "text/xml";
}

void test_object_cleanup(void)
{
	if (xml_parser_initialised) {
		dom_xml_binding_finalise();
		dom_finalise();
	}
}