an efficient binary archive format
use bindle header in test.c
+82
-106
+82
-106
test/test.c
+82
-106
test/test.c
···
1
1
#include "greatest.h"
2
2
#include <string.h>
3
3
4
-
// Forward declarations for the C API
5
-
typedef struct Bindle Bindle;
6
-
typedef struct Writer Writer;
7
-
typedef struct Reader Reader;
8
-
9
-
typedef enum {
10
-
BindleCompressNone = 0,
11
-
BindleCompressZstd = 1,
12
-
BindleCompressAuto = 2,
13
-
} Compress;
14
-
15
-
Bindle* bindle_create(const char* path);
16
-
Bindle* bindle_open(const char* path);
17
-
Bindle* bindle_load(const char* path);
18
-
int bindle_add(Bindle* ctx, const char* name, const unsigned char* data, size_t data_len, Compress compress);
19
-
int bindle_save(Bindle* ctx);
20
-
void bindle_close(Bindle* ctx);
21
-
unsigned char* bindle_read(Bindle* ctx, const char* name, size_t* out_len);
22
-
void bindle_free_buffer(unsigned char* ptr);
23
-
int bindle_exists(const Bindle* ctx, const char* name);
24
-
size_t bindle_length(const Bindle* ctx);
25
-
int bindle_remove(Bindle* ctx, const char* name);
26
-
int bindle_vacuum(Bindle* ctx);
27
-
Writer* bindle_writer_new(Bindle* ctx, const char* name, Compress compress);
28
-
int bindle_writer_write(Writer* writer, const unsigned char* data, size_t len);
29
-
int bindle_writer_close(Writer* writer);
30
-
Reader* bindle_reader_new(const Bindle* ctx, const char* name);
31
-
long bindle_reader_read(Reader* reader, unsigned char* buffer, size_t buffer_len);
32
-
int bindle_reader_verify_crc32(const Reader* reader);
33
-
void bindle_reader_close(Reader* reader);
4
+
#include "../include/bindle.h"
34
5
35
6
TEST test_basic(void) {
36
-
const char* path = "test_c.bndl";
37
-
const char* name = "test.txt";
38
-
const char* data = "Hello from C!";
7
+
const char *path = "test_c.bndl";
8
+
const char *name = "test.txt";
9
+
const char *data = "Hello from C!";
39
10
40
-
// Create and add data
41
-
Bindle* archive = bindle_create(path);
42
-
ASSERT(archive != NULL);
11
+
// Create and add data
12
+
Bindle *archive = bindle_create(path);
13
+
ASSERT(archive != NULL);
43
14
44
-
int success = bindle_add(archive, name, (unsigned char*)data, strlen(data), BindleCompressNone);
45
-
ASSERT(success);
46
-
47
-
success = bindle_save(archive);
48
-
ASSERT(success);
15
+
int success = bindle_add(archive, name, (unsigned char *)data, strlen(data),
16
+
BindleCompressNone);
17
+
ASSERT(success);
49
18
50
-
// Read back
51
-
size_t len = 0;
52
-
unsigned char* read_data = bindle_read(archive, name, &len);
53
-
ASSERT(read_data != NULL);
54
-
ASSERT_EQ(len, strlen(data));
55
-
ASSERT_MEM_EQ(read_data, data, len);
19
+
success = bindle_save(archive);
20
+
ASSERT(success);
56
21
57
-
bindle_free_buffer(read_data);
22
+
// Read back
23
+
size_t len = 0;
24
+
const unsigned char *read_data =
25
+
bindle_read_uncompressed_direct(archive, name, &len);
26
+
ASSERT(read_data != NULL);
27
+
ASSERT_MEM_EQ(read_data, data, len);
58
28
59
-
// Check exists
60
-
ASSERT(bindle_exists(archive, name));
61
-
ASSERT_EQ(bindle_length(archive), 1);
29
+
// Check exists
30
+
ASSERT(bindle_exists(archive, name));
31
+
ASSERT_EQ(bindle_length(archive), 1);
62
32
63
-
bindle_close(archive);
33
+
ASSERT(bindle_save(archive));
34
+
bindle_close(archive);
64
35
65
-
PASS();
36
+
PASS();
66
37
}
67
38
68
39
TEST test_writer_reader(void) {
69
-
const char* path = "test_c_stream.bndl";
70
-
const char* name = "streamed.txt";
71
-
const char* data = "Streaming from C!";
40
+
const char *path = "test_c_stream.bndl";
41
+
const char *name = "streamed.txt";
42
+
const char *data = "Streaming from C!";
72
43
73
-
// Write
74
-
Bindle* archive = bindle_create(path);
75
-
ASSERT(archive != NULL);
44
+
// Write
45
+
Bindle *archive = bindle_create(path);
46
+
ASSERT(archive != NULL);
76
47
77
-
Writer* writer = bindle_writer_new(archive, name, BindleCompressNone);
78
-
ASSERT(writer != NULL);
48
+
BindleWriter *writer = bindle_writer_new(archive, name, BindleCompressNone);
49
+
ASSERT(writer != NULL);
79
50
80
-
int success = bindle_writer_write(writer, (unsigned char*)data, strlen(data));
81
-
ASSERT(success);
51
+
int success =
52
+
bindle_writer_write(writer, (unsigned char *)data, strlen(data));
53
+
ASSERT(success);
82
54
83
-
success = bindle_writer_close(writer);
84
-
ASSERT(success);
55
+
success = bindle_writer_close(writer);
56
+
ASSERT(success);
85
57
86
-
bindle_save(archive);
87
-
bindle_close(archive);
58
+
bindle_save(archive);
59
+
bindle_close(archive);
88
60
89
-
// Read
90
-
archive = bindle_open(path);
91
-
ASSERT(archive != NULL);
61
+
// Read
62
+
archive = bindle_open(path);
63
+
ASSERT(archive != NULL);
92
64
93
-
Reader* reader = bindle_reader_new(archive, name);
94
-
ASSERT(reader != NULL);
65
+
BindleReader *reader = bindle_reader_new(archive, name);
66
+
ASSERT(reader != NULL);
67
+
68
+
unsigned char buffer[256];
69
+
long bytes_read = bindle_reader_read(reader, buffer, sizeof(buffer));
70
+
ASSERT_EQ(bytes_read, (long)strlen(data));
71
+
ASSERT_MEM_EQ(buffer, data, bytes_read);
95
72
96
-
unsigned char buffer[256];
97
-
long bytes_read = bindle_reader_read(reader, buffer, sizeof(buffer));
98
-
ASSERT_EQ(bytes_read, (long)strlen(data));
99
-
ASSERT_MEM_EQ(buffer, data, bytes_read);
73
+
ASSERT(bindle_reader_verify_crc32(reader));
100
74
101
-
ASSERT(bindle_reader_verify_crc32(reader));
75
+
bindle_reader_close(reader);
102
76
103
-
bindle_reader_close(reader);
104
-
bindle_close(archive);
77
+
ASSERT(bindle_save(archive));
78
+
bindle_close(archive);
105
79
106
-
PASS();
80
+
PASS();
107
81
}
108
82
109
83
TEST test_remove_vacuum(void) {
110
-
const char* path = "test_c_vacuum.bndl";
84
+
const char *path = "test_c_vacuum.bndl";
111
85
112
-
Bindle* archive = bindle_create(path);
113
-
ASSERT(archive != NULL);
86
+
Bindle *archive = bindle_create(path);
87
+
ASSERT(archive != NULL);
114
88
115
-
// Add two entries
116
-
bindle_add(archive, "file1.txt", (unsigned char*)"Data 1", 6, BindleCompressNone);
117
-
bindle_add(archive, "file2.txt", (unsigned char*)"Data 2", 6, BindleCompressNone);
118
-
bindle_save(archive);
89
+
// Add two entries
90
+
bindle_add(archive, "file1.txt", (unsigned char *)"Data 1", 6,
91
+
BindleCompressNone);
92
+
bindle_add(archive, "file2.txt", (unsigned char *)"Data 2", 6,
93
+
BindleCompressNone);
94
+
bindle_save(archive);
119
95
120
-
ASSERT_EQ(bindle_length(archive), 2);
96
+
ASSERT_EQ(bindle_length(archive), 2);
121
97
122
-
// Remove one
123
-
ASSERT(bindle_remove(archive, "file1.txt"));
124
-
bindle_save(archive);
98
+
// Remove one
99
+
ASSERT(bindle_remove(archive, "file1.txt"));
100
+
bindle_save(archive);
125
101
126
-
ASSERT_EQ(bindle_length(archive), 1);
127
-
ASSERT_FALSE(bindle_exists(archive, "file1.txt"));
128
-
ASSERT(bindle_exists(archive, "file2.txt"));
102
+
ASSERT_EQ(bindle_length(archive), 1);
103
+
ASSERT_FALSE(bindle_exists(archive, "file1.txt"));
104
+
ASSERT(bindle_exists(archive, "file2.txt"));
129
105
130
-
// Vacuum
131
-
ASSERT(bindle_vacuum(archive));
132
-
ASSERT_EQ(bindle_length(archive), 1);
106
+
// Vacuum
107
+
ASSERT(bindle_vacuum(archive));
108
+
ASSERT_EQ(bindle_length(archive), 1);
133
109
134
-
bindle_close(archive);
110
+
bindle_close(archive);
135
111
136
-
PASS();
112
+
PASS();
137
113
}
138
114
139
115
SUITE(c_api_suite) {
140
-
RUN_TEST(test_basic);
141
-
RUN_TEST(test_writer_reader);
142
-
RUN_TEST(test_remove_vacuum);
116
+
RUN_TEST(test_basic);
117
+
RUN_TEST(test_writer_reader);
118
+
RUN_TEST(test_remove_vacuum);
143
119
}
144
120
145
121
GREATEST_MAIN_DEFS();
146
122
147
-
int main(int argc, char** argv) {
148
-
GREATEST_MAIN_BEGIN();
149
-
RUN_SUITE(c_api_suite);
150
-
GREATEST_MAIN_END();
123
+
int main(int argc, char **argv) {
124
+
GREATEST_MAIN_BEGIN();
125
+
RUN_SUITE(c_api_suite);
126
+
GREATEST_MAIN_END();
151
127
}