test_hydrogen.c 36 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394
  1. /*
  2. * test_suites.c
  3. *
  4. * Created on: Jun 19, 2013
  5. * Author: petera
  6. */
  7. #include "testrunner.h"
  8. #include "test_spiffs.h"
  9. #include "spiffs_nucleus.h"
  10. #include "spiffs.h"
  11. #include <sys/types.h>
  12. #include <sys/stat.h>
  13. #include <fcntl.h>
  14. #include <dirent.h>
  15. #include <unistd.h>
  16. SUITE(hydrogen_tests)
  17. void setup() {
  18. _setup();
  19. }
  20. void teardown() {
  21. _teardown();
  22. }
  23. TEST(info)
  24. {
  25. u32_t used, total;
  26. int res = SPIFFS_info(FS, &total, &used);
  27. TEST_CHECK(res == SPIFFS_OK);
  28. TEST_CHECK(used == 0);
  29. TEST_CHECK(total < __fs.cfg.phys_size);
  30. return TEST_RES_OK;
  31. }
  32. TEST_END(info)
  33. TEST(missing_file)
  34. {
  35. spiffs_file fd = SPIFFS_open(FS, "this_wont_exist", SPIFFS_RDONLY, 0);
  36. TEST_CHECK(fd < 0);
  37. return TEST_RES_OK;
  38. }
  39. TEST_END(missing_file)
  40. TEST(bad_fd)
  41. {
  42. int res;
  43. spiffs_stat s;
  44. spiffs_file fd = SPIFFS_open(FS, "this_wont_exist", SPIFFS_RDONLY, 0);
  45. TEST_CHECK(fd < 0);
  46. res = SPIFFS_fstat(FS, fd, &s);
  47. TEST_CHECK(res < 0);
  48. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_BAD_DESCRIPTOR);
  49. res = SPIFFS_fremove(FS, fd);
  50. TEST_CHECK(res < 0);
  51. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_BAD_DESCRIPTOR);
  52. res = SPIFFS_lseek(FS, fd, 0, SPIFFS_SEEK_CUR);
  53. TEST_CHECK(res < 0);
  54. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_BAD_DESCRIPTOR);
  55. res = SPIFFS_read(FS, fd, 0, 0);
  56. TEST_CHECK(res < 0);
  57. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_BAD_DESCRIPTOR);
  58. res = SPIFFS_write(FS, fd, 0, 0);
  59. TEST_CHECK(res < 0);
  60. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_BAD_DESCRIPTOR);
  61. return TEST_RES_OK;
  62. }
  63. TEST_END(bad_fd)
  64. TEST(closed_fd)
  65. {
  66. int res;
  67. spiffs_stat s;
  68. res = test_create_file("file");
  69. spiffs_file fd = SPIFFS_open(FS, "file", SPIFFS_RDONLY, 0);
  70. TEST_CHECK(fd >= 0);
  71. SPIFFS_close(FS, fd);
  72. res = SPIFFS_fstat(FS, fd, &s);
  73. TEST_CHECK(res < 0);
  74. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  75. res = SPIFFS_fremove(FS, fd);
  76. TEST_CHECK(res < 0);
  77. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  78. res = SPIFFS_lseek(FS, fd, 0, SPIFFS_SEEK_CUR);
  79. TEST_CHECK(res < 0);
  80. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  81. res = SPIFFS_read(FS, fd, 0, 0);
  82. TEST_CHECK(res < 0);
  83. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  84. res = SPIFFS_write(FS, fd, 0, 0);
  85. TEST_CHECK(res < 0);
  86. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  87. return TEST_RES_OK;
  88. }
  89. TEST_END(closed_fd)
  90. TEST(deleted_same_fd)
  91. {
  92. int res;
  93. spiffs_stat s;
  94. spiffs_file fd;
  95. res = test_create_file("remove");
  96. fd = SPIFFS_open(FS, "remove", SPIFFS_RDWR, 0);
  97. TEST_CHECK(fd >= 0);
  98. fd = SPIFFS_open(FS, "remove", SPIFFS_RDWR, 0);
  99. TEST_CHECK(fd >= 0);
  100. res = SPIFFS_fremove(FS, fd);
  101. TEST_CHECK(res >= 0);
  102. res = SPIFFS_fstat(FS, fd, &s);
  103. TEST_CHECK(res < 0);
  104. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  105. res = SPIFFS_fremove(FS, fd);
  106. TEST_CHECK(res < 0);
  107. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  108. res = SPIFFS_lseek(FS, fd, 0, SPIFFS_SEEK_CUR);
  109. TEST_CHECK(res < 0);
  110. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  111. res = SPIFFS_read(FS, fd, 0, 0);
  112. TEST_CHECK(res < 0);
  113. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  114. res = SPIFFS_write(FS, fd, 0, 0);
  115. TEST_CHECK(res < 0);
  116. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  117. return TEST_RES_OK;
  118. }
  119. TEST_END(deleted_same_fd)
  120. TEST(deleted_other_fd)
  121. {
  122. int res;
  123. spiffs_stat s;
  124. spiffs_file fd, fd_orig;
  125. res = test_create_file("remove");
  126. fd_orig = SPIFFS_open(FS, "remove", SPIFFS_RDWR, 0);
  127. TEST_CHECK(fd_orig >= 0);
  128. fd = SPIFFS_open(FS, "remove", SPIFFS_RDWR, 0);
  129. TEST_CHECK(fd >= 0);
  130. res = SPIFFS_fremove(FS, fd_orig);
  131. TEST_CHECK(res >= 0);
  132. SPIFFS_close(FS, fd_orig);
  133. res = SPIFFS_fstat(FS, fd, &s);
  134. TEST_CHECK(res < 0);
  135. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  136. res = SPIFFS_fremove(FS, fd);
  137. TEST_CHECK(res < 0);
  138. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  139. res = SPIFFS_lseek(FS, fd, 0, SPIFFS_SEEK_CUR);
  140. TEST_CHECK(res < 0);
  141. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  142. res = SPIFFS_read(FS, fd, 0, 0);
  143. TEST_CHECK(res < 0);
  144. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  145. res = SPIFFS_write(FS, fd, 0, 0);
  146. TEST_CHECK(res < 0);
  147. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FILE_CLOSED);
  148. return TEST_RES_OK;
  149. }
  150. TEST_END(deleted_other_fd)
  151. TEST(file_by_open)
  152. {
  153. int res;
  154. spiffs_stat s;
  155. spiffs_file fd = SPIFFS_open(FS, "filebopen", SPIFFS_CREAT, 0);
  156. TEST_CHECK(fd >= 0);
  157. res = SPIFFS_fstat(FS, fd, &s);
  158. TEST_CHECK(res >= 0);
  159. TEST_CHECK(strcmp((char*)s.name, "filebopen") == 0);
  160. TEST_CHECK(s.size == 0);
  161. SPIFFS_close(FS, fd);
  162. fd = SPIFFS_open(FS, "filebopen", SPIFFS_RDONLY, 0);
  163. TEST_CHECK(fd >= 0);
  164. res = SPIFFS_fstat(FS, fd, &s);
  165. TEST_CHECK(res >= 0);
  166. TEST_CHECK(strcmp((char*)s.name, "filebopen") == 0);
  167. TEST_CHECK(s.size == 0);
  168. SPIFFS_close(FS, fd);
  169. return TEST_RES_OK;
  170. }
  171. TEST_END(file_by_open)
  172. TEST(file_by_creat)
  173. {
  174. int res;
  175. res = test_create_file("filebcreat");
  176. TEST_CHECK(res >= 0);
  177. res = SPIFFS_creat(FS, "filebcreat", 0);
  178. TEST_CHECK(res < 0);
  179. TEST_CHECK(SPIFFS_errno(FS)==SPIFFS_ERR_CONFLICTING_NAME);
  180. return TEST_RES_OK;
  181. }
  182. TEST_END(file_by_creat)
  183. TEST(list_dir)
  184. {
  185. int res;
  186. char *files[4] = {
  187. "file1",
  188. "file2",
  189. "file3",
  190. "file4"
  191. };
  192. int file_cnt = sizeof(files)/sizeof(char *);
  193. int i;
  194. for (i = 0; i < file_cnt; i++) {
  195. res = test_create_file(files[i]);
  196. TEST_CHECK(res >= 0);
  197. }
  198. spiffs_DIR d;
  199. struct spiffs_dirent e;
  200. struct spiffs_dirent *pe = &e;
  201. SPIFFS_opendir(FS, "/", &d);
  202. int found = 0;
  203. while ((pe = SPIFFS_readdir(&d, pe))) {
  204. printf(" %s [%04x] size:%i\n", pe->name, pe->obj_id, pe->size);
  205. for (i = 0; i < file_cnt; i++) {
  206. if (strcmp(files[i], pe->name) == 0) {
  207. found++;
  208. break;
  209. }
  210. }
  211. }
  212. SPIFFS_closedir(&d);
  213. TEST_CHECK(found == file_cnt);
  214. return TEST_RES_OK;
  215. }
  216. TEST_END(list_dir)
  217. TEST(open_by_dirent) {
  218. int res;
  219. char *files[4] = {
  220. "file1",
  221. "file2",
  222. "file3",
  223. "file4"
  224. };
  225. int file_cnt = sizeof(files)/sizeof(char *);
  226. int i;
  227. int size = SPIFFS_DATA_PAGE_SIZE(FS);
  228. for (i = 0; i < file_cnt; i++) {
  229. res = test_create_and_write_file(files[i], size, size);
  230. TEST_CHECK(res >= 0);
  231. }
  232. spiffs_DIR d;
  233. struct spiffs_dirent e;
  234. struct spiffs_dirent *pe = &e;
  235. int found = 0;
  236. SPIFFS_opendir(FS, "/", &d);
  237. while ((pe = SPIFFS_readdir(&d, pe))) {
  238. spiffs_file fd = SPIFFS_open_by_dirent(FS, pe, SPIFFS_RDWR, 0);
  239. TEST_CHECK(fd >= 0);
  240. res = read_and_verify_fd(fd, pe->name);
  241. TEST_CHECK(res == SPIFFS_OK);
  242. fd = SPIFFS_open_by_dirent(FS, pe, SPIFFS_RDWR, 0);
  243. TEST_CHECK(fd >= 0);
  244. res = SPIFFS_fremove(FS, fd);
  245. TEST_CHECK(res == SPIFFS_OK);
  246. SPIFFS_close(FS, fd);
  247. found++;
  248. }
  249. SPIFFS_closedir(&d);
  250. TEST_CHECK(found == file_cnt);
  251. found = 0;
  252. SPIFFS_opendir(FS, "/", &d);
  253. while ((pe = SPIFFS_readdir(&d, pe))) {
  254. found++;
  255. }
  256. SPIFFS_closedir(&d);
  257. TEST_CHECK(found == 0);
  258. return TEST_RES_OK;
  259. } TEST_END(open_by_dirent)
  260. TEST(rename) {
  261. int res;
  262. char *src_name = "baah";
  263. char *dst_name = "booh";
  264. char *dst_name2 = "beeh";
  265. int size = SPIFFS_DATA_PAGE_SIZE(FS);
  266. res = test_create_and_write_file(src_name, size, size);
  267. TEST_CHECK(res >= 0);
  268. res = SPIFFS_rename(FS, src_name, dst_name);
  269. TEST_CHECK(res >= 0);
  270. res = SPIFFS_rename(FS, dst_name, dst_name);
  271. TEST_CHECK(res < 0);
  272. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_CONFLICTING_NAME);
  273. res = SPIFFS_rename(FS, src_name, dst_name2);
  274. TEST_CHECK(res < 0);
  275. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_NOT_FOUND);
  276. return TEST_RES_OK;
  277. } TEST_END(rename)
  278. TEST(remove_single_by_path)
  279. {
  280. int res;
  281. spiffs_file fd;
  282. res = test_create_file("remove");
  283. TEST_CHECK(res >= 0);
  284. res = SPIFFS_remove(FS, "remove");
  285. TEST_CHECK(res >= 0);
  286. fd = SPIFFS_open(FS, "remove", SPIFFS_RDONLY, 0);
  287. TEST_CHECK(fd < 0);
  288. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_NOT_FOUND);
  289. return TEST_RES_OK;
  290. }
  291. TEST_END(remove_single_by_path)
  292. TEST(remove_single_by_fd)
  293. {
  294. int res;
  295. spiffs_file fd;
  296. res = test_create_file("remove");
  297. TEST_CHECK(res >= 0);
  298. fd = SPIFFS_open(FS, "remove", SPIFFS_RDWR, 0);
  299. TEST_CHECK(fd >= 0);
  300. res = SPIFFS_fremove(FS, fd);
  301. TEST_CHECK(res >= 0);
  302. SPIFFS_close(FS, fd);
  303. fd = SPIFFS_open(FS, "remove", SPIFFS_RDONLY, 0);
  304. TEST_CHECK(fd < 0);
  305. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_NOT_FOUND);
  306. return TEST_RES_OK;
  307. }
  308. TEST_END(remove_single_by_fd)
  309. TEST(write_big_file_chunks_page)
  310. {
  311. int size = ((50*(FS)->cfg.phys_size)/100);
  312. printf(" filesize %i\n", size);
  313. int res = test_create_and_write_file("bigfile", size, SPIFFS_DATA_PAGE_SIZE(FS));
  314. TEST_CHECK(res >= 0);
  315. res = read_and_verify("bigfile");
  316. TEST_CHECK(res >= 0);
  317. return TEST_RES_OK;
  318. }
  319. TEST_END(write_big_file_chunks_page)
  320. TEST(write_big_files_chunks_page)
  321. {
  322. char name[32];
  323. int f;
  324. int files = 10;
  325. int res;
  326. int size = ((50*(FS)->cfg.phys_size)/100)/files;
  327. printf(" filesize %i\n", size);
  328. for (f = 0; f < files; f++) {
  329. sprintf(name, "bigfile%i", f);
  330. res = test_create_and_write_file(name, size, SPIFFS_DATA_PAGE_SIZE(FS));
  331. TEST_CHECK(res >= 0);
  332. }
  333. for (f = 0; f < files; f++) {
  334. sprintf(name, "bigfile%i", f);
  335. res = read_and_verify(name);
  336. TEST_CHECK(res >= 0);
  337. }
  338. return TEST_RES_OK;
  339. }
  340. TEST_END(write_big_files_chunks_page)
  341. TEST(write_big_file_chunks_index)
  342. {
  343. int size = ((50*(FS)->cfg.phys_size)/100);
  344. printf(" filesize %i\n", size);
  345. int res = test_create_and_write_file("bigfile", size, SPIFFS_DATA_PAGE_SIZE(FS) * SPIFFS_OBJ_HDR_IX_LEN(FS));
  346. TEST_CHECK(res >= 0);
  347. res = read_and_verify("bigfile");
  348. TEST_CHECK(res >= 0);
  349. return TEST_RES_OK;
  350. }
  351. TEST_END(write_big_file_chunks_index)
  352. TEST(write_big_files_chunks_index)
  353. {
  354. char name[32];
  355. int f;
  356. int files = 10;
  357. int res;
  358. int size = ((50*(FS)->cfg.phys_size)/100)/files;
  359. printf(" filesize %i\n", size);
  360. for (f = 0; f < files; f++) {
  361. sprintf(name, "bigfile%i", f);
  362. res = test_create_and_write_file(name, size, SPIFFS_DATA_PAGE_SIZE(FS) * SPIFFS_OBJ_HDR_IX_LEN(FS));
  363. TEST_CHECK(res >= 0);
  364. }
  365. for (f = 0; f < files; f++) {
  366. sprintf(name, "bigfile%i", f);
  367. res = read_and_verify(name);
  368. TEST_CHECK(res >= 0);
  369. }
  370. return TEST_RES_OK;
  371. }
  372. TEST_END(write_big_files_chunks_index)
  373. TEST(write_big_file_chunks_huge)
  374. {
  375. int size = (FS_PURE_DATA_PAGES(FS) / 2) * SPIFFS_DATA_PAGE_SIZE(FS);
  376. printf(" filesize %i\n", size);
  377. int res = test_create_and_write_file("bigfile", size, size);
  378. TEST_CHECK(res >= 0);
  379. res = read_and_verify("bigfile");
  380. TEST_CHECK(res >= 0);
  381. return TEST_RES_OK;
  382. }
  383. TEST_END(write_big_file_chunks_huge)
  384. TEST(write_big_files_chunks_huge)
  385. {
  386. char name[32];
  387. int f;
  388. int files = 10;
  389. int res;
  390. int size = ((50*(FS)->cfg.phys_size)/100)/files;
  391. printf(" filesize %i\n", size);
  392. for (f = 0; f < files; f++) {
  393. sprintf(name, "bigfile%i", f);
  394. res = test_create_and_write_file(name, size, size);
  395. TEST_CHECK(res >= 0);
  396. }
  397. for (f = 0; f < files; f++) {
  398. sprintf(name, "bigfile%i", f);
  399. res = read_and_verify(name);
  400. TEST_CHECK(res >= 0);
  401. }
  402. return TEST_RES_OK;
  403. }
  404. TEST_END(write_big_files_chunks_huge)
  405. TEST(truncate_big_file)
  406. {
  407. int size = (FS_PURE_DATA_PAGES(FS) / 2) * SPIFFS_DATA_PAGE_SIZE(FS);
  408. printf(" filesize %i\n", size);
  409. int res = test_create_and_write_file("bigfile", size, size);
  410. TEST_CHECK(res >= 0);
  411. res = read_and_verify("bigfile");
  412. TEST_CHECK(res >= 0);
  413. spiffs_file fd = SPIFFS_open(FS, "bigfile", SPIFFS_RDWR, 0);
  414. TEST_CHECK(fd > 0);
  415. res = SPIFFS_fremove(FS, fd);
  416. TEST_CHECK(res >= 0);
  417. SPIFFS_close(FS, fd);
  418. fd = SPIFFS_open(FS, "bigfile", SPIFFS_RDWR, 0);
  419. TEST_CHECK(fd < 0);
  420. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_NOT_FOUND);
  421. return TEST_RES_OK;
  422. }
  423. TEST_END(truncate_big_file)
  424. TEST(simultaneous_write) {
  425. int res = SPIFFS_creat(FS, "simul1", 0);
  426. TEST_CHECK(res >= 0);
  427. spiffs_file fd1 = SPIFFS_open(FS, "simul1", SPIFFS_RDWR, 0);
  428. TEST_CHECK(fd1 > 0);
  429. spiffs_file fd2 = SPIFFS_open(FS, "simul1", SPIFFS_RDWR, 0);
  430. TEST_CHECK(fd2 > 0);
  431. spiffs_file fd3 = SPIFFS_open(FS, "simul1", SPIFFS_RDWR, 0);
  432. TEST_CHECK(fd3 > 0);
  433. u8_t data1 = 1;
  434. u8_t data2 = 2;
  435. u8_t data3 = 3;
  436. res = SPIFFS_write(FS, fd1, &data1, 1);
  437. TEST_CHECK(res >= 0);
  438. SPIFFS_close(FS, fd1);
  439. res = SPIFFS_write(FS, fd2, &data2, 1);
  440. TEST_CHECK(res >= 0);
  441. SPIFFS_close(FS, fd2);
  442. res = SPIFFS_write(FS, fd3, &data3, 1);
  443. TEST_CHECK(res >= 0);
  444. SPIFFS_close(FS, fd3);
  445. spiffs_stat s;
  446. res = SPIFFS_stat(FS, "simul1", &s);
  447. TEST_CHECK(res >= 0);
  448. TEST_CHECK(s.size == 1);
  449. u8_t rdata;
  450. spiffs_file fd = SPIFFS_open(FS, "simul1", SPIFFS_RDONLY, 0);
  451. TEST_CHECK(fd > 0);
  452. res = SPIFFS_read(FS, fd, &rdata, 1);
  453. TEST_CHECK(res >= 0);
  454. TEST_CHECK(rdata == data3);
  455. return TEST_RES_OK;
  456. }
  457. TEST_END(simultaneous_write)
  458. TEST(simultaneous_write_append) {
  459. int res = SPIFFS_creat(FS, "simul2", 0);
  460. TEST_CHECK(res >= 0);
  461. spiffs_file fd1 = SPIFFS_open(FS, "simul2", SPIFFS_RDWR | SPIFFS_APPEND, 0);
  462. TEST_CHECK(fd1 > 0);
  463. spiffs_file fd2 = SPIFFS_open(FS, "simul2", SPIFFS_RDWR | SPIFFS_APPEND, 0);
  464. TEST_CHECK(fd2 > 0);
  465. spiffs_file fd3 = SPIFFS_open(FS, "simul2", SPIFFS_RDWR | SPIFFS_APPEND, 0);
  466. TEST_CHECK(fd3 > 0);
  467. u8_t data1 = 1;
  468. u8_t data2 = 2;
  469. u8_t data3 = 3;
  470. res = SPIFFS_write(FS, fd1, &data1, 1);
  471. TEST_CHECK(res >= 0);
  472. SPIFFS_close(FS, fd1);
  473. res = SPIFFS_write(FS, fd2, &data2, 1);
  474. TEST_CHECK(res >= 0);
  475. SPIFFS_close(FS, fd2);
  476. res = SPIFFS_write(FS, fd3, &data3, 1);
  477. TEST_CHECK(res >= 0);
  478. SPIFFS_close(FS, fd3);
  479. spiffs_stat s;
  480. res = SPIFFS_stat(FS, "simul2", &s);
  481. TEST_CHECK(res >= 0);
  482. TEST_CHECK(s.size == 3);
  483. u8_t rdata[3];
  484. spiffs_file fd = SPIFFS_open(FS, "simul2", SPIFFS_RDONLY, 0);
  485. TEST_CHECK(fd > 0);
  486. res = SPIFFS_read(FS, fd, &rdata, 3);
  487. TEST_CHECK(res >= 0);
  488. TEST_CHECK(rdata[0] == data1);
  489. TEST_CHECK(rdata[1] == data2);
  490. TEST_CHECK(rdata[2] == data3);
  491. return TEST_RES_OK;
  492. }
  493. TEST_END(simultaneous_write_append)
  494. TEST(file_uniqueness)
  495. {
  496. int res;
  497. spiffs_file fd;
  498. char fname[32];
  499. int files = ((SPIFFS_CFG_PHYS_SZ(FS) * 75) / 100) / 2 / SPIFFS_CFG_LOG_PAGE_SZ(FS);
  500. //(FS_PURE_DATA_PAGES(FS) / 2) - SPIFFS_PAGES_PER_BLOCK(FS)*8;
  501. int i;
  502. printf(" creating %i files\n", files);
  503. for (i = 0; i < files; i++) {
  504. char content[20];
  505. sprintf(fname, "file%i", i);
  506. sprintf(content, "%i", i);
  507. res = test_create_file(fname);
  508. TEST_CHECK(res >= 0);
  509. fd = SPIFFS_open(FS, fname, SPIFFS_APPEND | SPIFFS_RDWR, 0);
  510. TEST_CHECK(fd >= 0);
  511. res = SPIFFS_write(FS, fd, content, strlen(content)+1);
  512. TEST_CHECK(res >= 0);
  513. SPIFFS_close(FS, fd);
  514. }
  515. printf(" checking %i files\n", files);
  516. for (i = 0; i < files; i++) {
  517. char content[20];
  518. char ref_content[20];
  519. sprintf(fname, "file%i", i);
  520. sprintf(content, "%i", i);
  521. fd = SPIFFS_open(FS, fname, SPIFFS_RDONLY, 0);
  522. TEST_CHECK(fd >= 0);
  523. res = SPIFFS_read(FS, fd, ref_content, strlen(content)+1);
  524. TEST_CHECK(res >= 0);
  525. TEST_CHECK(strcmp(ref_content, content) == 0);
  526. SPIFFS_close(FS, fd);
  527. }
  528. printf(" removing %i files\n", files/2);
  529. for (i = 0; i < files; i += 2) {
  530. sprintf(fname, "file%i", i);
  531. res = SPIFFS_remove(FS, fname);
  532. TEST_CHECK(res >= 0);
  533. }
  534. printf(" creating %i files\n", files/2);
  535. for (i = 0; i < files; i += 2) {
  536. char content[20];
  537. sprintf(fname, "file%i", i);
  538. sprintf(content, "new%i", i);
  539. res = test_create_file(fname);
  540. TEST_CHECK(res >= 0);
  541. fd = SPIFFS_open(FS, fname, SPIFFS_APPEND | SPIFFS_RDWR, 0);
  542. TEST_CHECK(fd >= 0);
  543. res = SPIFFS_write(FS, fd, content, strlen(content)+1);
  544. TEST_CHECK(res >= 0);
  545. SPIFFS_close(FS, fd);
  546. }
  547. printf(" checking %i files\n", files);
  548. for (i = 0; i < files; i++) {
  549. char content[20];
  550. char ref_content[20];
  551. sprintf(fname, "file%i", i);
  552. if ((i & 1) == 0) {
  553. sprintf(content, "new%i", i);
  554. } else {
  555. sprintf(content, "%i", i);
  556. }
  557. fd = SPIFFS_open(FS, fname, SPIFFS_RDONLY, 0);
  558. TEST_CHECK(fd >= 0);
  559. res = SPIFFS_read(FS, fd, ref_content, strlen(content)+1);
  560. TEST_CHECK(res >= 0);
  561. TEST_CHECK(strcmp(ref_content, content) == 0);
  562. SPIFFS_close(FS, fd);
  563. }
  564. return TEST_RES_OK;
  565. }
  566. TEST_END(file_uniqueness)
  567. int create_and_read_back(int size, int chunk) {
  568. char *name = "file";
  569. spiffs_file fd;
  570. s32_t res;
  571. u8_t *buf = malloc(size);
  572. memrand(buf, size);
  573. res = test_create_file(name);
  574. CHECK(res >= 0);
  575. fd = SPIFFS_open(FS, name, SPIFFS_APPEND | SPIFFS_RDWR, 0);
  576. CHECK(fd >= 0);
  577. res = SPIFFS_write(FS, fd, buf, size);
  578. CHECK(res >= 0);
  579. spiffs_stat stat;
  580. res = SPIFFS_fstat(FS, fd, &stat);
  581. CHECK(res >= 0);
  582. CHECK(stat.size == size);
  583. SPIFFS_close(FS, fd);
  584. fd = SPIFFS_open(FS, name, SPIFFS_RDONLY, 0);
  585. CHECK(fd >= 0);
  586. u8_t *rbuf = malloc(size);
  587. int offs = 0;
  588. while (offs < size) {
  589. int len = MIN(size - offs, chunk);
  590. res = SPIFFS_read(FS, fd, &rbuf[offs], len);
  591. CHECK(res >= 0);
  592. CHECK(memcmp(&rbuf[offs], &buf[offs], len) == 0);
  593. offs += chunk;
  594. }
  595. CHECK(memcmp(&rbuf[0], &buf[0], size) == 0);
  596. SPIFFS_close(FS, fd);
  597. free(rbuf);
  598. free(buf);
  599. return 0;
  600. }
  601. TEST(read_chunk_1)
  602. {
  603. TEST_CHECK(create_and_read_back(SPIFFS_DATA_PAGE_SIZE(FS)*8, 1) == 0);
  604. return TEST_RES_OK;
  605. }
  606. TEST_END(read_chunk_1)
  607. TEST(read_chunk_page)
  608. {
  609. TEST_CHECK(create_and_read_back(SPIFFS_DATA_PAGE_SIZE(FS)*(SPIFFS_PAGES_PER_BLOCK(FS) - SPIFFS_OBJ_LOOKUP_PAGES(FS))*2,
  610. SPIFFS_DATA_PAGE_SIZE(FS)) == 0);
  611. return TEST_RES_OK;
  612. }
  613. TEST_END(read_chunk_page)
  614. TEST(read_chunk_index)
  615. {
  616. TEST_CHECK(create_and_read_back(SPIFFS_DATA_PAGE_SIZE(FS)*(SPIFFS_PAGES_PER_BLOCK(FS) - SPIFFS_OBJ_LOOKUP_PAGES(FS))*4,
  617. SPIFFS_DATA_PAGE_SIZE(FS)*(SPIFFS_PAGES_PER_BLOCK(FS) - SPIFFS_OBJ_LOOKUP_PAGES(FS))) == 0);
  618. return TEST_RES_OK;
  619. }
  620. TEST_END(read_chunk_index)
  621. TEST(read_chunk_huge)
  622. {
  623. int sz = (2*(FS)->cfg.phys_size)/3;
  624. TEST_CHECK(create_and_read_back(sz, sz) == 0);
  625. return TEST_RES_OK;
  626. }
  627. TEST_END(read_chunk_huge)
  628. TEST(read_beyond)
  629. {
  630. char *name = "file";
  631. spiffs_file fd;
  632. s32_t res;
  633. u32_t size = SPIFFS_DATA_PAGE_SIZE(FS)*2;
  634. u8_t *buf = malloc(size);
  635. memrand(buf, size);
  636. res = test_create_file(name);
  637. CHECK(res >= 0);
  638. fd = SPIFFS_open(FS, name, SPIFFS_APPEND | SPIFFS_RDWR, 0);
  639. CHECK(fd >= 0);
  640. res = SPIFFS_write(FS, fd, buf, size);
  641. CHECK(res >= 0);
  642. spiffs_stat stat;
  643. res = SPIFFS_fstat(FS, fd, &stat);
  644. CHECK(res >= 0);
  645. CHECK(stat.size == size);
  646. SPIFFS_close(FS, fd);
  647. fd = SPIFFS_open(FS, name, SPIFFS_RDONLY, 0);
  648. CHECK(fd >= 0);
  649. u8_t *rbuf = malloc(size+10);
  650. res = SPIFFS_read(FS, fd, rbuf, size+10);
  651. SPIFFS_close(FS, fd);
  652. free(rbuf);
  653. free(buf);
  654. TEST_CHECK(res == size);
  655. return TEST_RES_OK;
  656. }
  657. TEST_END(read_beyond)
  658. TEST(bad_index_1) {
  659. int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
  660. int res = test_create_and_write_file("file", size, size);
  661. TEST_CHECK(res >= 0);
  662. res = read_and_verify("file");
  663. TEST_CHECK(res >= 0);
  664. spiffs_file fd = SPIFFS_open(FS, "file", SPIFFS_RDONLY, 0);
  665. TEST_CHECK(fd > 0);
  666. spiffs_stat s;
  667. res = SPIFFS_fstat(FS, fd, &s);
  668. TEST_CHECK(res >= 0);
  669. SPIFFS_close(FS, fd);
  670. // modify object index, find object index header
  671. spiffs_page_ix pix;
  672. res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
  673. TEST_CHECK(res >= 0);
  674. // set object index entry 2 to a bad page, free
  675. u32_t addr = SPIFFS_PAGE_TO_PADDR(FS, pix) + sizeof(spiffs_page_object_ix_header) + 2 * sizeof(spiffs_page_ix);
  676. spiffs_page_ix bad_pix_ref = (spiffs_page_ix)-1;
  677. area_write(addr, (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
  678. #if SPIFFS_CACHE
  679. // delete all cache
  680. spiffs_cache *cache = spiffs_get_cache(FS);
  681. cache->cpage_use_map = 0;
  682. #endif
  683. res = read_and_verify("file");
  684. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_INDEX_REF_FREE);
  685. return TEST_RES_OK;
  686. } TEST_END(bad_index_1)
  687. TEST(bad_index_2) {
  688. int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
  689. int res = test_create_and_write_file("file", size, size);
  690. TEST_CHECK(res >= 0);
  691. res = read_and_verify("file");
  692. TEST_CHECK(res >= 0);
  693. spiffs_file fd = SPIFFS_open(FS, "file", SPIFFS_RDONLY, 0);
  694. TEST_CHECK(fd > 0);
  695. spiffs_stat s;
  696. res = SPIFFS_fstat(FS, fd, &s);
  697. TEST_CHECK(res >= 0);
  698. SPIFFS_close(FS, fd);
  699. // modify object index, find object index header
  700. spiffs_page_ix pix;
  701. res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
  702. TEST_CHECK(res >= 0);
  703. // set object index entry 2 to a bad page, lu
  704. u32_t addr = SPIFFS_PAGE_TO_PADDR(FS, pix) + sizeof(spiffs_page_object_ix_header) + 2 * sizeof(spiffs_page_ix);
  705. spiffs_page_ix bad_pix_ref = SPIFFS_OBJ_LOOKUP_PAGES(FS)-1;
  706. area_write(addr, (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
  707. #if SPIFFS_CACHE
  708. // delete all cache
  709. spiffs_cache *cache = spiffs_get_cache(FS);
  710. cache->cpage_use_map = 0;
  711. #endif
  712. res = read_and_verify("file");
  713. TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_INDEX_REF_LU);
  714. return TEST_RES_OK;
  715. } TEST_END(bad_index_2)
  716. TEST(lseek_simple_modification) {
  717. int res;
  718. spiffs_file fd;
  719. char *fname = "seekfile";
  720. int i;
  721. int len = 4096;
  722. fd = SPIFFS_open(FS, fname, SPIFFS_TRUNC | SPIFFS_CREAT | SPIFFS_RDWR, 0);
  723. TEST_CHECK(fd > 0);
  724. int pfd = open(make_test_fname(fname), O_TRUNC | O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
  725. u8_t *buf = malloc(len);
  726. memrand(buf, len);
  727. res = SPIFFS_write(FS, fd, buf, len);
  728. TEST_CHECK(res >= 0);
  729. write(pfd, buf, len);
  730. free(buf);
  731. res = read_and_verify(fname);
  732. TEST_CHECK(res >= 0);
  733. res = SPIFFS_lseek(FS, fd, len/2, SPIFFS_SEEK_SET);
  734. TEST_CHECK(res >= 0);
  735. lseek(pfd, len/2, SEEK_SET);
  736. len = len/4;
  737. buf = malloc(len);
  738. memrand(buf, len);
  739. res = SPIFFS_write(FS, fd, buf, len);
  740. TEST_CHECK(res >= 0);
  741. write(pfd, buf, len);
  742. free(buf);
  743. res = read_and_verify(fname);
  744. TEST_CHECK(res >= 0);
  745. SPIFFS_close(FS, fd);
  746. close(pfd);
  747. return TEST_RES_OK;
  748. }
  749. TEST_END(lseek_simple_modification)
  750. TEST(lseek_modification_append) {
  751. int res;
  752. spiffs_file fd;
  753. char *fname = "seekfile";
  754. int i;
  755. int len = 4096;
  756. fd = SPIFFS_open(FS, fname, SPIFFS_TRUNC | SPIFFS_CREAT | SPIFFS_RDWR, 0);
  757. TEST_CHECK(fd > 0);
  758. int pfd = open(make_test_fname(fname), O_TRUNC | O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
  759. u8_t *buf = malloc(len);
  760. memrand(buf, len);
  761. res = SPIFFS_write(FS, fd, buf, len);
  762. TEST_CHECK(res >= 0);
  763. write(pfd, buf, len);
  764. free(buf);
  765. res = read_and_verify(fname);
  766. TEST_CHECK(res >= 0);
  767. res = SPIFFS_lseek(FS, fd, len/2, SPIFFS_SEEK_SET);
  768. TEST_CHECK(res >= 0);
  769. lseek(pfd, len/2, SEEK_SET);
  770. buf = malloc(len);
  771. memrand(buf, len);
  772. res = SPIFFS_write(FS, fd, buf, len);
  773. TEST_CHECK(res >= 0);
  774. write(pfd, buf, len);
  775. free(buf);
  776. res = read_and_verify(fname);
  777. TEST_CHECK(res >= 0);
  778. SPIFFS_close(FS, fd);
  779. close(pfd);
  780. return TEST_RES_OK;
  781. }
  782. TEST_END(lseek_modification_append)
  783. TEST(lseek_modification_append_multi) {
  784. int res;
  785. spiffs_file fd;
  786. char *fname = "seekfile";
  787. int len = 1024;
  788. int runs = (FS_PURE_DATA_PAGES(FS) / 2) * SPIFFS_DATA_PAGE_SIZE(FS) / (len/2);
  789. fd = SPIFFS_open(FS, fname, SPIFFS_TRUNC | SPIFFS_CREAT | SPIFFS_RDWR, 0);
  790. TEST_CHECK(fd > 0);
  791. int pfd = open(make_test_fname(fname), O_TRUNC | O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
  792. u8_t *buf = malloc(len);
  793. memrand(buf, len);
  794. res = SPIFFS_write(FS, fd, buf, len);
  795. TEST_CHECK(res >= 0);
  796. write(pfd, buf, len);
  797. free(buf);
  798. res = read_and_verify(fname);
  799. TEST_CHECK(res >= 0);
  800. while (runs--) {
  801. res = SPIFFS_lseek(FS, fd, -len/2, SPIFFS_SEEK_END);
  802. TEST_CHECK(res >= 0);
  803. lseek(pfd, -len/2, SEEK_END);
  804. buf = malloc(len);
  805. memrand(buf, len);
  806. res = SPIFFS_write(FS, fd, buf, len);
  807. TEST_CHECK(res >= 0);
  808. write(pfd, buf, len);
  809. free(buf);
  810. res = read_and_verify(fname);
  811. TEST_CHECK(res >= 0);
  812. }
  813. SPIFFS_close(FS, fd);
  814. close(pfd);
  815. return TEST_RES_OK;
  816. }
  817. TEST_END(lseek_modification_append_multi)
  818. TEST(lseek_read) {
  819. int res;
  820. spiffs_file fd;
  821. char *fname = "seekfile";
  822. int len = (FS_PURE_DATA_PAGES(FS) / 2) * SPIFFS_DATA_PAGE_SIZE(FS);
  823. int runs = 100000;
  824. fd = SPIFFS_open(FS, fname, SPIFFS_TRUNC | SPIFFS_CREAT | SPIFFS_RDWR, 0);
  825. TEST_CHECK(fd > 0);
  826. u8_t *refbuf = malloc(len);
  827. memrand(refbuf, len);
  828. res = SPIFFS_write(FS, fd, refbuf, len);
  829. TEST_CHECK(res >= 0);
  830. int offs = 0;
  831. res = SPIFFS_lseek(FS, fd, 0, SPIFFS_SEEK_SET);
  832. TEST_CHECK(res >= 0);
  833. while (runs--) {
  834. int i;
  835. u8_t buf[64];
  836. if (offs + 41 + sizeof(buf) >= len) {
  837. offs = (offs + 41 + sizeof(buf)) % len;
  838. res = SPIFFS_lseek(FS, fd, offs, SPIFFS_SEEK_SET);
  839. TEST_CHECK(res >= 0);
  840. }
  841. res = SPIFFS_lseek(FS, fd, 41, SPIFFS_SEEK_CUR);
  842. TEST_CHECK(res >= 0);
  843. offs += 41;
  844. res = SPIFFS_read(FS, fd, buf, sizeof(buf));
  845. TEST_CHECK(res >= 0);
  846. for (i = 0; i < sizeof(buf); i++) {
  847. if (buf[i] != refbuf[offs+i]) {
  848. printf(" mismatch at offs %i\n", offs);
  849. }
  850. TEST_CHECK(buf[i] == refbuf[offs+i]);
  851. }
  852. offs += sizeof(buf);
  853. res = SPIFFS_lseek(FS, fd, -((u32_t)sizeof(buf)+11), SPIFFS_SEEK_CUR);
  854. TEST_CHECK(res >= 0);
  855. offs -= (sizeof(buf)+11);
  856. res = SPIFFS_read(FS, fd, buf, sizeof(buf));
  857. TEST_CHECK(res >= 0);
  858. for (i = 0; i < sizeof(buf); i++) {
  859. if (buf[i] != refbuf[offs+i]) {
  860. printf(" mismatch at offs %i\n", offs);
  861. }
  862. TEST_CHECK(buf[i] == refbuf[offs+i]);
  863. }
  864. offs += sizeof(buf);
  865. }
  866. free(refbuf);
  867. SPIFFS_close(FS, fd);
  868. return TEST_RES_OK;
  869. }
  870. TEST_END(lseek_read)
  871. TEST(write_small_file_chunks_1)
  872. {
  873. int res = test_create_and_write_file("smallfile", 256, 1);
  874. TEST_CHECK(res >= 0);
  875. res = read_and_verify("smallfile");
  876. TEST_CHECK(res >= 0);
  877. return TEST_RES_OK;
  878. }
  879. TEST_END(write_small_file_chunks_1)
  880. TEST(write_small_files_chunks_1)
  881. {
  882. char name[32];
  883. int f;
  884. int size = 512;
  885. int files = ((20*(FS)->cfg.phys_size)/100)/size;
  886. int res;
  887. for (f = 0; f < files; f++) {
  888. sprintf(name, "smallfile%i", f);
  889. res = test_create_and_write_file(name, size, 1);
  890. TEST_CHECK(res >= 0);
  891. }
  892. for (f = 0; f < files; f++) {
  893. sprintf(name, "smallfile%i", f);
  894. res = read_and_verify(name);
  895. TEST_CHECK(res >= 0);
  896. }
  897. return TEST_RES_OK;
  898. }
  899. TEST_END(write_small_files_chunks_1)
  900. TEST(write_big_file_chunks_1)
  901. {
  902. int size = ((50*(FS)->cfg.phys_size)/100);
  903. printf(" filesize %i\n", size);
  904. int res = test_create_and_write_file("bigfile", size, 1);
  905. TEST_CHECK(res >= 0);
  906. res = read_and_verify("bigfile");
  907. TEST_CHECK(res >= 0);
  908. return TEST_RES_OK;
  909. }
  910. TEST_END(write_big_file_chunks_1)
  911. TEST(write_big_files_chunks_1)
  912. {
  913. char name[32];
  914. int f;
  915. int files = 10;
  916. int res;
  917. int size = ((50*(FS)->cfg.phys_size)/100)/files;
  918. printf(" filesize %i\n", size);
  919. for (f = 0; f < files; f++) {
  920. sprintf(name, "bigfile%i", f);
  921. res = test_create_and_write_file(name, size, 1);
  922. TEST_CHECK(res >= 0);
  923. }
  924. for (f = 0; f < files; f++) {
  925. sprintf(name, "bigfile%i", f);
  926. res = read_and_verify(name);
  927. TEST_CHECK(res >= 0);
  928. }
  929. return TEST_RES_OK;
  930. }
  931. TEST_END(write_big_files_chunks_1)
  932. TEST(long_run_config_many_small_one_long)
  933. {
  934. tfile_conf cfgs[] = {
  935. { .tsize = LARGE, .ttype = MODIFIED, .tlife = LONG
  936. },
  937. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = SHORT
  938. },
  939. { .tsize = EMPTY, .ttype = APPENDED, .tlife = SHORT
  940. },
  941. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = SHORT
  942. },
  943. { .tsize = SMALL, .ttype = MODIFIED, .tlife = MEDIUM
  944. },
  945. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = LONG
  946. },
  947. { .tsize = SMALL, .ttype = MODIFIED, .tlife = MEDIUM
  948. },
  949. { .tsize = SMALL, .ttype = MODIFIED, .tlife = MEDIUM
  950. },
  951. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = LONG
  952. },
  953. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = MEDIUM
  954. },
  955. { .tsize = SMALL, .ttype = MODIFIED, .tlife = LONG
  956. },
  957. { .tsize = SMALL, .ttype = MODIFIED, .tlife = MEDIUM
  958. },
  959. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = LONG
  960. },
  961. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = MEDIUM
  962. },
  963. { .tsize = SMALL, .ttype = MODIFIED, .tlife = LONG
  964. },
  965. };
  966. int res = run_file_config(sizeof(cfgs)/sizeof(cfgs[0]), &cfgs[0], 206, 5, 0);
  967. TEST_CHECK(res >= 0);
  968. return TEST_RES_OK;
  969. }
  970. TEST_END(long_run_config_many_small_one_long)
  971. TEST(long_run_config_many_medium)
  972. {
  973. tfile_conf cfgs[] = {
  974. { .tsize = MEDIUM, .ttype = MODIFIED, .tlife = LONG
  975. },
  976. { .tsize = MEDIUM, .ttype = APPENDED, .tlife = LONG
  977. },
  978. { .tsize = LARGE, .ttype = MODIFIED, .tlife = LONG
  979. },
  980. { .tsize = MEDIUM, .ttype = APPENDED, .tlife = LONG
  981. },
  982. { .tsize = MEDIUM, .ttype = MODIFIED, .tlife = LONG
  983. },
  984. { .tsize = MEDIUM, .ttype = MODIFIED, .tlife = LONG
  985. },
  986. { .tsize = MEDIUM, .ttype = APPENDED, .tlife = LONG
  987. },
  988. { .tsize = LARGE, .ttype = MODIFIED, .tlife = LONG
  989. },
  990. { .tsize = MEDIUM, .ttype = APPENDED, .tlife = LONG
  991. },
  992. { .tsize = MEDIUM, .ttype = MODIFIED, .tlife = LONG
  993. },
  994. { .tsize = MEDIUM, .ttype = MODIFIED, .tlife = LONG
  995. },
  996. { .tsize = MEDIUM, .ttype = APPENDED, .tlife = LONG
  997. },
  998. { .tsize = LARGE, .ttype = MODIFIED, .tlife = LONG
  999. },
  1000. { .tsize = MEDIUM, .ttype = APPENDED, .tlife = LONG
  1001. },
  1002. { .tsize = MEDIUM, .ttype = MODIFIED, .tlife = LONG
  1003. },
  1004. };
  1005. int res = run_file_config(sizeof(cfgs)/sizeof(cfgs[0]), &cfgs[0], 305, 5, 0);
  1006. TEST_CHECK(res >= 0);
  1007. return TEST_RES_OK;
  1008. }
  1009. TEST_END(long_run_config_many_medium)
  1010. TEST(long_run_config_many_small)
  1011. {
  1012. tfile_conf cfgs[] = {
  1013. { .tsize = SMALL, .ttype = APPENDED, .tlife = LONG
  1014. },
  1015. { .tsize = SMALL, .ttype = MODIFIED, .tlife = MEDIUM
  1016. },
  1017. { .tsize = SMALL, .ttype = MODIFIED, .tlife = SHORT
  1018. },
  1019. { .tsize = SMALL, .ttype = APPENDED, .tlife = MEDIUM
  1020. },
  1021. { .tsize = SMALL, .ttype = APPENDED, .tlife = SHORT
  1022. },
  1023. { .tsize = EMPTY, .ttype = APPENDED, .tlife = MEDIUM
  1024. },
  1025. { .tsize = EMPTY, .ttype = APPENDED, .tlife = SHORT
  1026. },
  1027. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = MEDIUM
  1028. },
  1029. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = SHORT
  1030. },
  1031. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = MEDIUM
  1032. },
  1033. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = SHORT
  1034. },
  1035. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = MEDIUM
  1036. },
  1037. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = SHORT
  1038. },
  1039. { .tsize = EMPTY, .ttype = APPENDED, .tlife = MEDIUM
  1040. },
  1041. { .tsize = EMPTY, .ttype = APPENDED, .tlife = SHORT
  1042. },
  1043. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = MEDIUM
  1044. },
  1045. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = SHORT
  1046. },
  1047. { .tsize = SMALL, .ttype = MODIFIED, .tlife = MEDIUM
  1048. },
  1049. { .tsize = SMALL, .ttype = MODIFIED, .tlife = SHORT
  1050. },
  1051. { .tsize = SMALL, .ttype = APPENDED, .tlife = MEDIUM
  1052. },
  1053. { .tsize = SMALL, .ttype = APPENDED, .tlife = SHORT
  1054. },
  1055. { .tsize = SMALL, .ttype = APPENDED, .tlife = LONG
  1056. },
  1057. { .tsize = EMPTY, .ttype = APPENDED, .tlife = MEDIUM
  1058. },
  1059. { .tsize = EMPTY, .ttype = APPENDED, .tlife = SHORT
  1060. },
  1061. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = MEDIUM
  1062. },
  1063. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = SHORT
  1064. },
  1065. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = MEDIUM
  1066. },
  1067. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = SHORT
  1068. },
  1069. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = MEDIUM
  1070. },
  1071. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = SHORT
  1072. },
  1073. { .tsize = EMPTY, .ttype = APPENDED, .tlife = MEDIUM
  1074. },
  1075. { .tsize = EMPTY, .ttype = APPENDED, .tlife = SHORT
  1076. },
  1077. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = MEDIUM
  1078. },
  1079. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = SHORT
  1080. },
  1081. { .tsize = SMALL, .ttype = MODIFIED, .tlife = MEDIUM
  1082. },
  1083. { .tsize = SMALL, .ttype = MODIFIED, .tlife = SHORT
  1084. },
  1085. { .tsize = SMALL, .ttype = APPENDED, .tlife = MEDIUM
  1086. },
  1087. { .tsize = SMALL, .ttype = APPENDED, .tlife = SHORT
  1088. },
  1089. { .tsize = EMPTY, .ttype = APPENDED, .tlife = MEDIUM
  1090. },
  1091. { .tsize = EMPTY, .ttype = APPENDED, .tlife = SHORT
  1092. },
  1093. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = MEDIUM
  1094. },
  1095. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = SHORT
  1096. },
  1097. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = MEDIUM
  1098. },
  1099. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = SHORT
  1100. },
  1101. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = MEDIUM
  1102. },
  1103. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = SHORT
  1104. },
  1105. { .tsize = EMPTY, .ttype = APPENDED, .tlife = MEDIUM
  1106. },
  1107. { .tsize = EMPTY, .ttype = APPENDED, .tlife = SHORT
  1108. },
  1109. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = MEDIUM
  1110. },
  1111. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = SHORT
  1112. },
  1113. { .tsize = SMALL, .ttype = MODIFIED, .tlife = MEDIUM
  1114. },
  1115. { .tsize = SMALL, .ttype = MODIFIED, .tlife = SHORT
  1116. },
  1117. { .tsize = SMALL, .ttype = APPENDED, .tlife = MEDIUM
  1118. },
  1119. { .tsize = SMALL, .ttype = APPENDED, .tlife = SHORT
  1120. },
  1121. { .tsize = EMPTY, .ttype = APPENDED, .tlife = MEDIUM
  1122. },
  1123. { .tsize = EMPTY, .ttype = APPENDED, .tlife = SHORT
  1124. },
  1125. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = MEDIUM
  1126. },
  1127. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = SHORT
  1128. },
  1129. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = MEDIUM
  1130. },
  1131. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = SHORT
  1132. },
  1133. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = MEDIUM
  1134. },
  1135. { .tsize = SMALL, .ttype = UNTAMPERED, .tlife = SHORT
  1136. },
  1137. { .tsize = EMPTY, .ttype = APPENDED, .tlife = MEDIUM
  1138. },
  1139. { .tsize = EMPTY, .ttype = APPENDED, .tlife = SHORT
  1140. },
  1141. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = MEDIUM
  1142. },
  1143. { .tsize = EMPTY, .ttype = UNTAMPERED, .tlife = SHORT
  1144. },
  1145. };
  1146. int res = run_file_config(sizeof(cfgs)/sizeof(cfgs[0]), &cfgs[0], 115, 6, 0);
  1147. TEST_CHECK(res >= 0);
  1148. return TEST_RES_OK;
  1149. }
  1150. TEST_END(long_run_config_many_small)
  1151. TEST(long_run)
  1152. {
  1153. tfile_conf cfgs[] = {
  1154. { .tsize = EMPTY, .ttype = APPENDED, .tlife = MEDIUM
  1155. },
  1156. { .tsize = SMALL, .ttype = REWRITTEN, .tlife = SHORT
  1157. },
  1158. { .tsize = MEDIUM, .ttype = MODIFIED, .tlife = SHORT
  1159. },
  1160. { .tsize = MEDIUM, .ttype = APPENDED, .tlife = SHORT
  1161. },
  1162. };
  1163. int macro_runs = 500;
  1164. printf(" ");
  1165. u32_t clob_size = SPIFFS_CFG_PHYS_SZ(FS)/4;
  1166. int res = test_create_and_write_file("long_clobber", clob_size, clob_size);
  1167. TEST_CHECK(res >= 0);
  1168. res = read_and_verify("long_clobber");
  1169. TEST_CHECK(res >= 0);
  1170. while (macro_runs--) {
  1171. //printf(" ---- run %i ----\n", macro_runs);
  1172. if ((macro_runs % 20) == 0) {
  1173. printf(".");
  1174. fflush(stdout);
  1175. }
  1176. res = run_file_config(sizeof(cfgs)/sizeof(cfgs[0]), &cfgs[0], 11, 2, 0);
  1177. TEST_CHECK(res >= 0);
  1178. }
  1179. printf("\n");
  1180. res = read_and_verify("long_clobber");
  1181. TEST_CHECK(res >= 0);
  1182. res = SPIFFS_check(FS);
  1183. TEST_CHECK(res >= 0);
  1184. return TEST_RES_OK;
  1185. }
  1186. TEST_END(long_run)
  1187. SUITE_END(hydrogen_tests)