1
/* Copyright (C) 2006 MySQL AB
3
This program is free software; you can redistribute it and/or modify
4
it under the terms of the GNU General Public License as published by
5
the Free Software Foundation; version 2 of the License.
7
This program is distributed in the hope that it will be useful,
8
but WITHOUT ANY WARRANTY; without even the implied warranty of
9
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
GNU General Public License for more details.
12
You should have received a copy of the GNU General Public License
13
along with this program; if not, write to the Free Software
14
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
25
#include "drizzled/my_getopt.h"
27
#if TIME_WITH_SYS_TIME
28
# include <sys/time.h>
32
# include <sys/time.h>
38
#define COMMENT_STRING "Your bases"
39
#define FRM_STRING "My bases"
40
#define TEST_FILENAME "test.az"
41
#define TEST_STRING_INIT "YOU don't know about me without you have read a book by the name of The Adventures of Tom Sawyer; but that ain't no matter. That book was made by Mr. Mark Twain, and he told the truth, mainly. There was things which he stretched, but mainly he told the truth. That is nothing. I never seen anybody but lied one time or another, without it was Aunt Polly, or the widow, or maybe Mary. Aunt Polly--Tom's Aunt Polly, she is--and Mary, and the Widow Douglas is all told about in that book, which is mostly a true book, with some stretchers, as I said before. Now the way that the book winds up is this: Tom and me found the money that the robbers hid in the cave, and it made us rich. We got six thousand dollars apiece--all gold. It was an awful sight of money when it was piled up. Well, Judge Thatcher he took it and put it out at interest, and it fetched us a dollar a day apiece all the year round --more than a body could tell what to do with. The Widow Douglas she took me for her son, and allowed she would..."
42
#define TEST_LOOP_NUM 100
44
#define BUFFER_LEN 1024
46
char test_string[BUFFER_LEN];
48
uint64_t row_lengths[]= {536870912LL, 2147483648LL, 4294967296LL, 8589934592LL};
49
uint64_t row_numbers[]= {524288LL, 2097152LL, 4194304LL, 8388608LL};
52
int size_test(uint64_t length, uint64_t rows_to_test_for, az_method method);
53
int small_test(az_method method);
54
long int timedif(struct timeval a, struct timeval b);
57
int main(int argc, char *argv[])
65
drizzled::internal::my_init();
68
for (method= AZ_METHOD_BLOCK; method < AZ_METHOD_MAX; method++)
70
struct timeval start_time, end_time;
73
printf("Testing %d\n", (int)method);
74
gettimeofday(&start_time, NULL);
75
small_test((az_method)method);
76
gettimeofday(&end_time, NULL);
77
timing= timedif(end_time, start_time);
78
printf("\tTime took %ld.%03ld seconds\n\n", timing / 1000, timing % 1000);
84
/* Start size tests */
85
printf("About to run .5/2/4/8 gig tests now, you may want to hit CTRL-C\n");
86
for (x= 0; x < 4; x++) /* 4 is the current size of the array we use */
88
for (method= AZ_METHOD_BLOCK; method < AZ_METHOD_MAX; method++)
90
struct timeval start_time, end_time;
93
printf("Testing %"PRIu64" bytes with (%d)\n", row_lengths[x], (int)method);
94
gettimeofday(&start_time, NULL);
95
size_test(row_lengths[x], row_numbers[x], (az_method)method);
96
gettimeofday(&end_time, NULL);
97
timing= timedif(end_time, start_time);
98
printf("\tTime took %ld.%03ld seconds\n\n", timing / 1000, timing % 1000);
102
drizzled::internal::my_end();
107
int small_test(az_method method)
110
char comment_str[10];
115
azio_stream writer_handle, reader_handle;
117
memcpy(test_string, TEST_STRING_INIT, 1024);
119
unlink(TEST_FILENAME);
121
if (!(ret= azopen(&writer_handle, TEST_FILENAME, O_CREAT|O_RDWR,
124
printf("Could not create test file\n");
128
azwrite_comment(&writer_handle, (char *)COMMENT_STRING,
129
(unsigned int)strlen(COMMENT_STRING));
130
azread_comment(&writer_handle, comment_str);
131
assert(!memcmp(COMMENT_STRING, comment_str,
132
strlen(COMMENT_STRING)));
134
azwrite_frm(&writer_handle, (char *)FRM_STRING,
135
(unsigned int)strlen(FRM_STRING));
136
azread_frm(&writer_handle, comment_str);
137
assert(!memcmp(FRM_STRING, comment_str,
138
strlen(FRM_STRING)));
141
if (!(ret= azopen(&reader_handle, TEST_FILENAME, O_RDONLY,
144
printf("Could not open test file\n");
148
assert(reader_handle.rows == 0);
149
assert(reader_handle.auto_increment == 0);
150
assert(reader_handle.check_point == 0);
151
assert(reader_handle.forced_flushes == 0);
152
assert(reader_handle.dirty == AZ_STATE_DIRTY);
154
for (x= 0; x < TEST_LOOP_NUM; x++)
156
ret= azwrite_row(&writer_handle, test_string, BUFFER_LEN);
157
assert(ret == BUFFER_LEN);
160
azflush(&writer_handle, Z_SYNC_FLUSH);
162
azread_comment(&writer_handle, comment_str);
163
assert(!memcmp(COMMENT_STRING, comment_str,
164
strlen(COMMENT_STRING)));
166
/* Lets test that our internal stats are good */
167
assert(writer_handle.rows == TEST_LOOP_NUM);
169
/* Reader needs to be flushed to make sure it is up to date */
170
azflush(&reader_handle, Z_SYNC_FLUSH);
171
assert(reader_handle.rows == TEST_LOOP_NUM);
172
assert(reader_handle.auto_increment == 0);
173
assert(reader_handle.check_point == 1269);
174
assert(reader_handle.forced_flushes == 1);
175
assert(reader_handle.comment_length == 10);
176
assert(reader_handle.dirty == AZ_STATE_SAVED);
178
writer_handle.auto_increment= 4;
179
azflush(&writer_handle, Z_SYNC_FLUSH);
180
assert(writer_handle.rows == TEST_LOOP_NUM);
181
assert(writer_handle.auto_increment == 4);
182
assert(writer_handle.check_point == 1269);
183
assert(writer_handle.forced_flushes == 2);
184
assert(writer_handle.dirty == AZ_STATE_SAVED);
186
azclose(&reader_handle);
188
if (!(ret= azopen(&reader_handle, TEST_FILENAME, O_RDONLY,
191
printf("Could not open test file\n");
196
/* Read the original data */
197
azread_init(&reader_handle);
198
for (x= 0; x < writer_handle.rows; x++)
200
ret= azread_row(&reader_handle, &error);
202
assert(ret == BUFFER_LEN);
203
assert(!memcmp(reader_handle.row_ptr, test_string, ret));
205
assert(writer_handle.rows == TEST_LOOP_NUM);
208
/* Test here for falling off the planet */
210
/* Final Write before closing */
211
ret= azwrite_row(&writer_handle, test_string, BUFFER_LEN);
212
assert(ret == BUFFER_LEN);
214
/* We don't use FINISH, but I want to have it tested */
215
azflush(&writer_handle, Z_FINISH);
217
assert(writer_handle.rows == TEST_LOOP_NUM+1);
219
/* Read final write */
220
azread_init(&reader_handle);
221
for (x= 0; x < writer_handle.rows; x++)
223
ret= azread_row(&reader_handle, &error);
224
assert(ret == BUFFER_LEN);
226
assert(!memcmp(reader_handle.row_ptr, test_string, ret));
230
azclose(&writer_handle);
233
/* Rewind and full test */
234
azread_init(&reader_handle);
235
for (x= 0; x < writer_handle.rows; x++)
237
ret= azread_row(&reader_handle, &error);
238
assert(ret == BUFFER_LEN);
240
assert(!memcmp(reader_handle.row_ptr, test_string, ret));
243
if (!(ret= azopen(&writer_handle, TEST_FILENAME, O_RDWR, method)))
245
printf("Could not open file (%s) for appending\n", TEST_FILENAME);
248
ret= azwrite_row(&writer_handle, test_string, BUFFER_LEN);
249
assert(ret == BUFFER_LEN);
250
azflush(&writer_handle, Z_SYNC_FLUSH);
251
azflush(&reader_handle, Z_SYNC_FLUSH);
253
/* Rewind and full test */
254
azread_init(&reader_handle);
255
for (x= 0; x < writer_handle.rows; x++)
257
ret= azread_row(&reader_handle, &error);
259
assert(ret == BUFFER_LEN);
260
assert(!memcmp(reader_handle.row_ptr, test_string, ret));
263
/* Reader needs to be flushed to make sure it is up to date */
264
azflush(&reader_handle, Z_SYNC_FLUSH);
265
assert(reader_handle.rows == 102);
266
assert(reader_handle.auto_increment == 4);
267
assert(reader_handle.check_point == 1829);
268
assert(reader_handle.forced_flushes == 4);
269
assert(reader_handle.dirty == AZ_STATE_SAVED);
271
azflush(&writer_handle, Z_SYNC_FLUSH);
272
assert(writer_handle.rows == reader_handle.rows);
273
assert(writer_handle.auto_increment == reader_handle.auto_increment);
274
assert(writer_handle.check_point == reader_handle.check_point);
275
/* This is +1 because we do a flush right before we read */
276
assert(writer_handle.forced_flushes == reader_handle.forced_flushes + 1);
277
assert(writer_handle.dirty == reader_handle.dirty);
279
azclose(&writer_handle);
280
azclose(&reader_handle);
281
unlink(TEST_FILENAME);
286
int size_test(uint64_t length, uint64_t rows_to_test_for,
289
azio_stream writer_handle, reader_handle;
290
uint64_t write_length;
291
uint64_t read_length;
297
if (!(ret= azopen(&writer_handle, TEST_FILENAME,
298
O_CREAT|O_RDWR|O_TRUNC,
301
printf("Could not create test file\n");
305
for (count= 0, write_length= 0; write_length < length ;
309
ret= azwrite_row(&writer_handle, test_string, BUFFER_LEN);
310
if (ret != BUFFER_LEN)
312
printf("Size %u\n", ret);
313
assert(ret != BUFFER_LEN);
315
if ((write_length % 14031) == 0)
317
azflush(&writer_handle, Z_SYNC_FLUSH);
320
assert(write_length == count * BUFFER_LEN); /* Number of rows time BUFFER_LEN */
321
azflush(&writer_handle, Z_SYNC_FLUSH);
323
if (!(ret= azopen(&reader_handle, TEST_FILENAME, O_RDONLY,
326
printf("Could not open test file\n");
330
/* We do a double loop to test speed */
331
for (x= 0, read_length= 0; x < 2; x++, read_length= 0)
335
azread_init(&reader_handle);
336
for (read_count= 0; read_count < writer_handle.rows; read_count++)
338
ret= azread_row(&reader_handle, &error);
340
assert(!memcmp(reader_handle.row_ptr, test_string, ret));
341
if (ret != BUFFER_LEN)
343
printf("Size %u\n", ret);
344
assert(ret != BUFFER_LEN);
347
azread_init(&reader_handle);
349
assert(read_length == write_length);
350
assert(writer_handle.rows == rows_to_test_for);
352
azclose(&writer_handle);
353
azclose(&reader_handle);
355
unlink(TEST_FILENAME);
360
long int timedif(struct timeval a, struct timeval b)
364
us = a.tv_usec - b.tv_usec;
366
s = a.tv_sec - b.tv_sec;
added
removed
plugin/archive/archive_test.cc
