├── .gitignore ├── LICENSE ├── README.md ├── core ├── yaffs_allocator.c ├── yaffs_allocator.h ├── yaffs_attribs.c ├── yaffs_attribs.h ├── yaffs_bitmap.c ├── yaffs_bitmap.h ├── yaffs_cache.c ├── yaffs_cache.h ├── yaffs_checkptrw.c ├── yaffs_checkptrw.h ├── yaffs_ecc.c ├── yaffs_ecc.h ├── yaffs_endian.c ├── yaffs_endian.h ├── yaffs_getblockinfo.h ├── yaffs_guts.c ├── yaffs_guts.h ├── yaffs_nameval.c ├── yaffs_nameval.h ├── yaffs_nand.c ├── yaffs_nand.h ├── yaffs_packedtags1.c ├── yaffs_packedtags1.h ├── yaffs_packedtags2.c ├── yaffs_packedtags2.h ├── yaffs_summary.c ├── yaffs_summary.h ├── yaffs_tagscompat.c ├── yaffs_tagscompat.h ├── yaffs_tagsmarshall.c ├── yaffs_tagsmarshall.h ├── yaffs_trace.h ├── yaffs_verify.c ├── yaffs_verify.h ├── yaffs_yaffs1.c ├── yaffs_yaffs1.h ├── yaffs_yaffs2.c └── yaffs_yaffs2.h ├── direct ├── README.txt ├── handle_common.sh ├── optional_sort │ ├── README_qsort.txt │ └── qsort.c ├── test-framework │ ├── FrameworkRules.mk │ ├── basic-tests │ │ ├── Makefile │ │ ├── README.txt │ │ ├── dtest.c │ │ ├── reldevtest.c │ │ └── unlinkfilltest.c │ ├── nand_chip.h │ ├── nand_store.h │ ├── nanddrv.c │ ├── nanddrv.h │ ├── nandsim.c │ ├── nandsim.h │ ├── nandsim_file.c │ ├── nandsim_file.h │ ├── nandstore_file.c │ ├── nandstore_file.h │ ├── python │ │ ├── Makefile │ │ ├── README.txt │ │ ├── README_yaffs_browser_py.txt │ │ ├── README_yaffs_import_py.txt │ │ ├── examples.py │ │ ├── yaffs_browser.py │ │ ├── yaffs_importer.py │ │ ├── yaffs_python_helper.c │ │ └── yaffsfs.py │ ├── stress_tests │ │ ├── handle_tests │ │ │ ├── .gitignore │ │ │ ├── Makefile │ │ │ ├── README.txt │ │ │ ├── handle_test.c │ │ │ └── handle_test.h │ │ ├── stress_tester │ │ │ ├── .gitignore │ │ │ ├── Makefile │ │ │ ├── README.txt │ │ │ ├── error_handler.c │ │ │ ├── error_handler.h │ │ │ ├── message_buffer.c │ │ │ ├── message_buffer.h │ │ │ ├── shared.c │ │ │ ├── shared.h │ │ │ ├── yaffs_tester.c │ │ │ └── yaffs_tester.h │ │ └── threading │ │ │ ├── .gitignore │ │ │ ├── Makefile │ │ │ ├── README.txt │ │ │ ├── lib.c │ │ │ ├── lib.h │ │ │ ├── test_a.c │ │ │ ├── test_a.h │ │ │ ├── test_b.c │ │ │ ├── test_b.h │ │ │ ├── thread_function.c │ │ │ ├── thread_function.h │ │ │ ├── threading.c │ │ │ └── threading.h │ ├── tests │ │ ├── Makefile │ │ ├── README │ │ ├── fuzzer.c │ │ ├── init_fw_update_test_m18.sh │ │ ├── init_fw_update_test_nand.sh │ │ ├── init_fw_update_test_nor.sh │ │ ├── launch_tests.sh │ │ ├── manage_m18_test.sh │ │ ├── manage_nand_test.sh │ │ ├── manage_nor_test.sh │ │ ├── nor_stress.c │ │ ├── nor_stress.h │ │ ├── run_fuzz_test_nand.sh │ │ ├── run_fw_update_test_m18.sh │ │ ├── run_fw_update_test_nand.sh │ │ ├── run_fw_update_test_nor.sh │ │ ├── yaffs_fsx.c │ │ ├── yaffs_fsx.h │ │ └── yaffs_test.c │ ├── unit_tests │ │ ├── 64_and_32_bit_time │ │ │ ├── 32_bit │ │ │ │ ├── .gitignore │ │ │ │ ├── Makefile │ │ │ │ ├── create_32_bit.c │ │ │ │ ├── shared.c │ │ │ │ ├── shared.h │ │ │ │ ├── time_32_tests.c │ │ │ │ └── validate_32_bit.c │ │ │ ├── 64_bit │ │ │ │ ├── .gitignore │ │ │ │ ├── Makefile │ │ │ │ ├── create_64_bit.c │ │ │ │ ├── shared.c │ │ │ │ ├── shared.h │ │ │ │ ├── time_64_tests.c │ │ │ │ └── validate_64_bit.c │ │ │ ├── shared │ │ │ │ ├── create_file.c │ │ │ │ ├── shared.c │ │ │ │ ├── shared.h │ │ │ │ └── validate_file.c │ │ │ └── time_test_runner.sh │ │ ├── is_yaffs_working_tests │ │ │ ├── .gitignore │ │ │ ├── Makefile │ │ │ ├── README.txt │ │ │ └── test_1_yaffs_mount.c │ │ ├── quick_tests │ │ │ ├── .gitignore │ │ │ ├── Makefile │ │ │ ├── README.txt │ │ │ ├── lib.c │ │ │ ├── lib.h │ │ │ ├── quick_tests.c │ │ │ ├── quick_tests.h │ │ │ ├── test_yaffs_access.c │ │ │ ├── test_yaffs_access.h │ │ │ ├── test_yaffs_access_EACCES.c │ │ │ ├── test_yaffs_access_EACCES.h │ │ │ ├── test_yaffs_access_EINVAL.c │ │ │ ├── test_yaffs_access_EINVAL.h │ │ │ ├── test_yaffs_access_ELOOP.c │ │ │ ├── test_yaffs_access_ELOOP.h │ │ │ ├── test_yaffs_access_ELOOP_dir.c │ │ │ ├── test_yaffs_access_ELOOP_dir.h │ │ │ ├── test_yaffs_access_ENAMETOOLONG.c │ │ │ ├── test_yaffs_access_ENAMETOOLONG.h │ │ │ ├── test_yaffs_access_ENOENT.c │ │ │ ├── test_yaffs_access_ENOENT.h │ │ │ ├── test_yaffs_access_ENOENT2.c │ │ │ ├── test_yaffs_access_ENOENT2.h │ │ │ ├── test_yaffs_access_ENOTDIR.c │ │ │ ├── test_yaffs_access_ENOTDIR.h │ │ │ ├── test_yaffs_access_EROFS.c │ │ │ ├── test_yaffs_access_EROFS.h │ │ │ ├── test_yaffs_access_NULL.c │ │ │ ├── test_yaffs_access_NULL.h │ │ │ ├── test_yaffs_chmod.c │ │ │ ├── test_yaffs_chmod.h │ │ │ ├── test_yaffs_chmod_EINVAL.c │ │ │ ├── test_yaffs_chmod_EINVAL.h │ │ │ ├── test_yaffs_chmod_ELOOP.c │ │ │ ├── test_yaffs_chmod_ELOOP.h │ │ │ ├── test_yaffs_chmod_ELOOP_dir.c │ │ │ ├── test_yaffs_chmod_ELOOP_dir.h │ │ │ ├── test_yaffs_chmod_ENAMETOOLONG.c │ │ │ ├── test_yaffs_chmod_ENAMETOOLONG.h │ │ │ ├── test_yaffs_chmod_ENOENT.c │ │ │ ├── test_yaffs_chmod_ENOENT.h │ │ │ ├── test_yaffs_chmod_ENOENT2.c │ │ │ ├── test_yaffs_chmod_ENOENT2.h │ │ │ ├── test_yaffs_chmod_ENOTDIR.c │ │ │ ├── test_yaffs_chmod_ENOTDIR.h │ │ │ ├── test_yaffs_chmod_EROFS.c │ │ │ ├── test_yaffs_chmod_EROFS.h │ │ │ ├── test_yaffs_chmod_NULL.c │ │ │ ├── test_yaffs_chmod_NULL.h │ │ │ ├── test_yaffs_close.c │ │ │ ├── test_yaffs_close.h │ │ │ ├── test_yaffs_close_EBADF.c │ │ │ ├── test_yaffs_close_EBADF.h │ │ │ ├── test_yaffs_close_NULL.c │ │ │ ├── test_yaffs_close_NULL.h │ │ │ ├── test_yaffs_dup.c │ │ │ ├── test_yaffs_dup.h │ │ │ ├── test_yaffs_dup_EBADF.c │ │ │ ├── test_yaffs_dup_EBADF.h │ │ │ ├── test_yaffs_fchmod.c │ │ │ ├── test_yaffs_fchmod.h │ │ │ ├── test_yaffs_fchmod_EBADF.c │ │ │ ├── test_yaffs_fchmod_EBADF.h │ │ │ ├── test_yaffs_fchmod_EINVAL.c │ │ │ ├── test_yaffs_fchmod_EINVAL.h │ │ │ ├── test_yaffs_fchmod_EROFS.c │ │ │ ├── test_yaffs_fchmod_EROFS.h │ │ │ ├── test_yaffs_fchmod_NULL.c │ │ │ ├── test_yaffs_fchmod_NULL.h │ │ │ ├── test_yaffs_fdatasync.c │ │ │ ├── test_yaffs_fdatasync.h │ │ │ ├── test_yaffs_fdatasync_EBADF.c │ │ │ ├── test_yaffs_fdatasync_EBADF.h │ │ │ ├── test_yaffs_fdatasync_EROFS.c │ │ │ ├── test_yaffs_fdatasync_EROFS.h │ │ │ ├── test_yaffs_fdatasync_NULL.c │ │ │ ├── test_yaffs_fdatasync_NULL.h │ │ │ ├── test_yaffs_flush.c │ │ │ ├── test_yaffs_flush.h │ │ │ ├── test_yaffs_flush_EBADF.c │ │ │ ├── test_yaffs_flush_EBADF.h │ │ │ ├── test_yaffs_flush_EROFS.c │ │ │ ├── test_yaffs_flush_EROFS.h │ │ │ ├── test_yaffs_freespace.c │ │ │ ├── test_yaffs_freespace.h │ │ │ ├── test_yaffs_freespace_EINVAL.c │ │ │ ├── test_yaffs_freespace_EINVAL.h │ │ │ ├── test_yaffs_freespace_ENAMETOOLONG.c │ │ │ ├── test_yaffs_freespace_ENAMETOOLONG.h │ │ │ ├── test_yaffs_freespace_NULL.c │ │ │ ├── test_yaffs_freespace_NULL.h │ │ │ ├── test_yaffs_fstat.c │ │ │ ├── test_yaffs_fstat.h │ │ │ ├── test_yaffs_fstat_EBADF.c │ │ │ ├── test_yaffs_fstat_EBADF.h │ │ │ ├── test_yaffs_fsync.c │ │ │ ├── test_yaffs_fsync.h │ │ │ ├── test_yaffs_fsync_EBADF.c │ │ │ ├── test_yaffs_fsync_EBADF.h │ │ │ ├── test_yaffs_fsync_EROFS.c │ │ │ ├── test_yaffs_fsync_EROFS.h │ │ │ ├── test_yaffs_ftruncate.c │ │ │ ├── test_yaffs_ftruncate.h │ │ │ ├── test_yaffs_ftruncate_EBADF.c │ │ │ ├── test_yaffs_ftruncate_EBADF.h │ │ │ ├── test_yaffs_ftruncate_EINVAL.c │ │ │ ├── test_yaffs_ftruncate_EINVAL.h │ │ │ ├── test_yaffs_ftruncate_EROFS.c │ │ │ ├── test_yaffs_ftruncate_EROFS.h │ │ │ ├── test_yaffs_ftruncate_big_file.c │ │ │ ├── test_yaffs_ftruncate_big_file.h │ │ │ ├── test_yaffs_inodecount.c │ │ │ ├── test_yaffs_inodecount.h │ │ │ ├── test_yaffs_inodecount_EINVAL.c │ │ │ ├── test_yaffs_inodecount_EINVAL.h │ │ │ ├── test_yaffs_inodecount_ENAMETOOLONG.c │ │ │ ├── test_yaffs_inodecount_ENAMETOOLONG.h │ │ │ ├── test_yaffs_inodecount_NULL.c │ │ │ ├── test_yaffs_inodecount_NULL.h │ │ │ ├── test_yaffs_link.c │ │ │ ├── test_yaffs_link.h │ │ │ ├── test_yaffs_link_EEXIST.c │ │ │ ├── test_yaffs_link_EEXIST.h │ │ │ ├── test_yaffs_link_ELOOP_dir.c │ │ │ ├── test_yaffs_link_ELOOP_dir.h │ │ │ ├── test_yaffs_link_ENAMETOOLONG.c │ │ │ ├── test_yaffs_link_ENAMETOOLONG.h │ │ │ ├── test_yaffs_link_ENAMETOOLONG2.c │ │ │ ├── test_yaffs_link_ENAMETOOLONG2.h │ │ │ ├── test_yaffs_link_ENOENT.c │ │ │ ├── test_yaffs_link_ENOENT.h │ │ │ ├── test_yaffs_link_ENOENT2.c │ │ │ ├── test_yaffs_link_ENOENT2.h │ │ │ ├── test_yaffs_link_ENOENT3.c │ │ │ ├── test_yaffs_link_ENOENT3.h │ │ │ ├── test_yaffs_link_ENOENT4.c │ │ │ ├── test_yaffs_link_ENOENT4.h │ │ │ ├── test_yaffs_link_ENOTDIR.c │ │ │ ├── test_yaffs_link_ENOTDIR.h │ │ │ ├── test_yaffs_link_ENOTDIR2.c │ │ │ ├── test_yaffs_link_ENOTDIR2.h │ │ │ ├── test_yaffs_link_EROFS.c │ │ │ ├── test_yaffs_link_EROFS.h │ │ │ ├── test_yaffs_link_NULL.c │ │ │ ├── test_yaffs_link_NULL.h │ │ │ ├── test_yaffs_link_NULL2.c │ │ │ ├── test_yaffs_link_NULL2.h │ │ │ ├── test_yaffs_lseek.c │ │ │ ├── test_yaffs_lseek.h │ │ │ ├── test_yaffs_lseek_EBADF.c │ │ │ ├── test_yaffs_lseek_EBADF.h │ │ │ ├── test_yaffs_lseek_EINVAL.c │ │ │ ├── test_yaffs_lseek_EINVAL.h │ │ │ ├── test_yaffs_lseek_EROFS.c │ │ │ ├── test_yaffs_lseek_EROFS.h │ │ │ ├── test_yaffs_lseek_big_file.c │ │ │ ├── test_yaffs_lseek_big_file.h │ │ │ ├── test_yaffs_lstat.c │ │ │ ├── test_yaffs_lstat.h │ │ │ ├── test_yaffs_lstat_ENAMETOOLONG.c │ │ │ ├── test_yaffs_lstat_ENAMETOOLONG.h │ │ │ ├── test_yaffs_lstat_ENOENT.c │ │ │ ├── test_yaffs_lstat_ENOENT.h │ │ │ ├── test_yaffs_lstat_ENOTDIR.c │ │ │ ├── test_yaffs_lstat_ENOTDIR.h │ │ │ ├── test_yaffs_lstat_NULL.c │ │ │ ├── test_yaffs_lstat_NULL.h │ │ │ ├── test_yaffs_mkdir.c │ │ │ ├── test_yaffs_mkdir.h │ │ │ ├── test_yaffs_mkdir_EEXIST.c │ │ │ ├── test_yaffs_mkdir_EEXIST.h │ │ │ ├── test_yaffs_mkdir_ELOOP_dir.c │ │ │ ├── test_yaffs_mkdir_ELOOP_dir.h │ │ │ ├── test_yaffs_mkdir_ENAMETOOLONG.c │ │ │ ├── test_yaffs_mkdir_ENAMETOOLONG.h │ │ │ ├── test_yaffs_mkdir_ENOENT.c │ │ │ ├── test_yaffs_mkdir_ENOENT.h │ │ │ ├── test_yaffs_mkdir_ENOTDIR.c │ │ │ ├── test_yaffs_mkdir_ENOTDIR.h │ │ │ ├── test_yaffs_mkdir_EROFS.c │ │ │ ├── test_yaffs_mkdir_EROFS.h │ │ │ ├── test_yaffs_mkdir_NULL.c │ │ │ ├── test_yaffs_mkdir_NULL.h │ │ │ ├── test_yaffs_mount.c │ │ │ ├── test_yaffs_mount.h │ │ │ ├── test_yaffs_mount2.c │ │ │ ├── test_yaffs_mount2.h │ │ │ ├── test_yaffs_mount2_ENODEV.c │ │ │ ├── test_yaffs_mount2_ENODEV.h │ │ │ ├── test_yaffs_mount_EBUSY.c │ │ │ ├── test_yaffs_mount_EBUSY.h │ │ │ ├── test_yaffs_mount_ENAMETOOLONG.c │ │ │ ├── test_yaffs_mount_ENAMETOOLONG.h │ │ │ ├── test_yaffs_mount_ENODEV.c │ │ │ ├── test_yaffs_mount_ENODEV.h │ │ │ ├── test_yaffs_mount_NULL.c │ │ │ ├── test_yaffs_mount_NULL.h │ │ │ ├── test_yaffs_open.c │ │ │ ├── test_yaffs_open.h │ │ │ ├── test_yaffs_open_EACCES.c │ │ │ ├── test_yaffs_open_EACCES.h │ │ │ ├── test_yaffs_open_EEXIST.c │ │ │ ├── test_yaffs_open_EEXIST.h │ │ │ ├── test_yaffs_open_EINVAL.c │ │ │ ├── test_yaffs_open_EINVAL.h │ │ │ ├── test_yaffs_open_EINVAL2.c │ │ │ ├── test_yaffs_open_EINVAL2.h │ │ │ ├── test_yaffs_open_ELOOP.c │ │ │ ├── test_yaffs_open_ELOOP.h │ │ │ ├── test_yaffs_open_ELOOP_dir.c │ │ │ ├── test_yaffs_open_ELOOP_dir.h │ │ │ ├── test_yaffs_open_ENAMETOOLONG.c │ │ │ ├── test_yaffs_open_ENAMETOOLONG.h │ │ │ ├── test_yaffs_open_ENOENT.c │ │ │ ├── test_yaffs_open_ENOENT.h │ │ │ ├── test_yaffs_open_ENOTDIR.c │ │ │ ├── test_yaffs_open_ENOTDIR.h │ │ │ ├── test_yaffs_open_EROFS.c │ │ │ ├── test_yaffs_open_EROFS.h │ │ │ ├── test_yaffs_open_NULL.c │ │ │ ├── test_yaffs_open_NULL.h │ │ │ ├── test_yaffs_read.c │ │ │ ├── test_yaffs_read.h │ │ │ ├── test_yaffs_read_EBADF.c │ │ │ ├── test_yaffs_read_EBADF.h │ │ │ ├── test_yaffs_read_EINVAL.c │ │ │ ├── test_yaffs_read_EINVAL.h │ │ │ ├── test_yaffs_remount_EINVAL.c │ │ │ ├── test_yaffs_remount_EINVAL.h │ │ │ ├── test_yaffs_remount_ENAMETOOLONG.c │ │ │ ├── test_yaffs_remount_ENAMETOOLONG.h │ │ │ ├── test_yaffs_remount_ENODEV.c │ │ │ ├── test_yaffs_remount_ENODEV.h │ │ │ ├── test_yaffs_remount_NULL.c │ │ │ ├── test_yaffs_remount_NULL.h │ │ │ ├── test_yaffs_remount_force_off_read_only_off.c │ │ │ ├── test_yaffs_remount_force_off_read_only_off.h │ │ │ ├── test_yaffs_remount_force_off_read_only_on.c │ │ │ ├── test_yaffs_remount_force_off_read_only_on.h │ │ │ ├── test_yaffs_remount_force_on_read_only_off.c │ │ │ ├── test_yaffs_remount_force_on_read_only_off.h │ │ │ ├── test_yaffs_remount_force_on_read_only_on.c │ │ │ ├── test_yaffs_remount_force_on_read_only_on.h │ │ │ ├── test_yaffs_rename.c │ │ │ ├── test_yaffs_rename.h │ │ │ ├── test_yaffs_rename_EEXISTS.c │ │ │ ├── test_yaffs_rename_EEXISTS.h │ │ │ ├── test_yaffs_rename_EINVAL.c │ │ │ ├── test_yaffs_rename_EINVAL.h │ │ │ ├── test_yaffs_rename_ELOOP_dir.c │ │ │ ├── test_yaffs_rename_ELOOP_dir.h │ │ │ ├── test_yaffs_rename_ENAMETOOLONG.c │ │ │ ├── test_yaffs_rename_ENAMETOOLONG.h │ │ │ ├── test_yaffs_rename_ENAMETOOLONG2.c │ │ │ ├── test_yaffs_rename_ENAMETOOLONG2.h │ │ │ ├── test_yaffs_rename_ENOENT.c │ │ │ ├── test_yaffs_rename_ENOENT.h │ │ │ ├── test_yaffs_rename_ENOTDIR.c │ │ │ ├── test_yaffs_rename_ENOTDIR.h │ │ │ ├── test_yaffs_rename_ENOTEMPTY.c │ │ │ ├── test_yaffs_rename_ENOTEMPTY.h │ │ │ ├── test_yaffs_rename_EROFS.c │ │ │ ├── test_yaffs_rename_EROFS.h │ │ │ ├── test_yaffs_rename_NULL.c │ │ │ ├── test_yaffs_rename_NULL.h │ │ │ ├── test_yaffs_rename_NULL2.c │ │ │ ├── test_yaffs_rename_NULL2.h │ │ │ ├── test_yaffs_rename_dir.c │ │ │ ├── test_yaffs_rename_dir.h │ │ │ ├── test_yaffs_rename_dir_ENOENT.c │ │ │ ├── test_yaffs_rename_dir_ENOENT.h │ │ │ ├── test_yaffs_rename_dir_ENOENT2.c │ │ │ ├── test_yaffs_rename_dir_ENOENT2.h │ │ │ ├── test_yaffs_rename_dir_not_empty.c │ │ │ ├── test_yaffs_rename_dir_not_empty.h │ │ │ ├── test_yaffs_rename_dir_over_dir.c │ │ │ ├── test_yaffs_rename_dir_over_dir.h │ │ │ ├── test_yaffs_rename_dir_to_file.c │ │ │ ├── test_yaffs_rename_dir_to_file.h │ │ │ ├── test_yaffs_rename_file_over_file.c │ │ │ ├── test_yaffs_rename_file_over_file.h │ │ │ ├── test_yaffs_rename_file_to_dir.c │ │ │ ├── test_yaffs_rename_file_to_dir.h │ │ │ ├── test_yaffs_rename_full_dir_over_dir.c │ │ │ ├── test_yaffs_rename_full_dir_over_dir.h │ │ │ ├── test_yaffs_rename_to_null_file.c │ │ │ ├── test_yaffs_rename_to_null_file.h │ │ │ ├── test_yaffs_rmdir.c │ │ │ ├── test_yaffs_rmdir.h │ │ │ ├── test_yaffs_rmdir_EBUSY.c │ │ │ ├── test_yaffs_rmdir_EBUSY.h │ │ │ ├── test_yaffs_rmdir_EINVAL.c │ │ │ ├── test_yaffs_rmdir_EINVAL.h │ │ │ ├── test_yaffs_rmdir_ELOOP_dir.c │ │ │ ├── test_yaffs_rmdir_ELOOP_dir.h │ │ │ ├── test_yaffs_rmdir_ENAMETOOLONG.c │ │ │ ├── test_yaffs_rmdir_ENAMETOOLONG.h │ │ │ ├── test_yaffs_rmdir_ENOENT.c │ │ │ ├── test_yaffs_rmdir_ENOENT.h │ │ │ ├── test_yaffs_rmdir_ENOTDIR.c │ │ │ ├── test_yaffs_rmdir_ENOTDIR.h │ │ │ ├── test_yaffs_rmdir_ENOTEMPTY.c │ │ │ ├── test_yaffs_rmdir_ENOTEMPTY.h │ │ │ ├── test_yaffs_rmdir_EROFS.c │ │ │ ├── test_yaffs_rmdir_EROFS.h │ │ │ ├── test_yaffs_rmdir_NULL.c │ │ │ ├── test_yaffs_rmdir_NULL.h │ │ │ ├── test_yaffs_stat.c │ │ │ ├── test_yaffs_stat.h │ │ │ ├── test_yaffs_stat_ELOOP.c │ │ │ ├── test_yaffs_stat_ELOOP.h │ │ │ ├── test_yaffs_stat_ELOOP_dir.c │ │ │ ├── test_yaffs_stat_ELOOP_dir.h │ │ │ ├── test_yaffs_stat_ENAMETOOLONG.c │ │ │ ├── test_yaffs_stat_ENAMETOOLONG.h │ │ │ ├── test_yaffs_stat_ENOENT.c │ │ │ ├── test_yaffs_stat_ENOENT.h │ │ │ ├── test_yaffs_stat_ENOENT2.c │ │ │ ├── test_yaffs_stat_ENOENT2.h │ │ │ ├── test_yaffs_stat_ENOTDIR.c │ │ │ ├── test_yaffs_stat_ENOTDIR.h │ │ │ ├── test_yaffs_stat_NULL.c │ │ │ ├── test_yaffs_stat_NULL.h │ │ │ ├── test_yaffs_symlink.c │ │ │ ├── test_yaffs_symlink.h │ │ │ ├── test_yaffs_symlink_EEXIST.c │ │ │ ├── test_yaffs_symlink_EEXIST.h │ │ │ ├── test_yaffs_symlink_ELOOP_dir.c │ │ │ ├── test_yaffs_symlink_ELOOP_dir.h │ │ │ ├── test_yaffs_symlink_ENAMETOOLONG.c │ │ │ ├── test_yaffs_symlink_ENAMETOOLONG.h │ │ │ ├── test_yaffs_symlink_ENOENT.c │ │ │ ├── test_yaffs_symlink_ENOENT.h │ │ │ ├── test_yaffs_symlink_ENOENT2.c │ │ │ ├── test_yaffs_symlink_ENOENT2.h │ │ │ ├── test_yaffs_symlink_ENOTDIR.c │ │ │ ├── test_yaffs_symlink_ENOTDIR.h │ │ │ ├── test_yaffs_symlink_EROFS.c │ │ │ ├── test_yaffs_symlink_EROFS.h │ │ │ ├── test_yaffs_symlink_NULL.c │ │ │ ├── test_yaffs_symlink_NULL.h │ │ │ ├── test_yaffs_symlink_NULL2.c │ │ │ ├── test_yaffs_symlink_NULL2.h │ │ │ ├── test_yaffs_sync.c │ │ │ ├── test_yaffs_sync.h │ │ │ ├── test_yaffs_sync_ENAMETOOLONG.c │ │ │ ├── test_yaffs_sync_ENAMETOOLONG.h │ │ │ ├── test_yaffs_sync_ENODEV.c │ │ │ ├── test_yaffs_sync_ENODEV.h │ │ │ ├── test_yaffs_sync_EROFS.c │ │ │ ├── test_yaffs_sync_EROFS.h │ │ │ ├── test_yaffs_sync_NULL.c │ │ │ ├── test_yaffs_sync_NULL.h │ │ │ ├── test_yaffs_totalspace.c │ │ │ ├── test_yaffs_totalspace.h │ │ │ ├── test_yaffs_totalspace_EINVAL.c │ │ │ ├── test_yaffs_totalspace_EINVAL.h │ │ │ ├── test_yaffs_totalspace_ENAMETOOLONG.c │ │ │ ├── test_yaffs_totalspace_ENAMETOOLONG.h │ │ │ ├── test_yaffs_totalspace_NULL.c │ │ │ ├── test_yaffs_totalspace_NULL.h │ │ │ ├── test_yaffs_truncate.c │ │ │ ├── test_yaffs_truncate.h │ │ │ ├── test_yaffs_truncate_EINVAL.c │ │ │ ├── test_yaffs_truncate_EINVAL.h │ │ │ ├── test_yaffs_truncate_EISDIR.c │ │ │ ├── test_yaffs_truncate_EISDIR.h │ │ │ ├── test_yaffs_truncate_ELOOP.c │ │ │ ├── test_yaffs_truncate_ELOOP.h │ │ │ ├── test_yaffs_truncate_ELOOP_dir.c │ │ │ ├── test_yaffs_truncate_ELOOP_dir.h │ │ │ ├── test_yaffs_truncate_ENAMETOOLONG.c │ │ │ ├── test_yaffs_truncate_ENAMETOOLONG.h │ │ │ ├── test_yaffs_truncate_ENOENT.c │ │ │ ├── test_yaffs_truncate_ENOENT.h │ │ │ ├── test_yaffs_truncate_ENOENT2.c │ │ │ ├── test_yaffs_truncate_ENOENT2.h │ │ │ ├── test_yaffs_truncate_ENOTDIR.c │ │ │ ├── test_yaffs_truncate_ENOTDIR.h │ │ │ ├── test_yaffs_truncate_EROFS.c │ │ │ ├── test_yaffs_truncate_EROFS.h │ │ │ ├── test_yaffs_truncate_NULL.c │ │ │ ├── test_yaffs_truncate_NULL.h │ │ │ ├── test_yaffs_truncate_big_file.c │ │ │ ├── test_yaffs_truncate_big_file.h │ │ │ ├── test_yaffs_unlink.c │ │ │ ├── test_yaffs_unlink.h │ │ │ ├── test_yaffs_unlink_EISDIR.c │ │ │ ├── test_yaffs_unlink_EISDIR.h │ │ │ ├── test_yaffs_unlink_ELOOP_dir.c │ │ │ ├── test_yaffs_unlink_ELOOP_dir.h │ │ │ ├── test_yaffs_unlink_ENAMETOOLONG.c │ │ │ ├── test_yaffs_unlink_ENAMETOOLONG.h │ │ │ ├── test_yaffs_unlink_ENOENT.c │ │ │ ├── test_yaffs_unlink_ENOENT.h │ │ │ ├── test_yaffs_unlink_ENOENT2.c │ │ │ ├── test_yaffs_unlink_ENOENT2.h │ │ │ ├── test_yaffs_unlink_ENOTDIR.c │ │ │ ├── test_yaffs_unlink_ENOTDIR.h │ │ │ ├── test_yaffs_unlink_EROFS.c │ │ │ ├── test_yaffs_unlink_EROFS.h │ │ │ ├── test_yaffs_unlink_NULL.c │ │ │ ├── test_yaffs_unlink_NULL.h │ │ │ ├── test_yaffs_unmount.c │ │ │ ├── test_yaffs_unmount.h │ │ │ ├── test_yaffs_unmount2.c │ │ │ ├── test_yaffs_unmount2.h │ │ │ ├── test_yaffs_unmount2_EINVAL.c │ │ │ ├── test_yaffs_unmount2_EINVAL.h │ │ │ ├── test_yaffs_unmount2_ENODEV.c │ │ │ ├── test_yaffs_unmount2_ENODEV.h │ │ │ ├── test_yaffs_unmount2_with_handle_open_and_forced_mode_off.c │ │ │ ├── test_yaffs_unmount2_with_handle_open_and_forced_mode_off.h │ │ │ ├── test_yaffs_unmount2_with_handle_open_and_forced_mode_on.c │ │ │ ├── test_yaffs_unmount2_with_handle_open_and_forced_mode_on.h │ │ │ ├── test_yaffs_unmount_EBUSY.c │ │ │ ├── test_yaffs_unmount_EBUSY.h │ │ │ ├── test_yaffs_unmount_ENAMETOOLONG.c │ │ │ ├── test_yaffs_unmount_ENAMETOOLONG.h │ │ │ ├── test_yaffs_unmount_ENODEV.c │ │ │ ├── test_yaffs_unmount_ENODEV.h │ │ │ ├── test_yaffs_unmount_NULL.c │ │ │ ├── test_yaffs_unmount_NULL.h │ │ │ ├── test_yaffs_write.c │ │ │ ├── test_yaffs_write.h │ │ │ ├── test_yaffs_write_EBADF.c │ │ │ ├── test_yaffs_write_EBADF.h │ │ │ ├── test_yaffs_write_EROFS.c │ │ │ ├── test_yaffs_write_EROFS.h │ │ │ ├── test_yaffs_write_big_file.c │ │ │ └── test_yaffs_write_big_file.h │ │ └── test_runner.py │ ├── yaffs2_image_maker │ │ ├── Makefile │ │ ├── README.md │ │ ├── yaffs2_dumper.c │ │ └── yaffs2_image_maker.c │ ├── yaffs_fileem.c │ ├── yaffs_fileem2k.c │ ├── yaffs_fileem2k.h │ ├── yaffs_flexible_file_sim.c │ ├── yaffs_flexible_file_sim.h │ ├── yaffs_m18_drv.c │ ├── yaffs_m18_drv.h │ ├── yaffs_nand_drv.c │ ├── yaffs_nand_drv.h │ ├── yaffs_nandsim_file.c │ ├── yaffs_nandsim_file.h │ ├── yaffs_nor_drv.c │ ├── yaffs_nor_drv.h │ ├── yaffs_osglue.c │ ├── yaffs_ramdisk.c │ ├── yaffs_ramdisk.h │ ├── yaffs_ramem2k.c │ ├── yaffscfg2k.c │ ├── yaffsnewcfg.c │ ├── ynorsim.c │ ├── ynorsim.h │ ├── yramsim.c │ └── yramsim.h ├── u-boot │ ├── common │ │ └── cmd_yaffs2.c │ ├── fs │ │ └── yaffs2 │ │ │ ├── Makefile │ │ │ ├── stdio.h │ │ │ ├── stdlib.h │ │ │ ├── string.h │ │ │ ├── yaffs_mtdif.c │ │ │ ├── yaffs_mtdif.h │ │ │ ├── yaffs_mtdif2.c │ │ │ ├── yaffs_mtdif2.h │ │ │ ├── yaffs_uboot_glue.c │ │ │ └── yaffs_uboot_glue.h │ └── patch-u-boot.sh ├── yaffs_attribs.c ├── yaffs_error.c ├── yaffs_flashif.h ├── yaffs_flashif2.h ├── yaffs_hweight.c ├── yaffs_hweight.h ├── yaffs_list.h ├── yaffs_nandemul2k.h ├── yaffs_osglue.h ├── yaffscfg.h ├── yaffsfs.c ├── yaffsfs.h ├── ydirectenv.h └── yportenv.h ├── linux ├── Kconfig_multi ├── Kconfig_single ├── Makefile ├── Makefile.kernel ├── README-linux ├── README-linux-patch ├── linux-tests │ ├── Makefile │ ├── initnandsim │ ├── mkdirtree │ ├── mkfiles │ ├── mount_cycling.sh │ ├── plot_data.sh │ ├── stress_test.sh │ ├── verifybigsparse.c │ ├── write_test.sh │ ├── writebigsparse.c │ └── xattrtest.c ├── moduleconfig.h ├── mtdemul │ ├── Makefile │ └── nandemul2k.c ├── patch-ker.sh ├── patches │ ├── README.txt │ ├── yaffs_linux_allocator.c │ └── yaffs_mtdif2.c ├── yaffs_linux.h ├── yaffs_mtdif.h ├── yaffs_mtdif_multi.c ├── yaffs_mtdif_single.c ├── yaffs_vfs_multi.c ├── yaffs_vfs_single.c ├── yportenv.h ├── yportenv_multi.h └── yportenv_single.h ├── rtems ├── Makefile.rtems ├── RTEMS_NOTES ├── rtems-y-test │ ├── basic-test │ │ ├── Makefile │ │ ├── README │ │ └── yaffs-rtems-basic-test.c │ ├── common │ │ ├── yaffs-rtems-flashsim.c │ │ ├── yaffs-rtems-flashsim.h │ │ └── yaffs-rtems-test-wrapper.c │ └── fsx │ │ ├── Makefile │ │ ├── README │ │ └── rtems-fsx.c ├── rtems_yaffs.c ├── rtems_yaffs.h ├── rtems_yaffs_os_context.c └── rtems_yaffs_os_glue.c └── utils ├── Makefile ├── mkyaffs2image.c ├── mkyaffsimage.c └── yutilsenv.h /core/yaffs_tagsmarshall.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __YAFFS_TAGSMARSHALL_H__ 16 | #define __YAFFS_TAGSMARSHALL_H__ 17 | 18 | #include "yaffs_guts.h" 19 | void yaffs_tags_marshall_install(struct yaffs_dev *dev); 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /core/yaffs_yaffs1.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __YAFFS_YAFFS1_H__ 16 | #define __YAFFS_YAFFS1_H__ 17 | 18 | #include "yaffs_guts.h" 19 | int yaffs1_scan(struct yaffs_dev *dev); 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/README.txt: -------------------------------------------------------------------------------- 1 | New Handling for Yaffs Core Code in Yaffs Direct 2 | 3 | In the past, the Yaffs core code was joined into the Yaffs direct code by 4 | means of symbolic links. This had to be changed when some Linux 5 | kernel-friendly changes were made. 6 | 7 | Now, the Yaffs core code needs to be slightly modified before use in Yaffs 8 | Direct. This is accomplished by a script that copies the code intto the 9 | Yaffs Direct "workspace" while using sed to modify some of the function 10 | names etc. For example, strlen() is changed to yaffs_strlen() to allow these 11 | functions to be twaeked for use with unicode. 12 | 13 | This is accomplished by the script called handle_common.sh. 14 | 15 | cd yaffs2/direct 16 | ./handle_common.sh copy 17 | 18 | -------------------------------------------------------------------------------- /direct/optional_sort/README_qsort.txt: -------------------------------------------------------------------------------- 1 | Optional QSort 2 | ~~~~~~~~~~~~~~ 3 | 4 | Yaffs needs a sort function for sorting block indices during scanning. 5 | 6 | Most systems already have qsort (or an equivalent that can be used) 7 | as part of the standard library and generally it is best to use that. 8 | 9 | For those systems that do not have this, we supply the qsort in this 10 | directory. 11 | 12 | This qsort.c file is the only code that is supplied as part of the 13 | Yaffs Direct code that is NOT written, from the ground up, by Aleph One. 14 | 15 | The licensing terms are fairly innocuous. Please read the banner at the top 16 | of qsort.c 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /direct/test-framework/basic-tests/README.txt: -------------------------------------------------------------------------------- 1 | basic-tests README 2 | 3 | This test is where we write a tests to 4 | reproduce errors that are hard to recreate. 5 | 6 | These errors frequently require yaffs to be put 7 | into abnormal states, which will not work well in 8 | normal test rig. 9 | 10 | The solutions are manually verified here. 11 | 12 | This is not designed to be run by you as a test rig. 13 | It is just here for us to use for debugging purposes. 14 | -------------------------------------------------------------------------------- /direct/test-framework/nandsim.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __NAND_SIM_H__ 16 | #define __NAND_SIM_H__ 17 | #include "nand_store.h" 18 | #include "nand_chip.h" 19 | struct nand_chip *nandsim_init(struct nand_store *store, int bus_width_shift); 20 | void nandsim_set_debug(int d); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/nandsim_file.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __NAND_SIM_FILE_H__ 16 | #define __NAND_SIM_FILE_H__ 17 | #include "nand_chip.h" 18 | struct nand_chip *nandsim_file_init(const char *fname, 19 | int blocks, 20 | int pages_per_block, 21 | int data_bytes_per_page, 22 | int spare_bytes_per_page, 23 | int bus_width_shift); 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/nandstore_file.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __NAND_STORE_FILE_H__ 16 | #define __NAND_STORE_FILE_H__ 17 | 18 | #include "nand_store.h" 19 | 20 | struct nand_store * 21 | nandstore_file_init(const char *fname, 22 | int blocks, 23 | int pages_per_block, 24 | int data_bytes_per_page, 25 | int spare_bytes_per_page); 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/handle_tests/.gitignore: -------------------------------------------------------------------------------- 1 | handle_test 2 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/handle_tests/README.txt: -------------------------------------------------------------------------------- 1 | handle_tests.c opens and closes random handles, in an effot to stress test yaffs. 2 | 3 | Command line options: 4 | No commands. 5 | 6 | compile command: make 7 | run command: ./handle_test 8 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/stress_tester/.gitignore: -------------------------------------------------------------------------------- 1 | yaffs_tester 2 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/stress_tester/README.txt: -------------------------------------------------------------------------------- 1 | The stress_tester program opens and closes files at random in an effort to break yaffs. 2 | 3 | compile command: make 4 | run command: ./yaffs_tester 5 | 6 | command line options: 7 | -seed [number] sets the random seed generator to the number. 8 | 9 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/stress_tester/shared.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | /* 14 | * error_handler.c contains code for checking yaffs function calls for errors. 15 | */ 16 | #include "shared.h" 17 | #include "yaffsfs.h" 18 | 19 | void quit_program(){ 20 | yaffs_unmount(YAFFS_MOUNT_DIR); 21 | exit(1); 22 | } 23 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/stress_tester/shared.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __shared_h__ 16 | #define __shared_h__ 17 | 18 | #define YAFFS_TEST_DIR "/yflash2/test_dir" /*the path to the directory where all of the testing will take place*/ 19 | #define YAFFS_MOUNT_DIR "/yflash2/" /*the path to the mount point which yaffs will mount*/ 20 | 21 | void quit_program(); 22 | #endif 23 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/threading/.gitignore: -------------------------------------------------------------------------------- 1 | threading 2 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/threading/README.txt: -------------------------------------------------------------------------------- 1 | Created by Timothy Manning on 7/01/11 2 | 3 | This test is designed to test the locking ability of yaffs functions. 4 | 5 | compile command: make 6 | run command: ./threading 7 | 8 | 9 | command line arguments are: 10 | -h displays the help contents 11 | -t sets the number of threads 12 | 13 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/threading/test_a.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_a_h__ 16 | #define __test_a_h__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | void test_a(void *x); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/threading/test_b.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_b_h__ 16 | #define __test_b_h__ 17 | #include "yaffsfs.h" 18 | #include "lib.h" 19 | void test_b(void *x); 20 | #endif 21 | -------------------------------------------------------------------------------- /direct/test-framework/stress_tests/threading/threading.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __threading_h__ 16 | #define __threading_h__ 17 | #include 18 | #include 19 | #include 20 | #include "thread_function.h" 21 | #include "lib.h" 22 | #include 23 | #endif 24 | -------------------------------------------------------------------------------- /direct/test-framework/tests/init_fw_update_test_m18.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Run this to initialise the file system for the test runs. 3 | set -x 4 | rm seed-m18-* 5 | rm emfile-m18* 6 | ./yaffs_test -u -i M18-1 7 | -------------------------------------------------------------------------------- /direct/test-framework/tests/init_fw_update_test_nand.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Run this to initialise the file system for the test runs. 3 | rm seed-nand-* 4 | rm emfile-nand-* 5 | ./yaffs_test -u -i nand 6 | 7 | 8 | -------------------------------------------------------------------------------- /direct/test-framework/tests/init_fw_update_test_nor.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Run this to initialise the file system for the test runs. 3 | rm seed-nor-* 4 | rm emfile-nor* 5 | ./yaffs_test -u -i nor 6 | -------------------------------------------------------------------------------- /direct/test-framework/tests/manage_m18_test.sh: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | dir_id=-none 4 | [ -z $1 ] || dir_id=$1 5 | 6 | 7 | iterations=100000 8 | 9 | [ -z $2 ] || iterations=$2 10 | 11 | STARTDIR=`pwd` 12 | RUNDIR=`pwd`/tmp/m18-$dir_id 13 | mkdir $RUNDIR 14 | cd $RUNDIR 15 | cp $STARTDIR/*sh . 16 | ln -s $STARTDIR/yaffs_test yaffs_test 17 | 18 | ./init_fw_update_test_m18.sh 19 | ./run_fw_update_test_m18.sh $iterations 20 | 21 | echo "!!!!!!!!!!!" 22 | echo "Tests done" 23 | while true 24 | do 25 | sleep 10000 26 | done 27 | -------------------------------------------------------------------------------- /direct/test-framework/tests/manage_nand_test.sh: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | dir_id=-none 4 | [ -z $1 ] || dir_id=$1 5 | 6 | iterations=100000 7 | 8 | [ -z $2 ] || iterations=$2 9 | 10 | STARTDIR=`pwd` 11 | RUNDIR=`pwd`/tmp/nand-$dir_id 12 | mkdir $RUNDIR 13 | cd $RUNDIR 14 | cp $STARTDIR/*sh . 15 | ln -s $STARTDIR/yaffs_test yaffs_test 16 | 17 | ./init_fw_update_test_nand.sh 18 | ./run_fw_update_test_nand.sh $iterations 19 | 20 | 21 | echo "!!!!!!!!!!!" 22 | echo "Tests done" 23 | while true 24 | do 25 | sleep 10000 26 | done 27 | -------------------------------------------------------------------------------- /direct/test-framework/tests/manage_nor_test.sh: -------------------------------------------------------------------------------- 1 | #! /bin/sh 2 | 3 | dir_id=-none 4 | [ -z $1 ] || dir_id=$1 5 | 6 | 7 | iterations=100000 8 | 9 | [ -z $2 ] || iterations=$2 10 | 11 | STARTDIR=`pwd` 12 | RUNDIR=`pwd`/tmp/nor-$dir_id 13 | mkdir $RUNDIR 14 | cd $RUNDIR 15 | cp $STARTDIR/*sh . 16 | ln -s $STARTDIR/yaffs_test yaffs_test 17 | 18 | ./init_fw_update_test_nor.sh 19 | ./run_fw_update_test_nor.sh $iterations 20 | 21 | echo "!!!!!!!!!!!" 22 | echo "Tests done" 23 | while true 24 | do 25 | sleep 10000 26 | done 27 | -------------------------------------------------------------------------------- /direct/test-framework/tests/nor_stress.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __NOR_STRESS_H__ 16 | #define __NOR_STRESS_H__ 17 | 18 | void NorStressTestInitialise(const char *path); 19 | void NorStressTestRun(const char *path, int n_cycles, int do_fsx, int no_verification); 20 | 21 | #endif 22 | 23 | -------------------------------------------------------------------------------- /direct/test-framework/tests/run_fw_update_test_m18.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | 4 | #set -x 5 | 6 | iterations=100000 7 | 8 | [ -z $1 ] || iterations=$1 9 | 10 | 11 | rm -f iteration-max-* 12 | touch iteration-max-$iterations 13 | 14 | echo " Running $iterations iterations" 15 | sleep 2 16 | 17 | for ((i=0; i < $iterations; i++)) 18 | do 19 | 20 | seed=$RANDOM 21 | j=$(( $i % 10 )) 22 | 23 | rm seed-m18-*$j 24 | echo $seed>seed-m18-for-run-$i 25 | 26 | 27 | rm -f emfile-m18-*$j 28 | cp emfile-m18 emfile-m18-$i 29 | 30 | rm -f log-m18-*$j 31 | 32 | echo "#########" 33 | echo "#########" 34 | echo "#########" 35 | echo "######### Run $i of $iterations with seed $seed" 36 | echo "#########" 37 | echo "#########" 38 | echo "#########" 39 | ./yaffs_test -u -f -p -s$seed -t0 M18-1 >log-m18-$i 40 | done 41 | 42 | -------------------------------------------------------------------------------- /direct/test-framework/tests/run_fw_update_test_nand.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | iterations=100000 4 | 5 | [ -z $1 ] || iterations=$1 6 | 7 | 8 | rm -f iteration-max-* 9 | touch iteration-max-$iterations 10 | 11 | echo " Running $iterations iterations" 12 | sleep 2 13 | 14 | for ((i=0; i < $iterations; i++)) 15 | do 16 | 17 | seed=$RANDOM 18 | j=$(( $i % 10 )) 19 | 20 | rm -f log-nand-*$j 21 | rm -f seed-nand-*$j 22 | echo $seed>seed-nand-for-run-$i 23 | 24 | rm -f emfile-nand-*$j 25 | 26 | cp emfile-nand emfile-nand-$j 27 | 28 | echo "#########" 29 | echo "#########" 30 | echo "#########" 31 | echo "######### Run $i of $iterations with seed $seed" 32 | echo "#########" 33 | echo "#########" 34 | echo "#########" 35 | ./yaffs_test -u -f -p -s$seed -t 0 nand >log-nand-$i 36 | done 37 | -------------------------------------------------------------------------------- /direct/test-framework/tests/run_fw_update_test_nor.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | iterations=100000 4 | 5 | [ -z $1 ] || iterations=$1 6 | 7 | 8 | rm -f iteration-max-* 9 | touch iteration-max-$iterations 10 | 11 | echo " Running $iterations iterations" 12 | sleep 2 13 | 14 | for ((i=0; i < $iterations; i++)) 15 | do 16 | 17 | seed=$RANDOM 18 | j=$(( $i % 10 )) 19 | 20 | rm -f seed-nor-*$j 21 | echo $seed>seed-nor-for-run-$i 22 | 23 | 24 | rm -f emfile-nor-*$j 25 | cp emfile-nor emfile-nor-$i 26 | 27 | rm -f log-nor-*$j 28 | 29 | echo "#########" 30 | echo "#########" 31 | echo "#########" 32 | echo "######### Run $i of $iterations with seed $seed" 33 | echo "#########" 34 | echo "#########" 35 | echo "#########" 36 | ./yaffs_test -u -f -p -s$seed -t0 nor >log-nor-$i 37 | done 38 | 39 | -------------------------------------------------------------------------------- /direct/test-framework/tests/yaffs_fsx.h: -------------------------------------------------------------------------------- 1 | #ifndef __YAFFS_FSX_H__ 2 | #define __YAFFS_FSX_H__ 3 | 4 | int yaffs_fsx_main(const char *mountpt,int n_cycles); 5 | int yaffs_fsx_init(const char *mountpt); 6 | int yaffs_fsx_complete(void); 7 | void yaffs_fsx_do_op(void); 8 | 9 | #endif 10 | 11 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/32_bit/.gitignore: -------------------------------------------------------------------------------- 1 | time_32_tests 2 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/32_bit/create_32_bit.c: -------------------------------------------------------------------------------- 1 | ../shared/create_file.c -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/32_bit/shared.c: -------------------------------------------------------------------------------- 1 | ../shared/shared.c -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/32_bit/shared.h: -------------------------------------------------------------------------------- 1 | ../shared/shared.h -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/32_bit/time_32_tests.c: -------------------------------------------------------------------------------- 1 | #include "yaffsfs.h" 2 | #define YAFFS_MOUNT_POINT "/yflash2/" 3 | #define FILE_PATH "/yflash2/foo.txt" 4 | 5 | int random_seed; 6 | int simulate_power_failure = 0; 7 | 8 | 9 | int main() 10 | { 11 | yaffs_start_up(); 12 | 13 | //test that ytime is 32 bits 14 | 15 | if (sizeof(YTIME_T) != 4) { 16 | printf("Error:size of YTIME_T is %lu, not 32 bits \n", sizeof(YTIME_T)*8); 17 | return 1; 18 | } 19 | 20 | 21 | //create several times and save them 22 | // 23 | 24 | //extra tests 25 | //save the time and get it to overflow. 26 | printf("all tests pass\n"); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/32_bit/validate_32_bit.c: -------------------------------------------------------------------------------- 1 | ../shared/validate_file.c -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/64_bit/.gitignore: -------------------------------------------------------------------------------- 1 | time_64_tests 2 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/64_bit/create_64_bit.c: -------------------------------------------------------------------------------- 1 | ../shared/create_file.c -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/64_bit/shared.c: -------------------------------------------------------------------------------- 1 | ../shared/shared.c -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/64_bit/shared.h: -------------------------------------------------------------------------------- 1 | ../shared/shared.h -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/64_bit/validate_64_bit.c: -------------------------------------------------------------------------------- 1 | ../shared/validate_file.c -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/shared/create_file.c: -------------------------------------------------------------------------------- 1 | #include "shared.h" 2 | 3 | int random_seed; 4 | int simulate_power_failure = 0; 5 | 6 | int main(int argc, char *argv[] ){ 7 | int ret = shared_create(argc, argv); 8 | ret = ret && shared_validate_file(argc, argv); 9 | return ret; 10 | } 11 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/shared/shared.h: -------------------------------------------------------------------------------- 1 | #ifndef __SHARED_H__ 2 | #define __SHARED_H__ 3 | 4 | #define TEST_PASS 0 5 | #define TEST_FAIL 1 6 | 7 | #define YAFFS_MOUNT_POINT "/yflash2/" 8 | #define FILE_PATH "/yflash2/foo.txt" 9 | 10 | void setup_yaffs(); 11 | int shared_create(); 12 | int shared_validate_file(); 13 | #endif 14 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/shared/validate_file.c: -------------------------------------------------------------------------------- 1 | #include "shared.h" 2 | 3 | int random_seed; 4 | int simulate_power_failure = 0; 5 | 6 | int main(int argc, char *argv[] ){ 7 | return shared_validate_file(argc, argv); 8 | } 9 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/64_and_32_bit_time/time_test_runner.sh: -------------------------------------------------------------------------------- 1 | make -C 32_bit/ && make -C 64_bit/ && 2 | rm emfile-* && 3 | ./32_bit/create_32_bit /yflash2/foo 100 && 4 | echo created 32 bit file && 5 | ./64_bit/validate_64_bit /yflash2/foo 100 && 6 | echo 32 bit file opened with 64 bit mode correctly 7 | 8 | rm emfile-* && 9 | ./64_bit/create_64_bit /yflash2/foo 100 && 10 | echo created 64 bit file && 11 | ./32_bit/validate_32_bit /yflash2/foo 100 && 12 | echo 64 bit file opened with 32 bit mode correctly && 13 | 14 | echo All tests ran properly 15 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/is_yaffs_working_tests/.gitignore: -------------------------------------------------------------------------------- 1 | test_1_yaffs_mount 2 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/is_yaffs_working_tests/README.txt: -------------------------------------------------------------------------------- 1 | is_yaffs_working_tests folder contains the very simple tests to check that yaffs has been installed properly. 2 | 3 | test_1_yaffs_mount.c mounts yaffs, creates a file, unmounts and then mounts yaffs and checks that the file is still there. 4 | 5 | 6 | 7 | compile command: make 8 | run command: ./test_1_yaffs_mount 9 | 10 | command line options: 11 | No commands. 12 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/.gitignore: -------------------------------------------------------------------------------- 1 | quick_tests 2 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | #include "test_yaffs_access.h" 14 | 15 | int test_yaffs_access(void) 16 | { 17 | 18 | if (-1==yaffs_close(yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE))){ 19 | print_message("failed to create file\n",1); 20 | return -1; 21 | } 22 | return yaffs_access(FILE_PATH,0); 23 | } 24 | 25 | int test_yaffs_access_clean(void) 26 | { 27 | return 1; 28 | } 29 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_access_h__ 16 | #define __test_yaffs_access_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | int test_yaffs_access(void); 20 | int test_yaffs_access_clean(void); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_EACCES.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_access_EACCES_h__ 16 | #define __test_yaffs_access_EACCES_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | int test_yaffs_access_EACCES(void); 20 | int test_yaffs_access_EACCES_clean(void); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs__access_EINVAL_h__ 16 | #define __test_yaffs_access_EINVAL_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | int test_yaffs_access_EINVAL(void); 20 | int test_yaffs_access_EINVAL_clean(void); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_ELOOP.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_access_ELOOP_h__ 16 | #define __test_yaffs_access_ELOOP_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | int test_yaffs_access_ELOOP(void); 20 | int test_yaffs_access_ELOOP_clean(void); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs__access_ELOOP_dir_h__ 16 | #define __test_yaffs_access_ELOOP_dir_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | int test_yaffs_access_ELOOP_dir(void); 20 | int test_yaffs_access_ELOOP_dir_clean(void); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_access_ENAMETOOLONG_h__ 16 | #define __test_yaffs_access_ENAMETOOLONG_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | int test_yaffs_access_ENAMETOOLONG(void); 20 | int test_yaffs_access_ENAMETOOLONG_clean(void); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_access_ENOENT_h__ 16 | #define __test_yaffs_access_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_access_ENOENT(void); 22 | int test_yaffs_access_ENOENT_clean(void); 23 | #endif 24 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_ENOENT2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_access_ENOENT2_h__ 16 | #define __test_yaffs_access_ENOENT2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_access_ENOENT2(void); 22 | int test_yaffs_access_ENOENT2_clean(void); 23 | #endif 24 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_access_ENOTDIR_h__ 16 | #define __test_yaffs_access_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_access_ENOTDIR(void); 22 | int test_yaffs_access_ENOTDIR_clean(void); 23 | #endif 24 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs__access_EROFS_h__ 16 | #define __test_yaffs_access_EROFS_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | int test_yaffs_access_EROFS(void); 20 | int test_yaffs_access_EROFS_clean(void); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_access_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_access_NULL_h__ 16 | #define __test_yaffs_access_NULL_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | int test_yaffs_access_NULL(void); 20 | int test_yaffs_access_NULL_clean(void); 21 | #endif 22 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_chmod.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_chmod_h__ 16 | #define __test_yaffs_chmod_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_chmod(void); 22 | int test_yaffs_chmod_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_chmod_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_chmod_EINVAL_h__ 16 | #define __test_yaffs_chmod_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_chmod.h" 21 | 22 | int test_yaffs_chmod_EINVAL(void); 23 | int test_yaffs_chmod_EINVAL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_chmod_ELOOP.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_chmod_ELOOP_h__ 16 | #define __test_yaffs_chmod_ELOOP_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_chmod.h" 21 | 22 | int test_yaffs_chmod_ELOOP(void); 23 | int test_yaffs_chmod_ELOOP_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_chmod_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_chmod_ELOOP_dir_h__ 16 | #define __test_yaffs_chmod_ELOOP_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_chmod.h" 21 | 22 | int test_yaffs_chmod_ELOOP_dir(void); 23 | int test_yaffs_chmod_ELOOP_dir_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_chmod_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_chmod_ENOENT_h__ 16 | #define __test_yaffs_chmod_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_chmod_ENOENT(void); 22 | int test_yaffs_chmod_ENOENT_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_chmod_ENOENT2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_chmod_ENOENT2_h__ 16 | #define __test_yaffs_chmod_ENOENT2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_chmod_ENOENT2(void); 22 | int test_yaffs_chmod_ENOENT2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_chmod_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_chmod_ENOTDIR_h__ 16 | #define __test_yaffs_chmod_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_chmod_ENOTDIR(void); 22 | int test_yaffs_chmod_ENOTDIR_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_chmod_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_chmod_EROFS_h__ 16 | #define __test_yaffs_chmod_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_chmod.h" 21 | 22 | int test_yaffs_chmod_EROFS(void); 23 | int test_yaffs_chmod_EROFS_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_chmod_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_chmod_NULL_h__ 16 | #define __test_yaffs_chmod_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_chmod.h" 21 | 22 | int test_yaffs_chmod_NULL(void); 23 | int test_yaffs_chmod_NULL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_close.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Aleph-One-Ltd/yaffs2/68030683543cccb4d942e3fedbcad1dc267e261c/direct/test-framework/unit_tests/quick_tests/test_yaffs_close.c -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_close.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Aleph-One-Ltd/yaffs2/68030683543cccb4d942e3fedbcad1dc267e261c/direct/test-framework/unit_tests/quick_tests/test_yaffs_close.h -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_close_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_close_EBADF_h__ 16 | #define __test_yaffs_close_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_close_EBADF(void); 22 | int test_yaffs_close_EBADF_clean(void); 23 | #endif 24 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_close_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_close_NULL_h__ 16 | #define __test_yaffs_close_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_close_NULL(void); 22 | int test_yaffs_close_NULL_clean(void); 23 | #endif 24 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_dup.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_dup_h__ 16 | #define __test_yaffs_dup_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_dup(void); 22 | int test_yaffs_dup_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_dup_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_dup_EBADF_h__ 16 | #define __test_yaffs_dup_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_dup_EBADF(void); 22 | int test_yaffs_dup_EBADF_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fchmod.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fchmod_h__ 16 | #define __test_yaffs_fchmod_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_fchmod(void); 22 | int test_yaffs_fchmod_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fchmod_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fchmod_EBADF_h__ 16 | #define __test_yaffs_fchmod_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_fchmod_EBADF(void); 22 | int test_yaffs_fchmod_EBADF_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fchmod_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fchmod_EROFS_h__ 16 | #define __test_yaffs_fchmod_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_fchmod_EROFS(void); 22 | int test_yaffs_fchmod_EROFS_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fchmod_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fchmod_NULL_h__ 16 | #define __test_yaffs_fchmod_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_fchmod_NULL(void); 22 | int test_yaffs_fchmod_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fdatasync.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fdatasync_h__ 16 | #define __test_yaffs_fdatasync_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_fdatasync(void); 23 | int test_yaffs_fdatasync_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fdatasync_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fdatasync_EBADF_h__ 16 | #define __test_yaffs_fdatasync_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_fdatasync_EBADF(void); 23 | int test_yaffs_fdatasync_EBADF_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fdatasync_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fdatasync_EROFS_h__ 16 | #define __test_yaffs_fdatasync_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_fdatasync_EROFS(void); 23 | int test_yaffs_fdatasync_EROFS_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fdatasync_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fdatasync_NULL_h__ 16 | #define __test_yaffs_fdatasync_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_fdatasync_NULL(void); 23 | int test_yaffs_fdatasync_NULL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_flush.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_flush_h__ 16 | #define __test_yaffs_flush_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_close.h" 21 | 22 | int test_yaffs_flush(void); 23 | int test_yaffs_flush_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_flush_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_flush_EBADF_h__ 16 | #define __test_yaffs_flush_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_close.h" 21 | 22 | int test_yaffs_flush_EBADF(void); 23 | int test_yaffs_flush_EBADF_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_flush_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_flush_EROFS_h__ 16 | #define __test_yaffs_flush_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_flush_EROFS(void); 23 | int test_yaffs_flush_EROFS_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_freespace.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | #include "test_yaffs_freespace.h" 14 | 15 | 16 | 17 | int test_yaffs_freespace(void) 18 | { 19 | int output=0; 20 | output = yaffs_freespace(YAFFS_MOUNT_POINT); 21 | return output; 22 | } 23 | 24 | 25 | int test_yaffs_freespace_clean(void) 26 | { 27 | return 1; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_freespace.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_freespace_h__ 16 | #define __test_yaffs_freespace_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_freespace(void); 22 | int test_yaffs_freespace_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_freespace_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_freespace_EINVAL_h__ 16 | #define __test_yaffs_freespace_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_freespace_EINVAL(void); 22 | int test_yaffs_freespace_EINVAL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_freespace_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_freespace_ENAMETOOLONG_h__ 16 | #define __test_yaffs_freespace_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_freespace_ENAMETOOLONG(void); 22 | int test_yaffs_freespace_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_freespace_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_freespace_NULL_h__ 16 | #define __test_yaffs_freespace_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_freespace_NULL(void); 22 | int test_yaffs_freespace_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fstat.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fstat_h__ 16 | #define __test_yaffs_fstat_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_fstat(void); 23 | int test_yaffs_fstat_clean(void); 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fstat_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fstat_EBADF_h__ 16 | #define __test_yaffs_fstat_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_fstat_EBADF(void); 23 | int test_yaffs_fstat_EBADF_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fsync.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | #include "test_yaffs_fsync.h" 14 | 15 | static int handle = 0; 16 | 17 | int test_yaffs_fsync(void) 18 | { 19 | handle = test_yaffs_open(); 20 | return yaffs_fsync(handle); 21 | } 22 | 23 | 24 | int test_yaffs_fsync_clean(void) 25 | { 26 | if (handle >= 0){ 27 | return yaffs_close(handle); 28 | } else { 29 | return 1; /* the file failed to open so there is no need to close it */ 30 | } 31 | } 32 | 33 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fsync.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fsync_h__ 16 | #define __test_yaffs_fsync_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_fsync(void); 23 | int test_yaffs_fsync_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fsync_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fsync_EBADF_h__ 16 | #define __test_yaffs_fsync_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_fsync_EBADF(void); 22 | int test_yaffs_fsync_EBADF_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_fsync_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_fsync_EROFS_h__ 16 | #define __test_yaffs_fsync_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_fsync_EROFS(void); 23 | int test_yaffs_fsync_EROFS_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_ftruncate.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_ftruncate_h__ 16 | #define __test_yaffs_ftruncate_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_ftruncate(void); 23 | int test_yaffs_ftruncate_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_ftruncate_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_ftruncate_EBADF_h__ 16 | #define __test_yaffs_ftruncate_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_ftruncate_EBADF(void); 23 | int test_yaffs_ftruncate_EBADF_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_ftruncate_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_ftruncate_EINVAL_h__ 16 | #define __test_yaffs_ftruncate_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_ftruncate_EINVAL(void); 23 | int test_yaffs_ftruncate_EINVAL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_ftruncate_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_ftruncate_EROFS_h__ 16 | #define __test_yaffs_ftruncate_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_ftruncate_EROFS(void); 23 | int test_yaffs_ftruncate_EROFS_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_inodecount.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | #include "test_yaffs_inodecount.h" 14 | 15 | 16 | 17 | int test_yaffs_inodecount(void) 18 | { 19 | int output=0; 20 | output = yaffs_inodecount(YAFFS_MOUNT_POINT); 21 | return output; 22 | } 23 | 24 | 25 | int test_yaffs_inodecount_clean(void) 26 | { 27 | return 1; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_inodecount.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_inodecount_h__ 16 | #define __test_yaffs_inodecount_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_inodecount(void); 22 | int test_yaffs_inodecount_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_inodecount_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_inodecount_EINVAL_h__ 16 | #define __test_yaffs_inodecount_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_inodecount_EINVAL(void); 22 | int test_yaffs_inodecount_EINVAL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_inodecount_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_inodecount_ENAMETOOLONG_h__ 16 | #define __test_yaffs_inodecount_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_inodecount_ENAMETOOLONG(void); 22 | int test_yaffs_inodecount_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_inodecount_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_inodecount_NULL_h__ 16 | #define __test_yaffs_inodecount_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_inodecount_NULL(void); 22 | int test_yaffs_inodecount_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_h__ 16 | #define __test_yaffs_link_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link(void); 22 | int test_yaffs_link_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_EEXIST.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_EEXIST_h__ 16 | #define __test_yaffs_link_EEXIST_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_EEXIST(void); 22 | int test_yaffs_link_EEXIST_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_ELOOP_dir_h__ 16 | #define __test_yaffs_link_ELOOP_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_ELOOP_dir(void); 22 | int test_yaffs_link_ELOOP_dir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_ENAMETOOLONG_h__ 16 | #define __test_yaffs_link_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_ENAMETOOLONG(void); 22 | int test_yaffs_link_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_ENAMETOOLONG2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_ENAMETOOLONG2_h__ 16 | #define __test_yaffs_link_ENAMETOOLONG2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_ENAMETOOLONG2(void); 22 | int test_yaffs_link_ENAMETOOLONG2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_ENOENT_h__ 16 | #define __test_yaffs_link_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_ENOENT(void); 22 | int test_yaffs_link_ENOENT_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_ENOENT2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_ENOENT2_h__ 16 | #define __test_yaffs_link_ENOENT2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_ENOENT2(void); 22 | int test_yaffs_link_ENOENT2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_ENOENT3.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_ENOENT3_h__ 16 | #define __test_yaffs_link_ENOENT32_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_ENOENT3(void); 22 | int test_yaffs_link_ENOENT3_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_ENOENT4.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_ENOENT4_h__ 16 | #define __test_yaffs_link_ENOENT4_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_ENOENT4(void); 22 | int test_yaffs_link_ENOENT4_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_ENOTDIR_h__ 16 | #define __test_yaffs_link_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_ENOTDIR(void); 22 | int test_yaffs_link_ENOTDIR_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_ENOTDIR2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_ENOTDIR2_h__ 16 | #define __test_yaffs_link_ENOTDIR2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_ENOTDIR2(void); 22 | int test_yaffs_link_ENOTDIR2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_EROFS_h__ 16 | #define __test_yaffs_link_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_EROFS(void); 22 | int test_yaffs_link_EROFS_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_NULL_h__ 16 | #define __test_yaffs_link_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_NULL(void); 22 | int test_yaffs_link_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_link_NULL2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_link_NULL2_h__ 16 | #define __test_yaffs_link_NULL2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_link_NULL2(void); 22 | int test_yaffs_link_NULL2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_lseek.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_lseek_h__ 16 | #define __test_yaffs_lseek_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_lseek(void); 23 | int test_yaffs_lseek_clean(void); 24 | int test_yaffs_lseek_to_beginning(void); 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_lseek_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_lseek_EBADF_h__ 16 | #define __test_yaffs_lseek_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_lseek_EBADF(void); 22 | int test_yaffs_lseek_EBADF_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_lseek_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_lseek_EINVAL_h__ 16 | #define __test_yaffs_lseek_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_lseek_EINVAL(void); 23 | int test_yaffs_lseek_EINVAL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_lseek_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_lseek_EROFS_h__ 16 | #define __test_yaffs_lseek_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_lseek_EROFS(void); 23 | int test_yaffs_lseek_EROFS_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_lseek_big_file.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_lseek_big_file_h__ 16 | #define __test_yaffs_lseek_big_file_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_lseek_big_file(void); 23 | int test_yaffs_lseek_big_file_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_lstat.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_lstat_h__ 16 | #define __test_yaffs_lstat_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_lstat(void); 22 | int test_yaffs_lstat_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_lstat_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_lstat_ENOENT_h__ 16 | #define __test_yaffs_lstat_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_lstat_ENOENT(void); 23 | int test_yaffs_lstat_ENOENT_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_lstat_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_lstat_ENOTDIR_h__ 16 | #define __test_yaffs_lstat_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_lstat_ENOTDIR(void); 23 | int test_yaffs_lstat_ENOTDIR_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_lstat_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_lstat_NULL_h__ 16 | #define __test_yaffs_lstat_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_lstat_NULL(void); 23 | int test_yaffs_lstat_NULL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mkdir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mkdir_h__ 16 | #define __test_yaffs_mkdir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mkdir(void); 22 | int test_yaffs_mkdir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mkdir_EEXIST.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mkdir_EEXIST_h__ 16 | #define __test_yaffs_mkdir_EEXIST_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mkdir_EEXIST(void); 22 | int test_yaffs_mkdir_EEXIST_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mkdir_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mkdir_ELOOP_dir_h__ 16 | #define __test_yaffs_mkdir_ELOOP_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mkdir_ELOOP_dir(void); 22 | int test_yaffs_mkdir_ELOOP_dir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mkdir_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mkdir_ENAMETOOLONG_h__ 16 | #define __test_yaffs_mkdir_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mkdir_ENAMETOOLONG(void); 22 | int test_yaffs_mkdir_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mkdir_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mkdir_ENOENT_h__ 16 | #define __test_yaffs_mkdir_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mkdir_ENOENT(void); 22 | int test_yaffs_mkdir_ENOENT_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mkdir_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mkdir_ENOTDIR_h__ 16 | #define __test_yaffs_mkdir_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mkdir_ENOTDIR(void); 22 | int test_yaffs_mkdir_ENOTDIR_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mkdir_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mkdir_EROFS_h__ 16 | #define __test_yaffs_mkdir_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mkdir_EROFS(void); 22 | int test_yaffs_mkdir_EROFS_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mkdir_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mkdir_NULL_h__ 16 | #define __test_yaffs_mkdir_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mkdir_NULL(void); 22 | int test_yaffs_mkdir_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mount.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | #include "test_yaffs_mount.h" 14 | 15 | int test_yaffs_mount(void) 16 | { 17 | int output = 0; 18 | output = yaffs_mount(YAFFS_MOUNT_POINT); 19 | yaffs_mkdir(TEST_DIR,S_IWRITE | S_IREAD); 20 | 21 | return output; 22 | } 23 | 24 | int test_yaffs_mount_clean(void) 25 | { 26 | return 1; 27 | } 28 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mount.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mount__ 16 | #define __test_yaffs_mount__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | 21 | int test_yaffs_mount(void); 22 | int test_yaffs_mount_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mount2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mount2__ 16 | #define __test_yaffs_mount2__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | #include "test_yaffs_unmount.h" 21 | 22 | int test_yaffs_mount2(void); 23 | int test_yaffs_mount2_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mount2_ENODEV.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mount2_ENODEV__ 16 | #define __test_yaffs_mount2_ENODEV__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | #include "test_yaffs_unmount.h" 21 | 22 | int test_yaffs_mount2_ENODEV(void); 23 | int test_yaffs_mount2_ENODEV_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mount_EBUSY.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mount_EBUSY_h__ 16 | #define __test_yaffs_mount_EBUSY_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mount_EBUSY(void); 22 | int test_yaffs_mount_EBUSY_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mount_ENODEV.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mount_ENODEV_h__ 16 | #define __test_yaffs_mount_ENODEV_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mount_ENODEV(void); 22 | int test_yaffs_mount_ENODEV_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_mount_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_mount_NULL_h__ 16 | #define __test_yaffs_mount_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_mount_NULL(void); 22 | int test_yaffs_mount_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_h__ 16 | #define __test_yaffs_open_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open(void); 22 | int test_yaffs_open_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_EACCES.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_EACCES_h__ 16 | #define __test_yaffs_open_EACCES_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_EACCES(void); 22 | int test_yaffs_open_EACCES_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_EEXIST.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_EEXIST_h__ 16 | #define __test_yaffs_open_EEXIST_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_EEXIST(void); 22 | int test_yaffs_open_EEXIST_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_EINVAL_h__ 16 | #define __test_yaffs_open_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_EINVAL(void); 22 | int test_yaffs_open_EINVAL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_EINVAL2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_EINVAL2_h__ 16 | #define __test_yaffs_open_EINVAL2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_EINVAL2(void); 22 | int test_yaffs_open_EINVAL2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_ELOOP.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_ELOOP_h__ 16 | #define __test_yaffs_open_ELOOP_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_ELOOP(void); 22 | int test_yaffs_open_ELOOP_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_ELOOP_dir_h__ 16 | #define __test_yaffs_open_ELOOP_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_ELOOP_dir(void); 22 | int test_yaffs_open_ELOOP_dir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_ENAMETOOLONG_h__ 16 | #define __test_yaffs_open_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_ENAMETOOLONG(void); 22 | int test_yaffs_open_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_ENOENT_h__ 16 | #define __test_yaffs_open_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_ENOENT(void); 22 | int test_yaffs_open_ENOENT_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_ENOTDIR_h__ 16 | #define __test_yaffs_open_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_ENOTDIR(void); 22 | int test_yaffs_open_ENOTDIR_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_EROFS_h__ 16 | #define __test_yaffs_open_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_EROFS(void); 22 | int test_yaffs_open_EROFS_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_open_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_open_NULL_h__ 16 | #define __test_yaffs_open_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_open_NULL(void); 22 | int test_yaffs_open_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_read.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_read_h__ 16 | #define __test_yaffs_read_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | #include "test_yaffs_open.h" 20 | 21 | 22 | int test_yaffs_read(void); 23 | int test_yaffs_read_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_read_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_read_EBADF_h__ 16 | #define __test_yaffs_read_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_read_EBADF(void); 23 | int test_yaffs_read_EBADF_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_remount_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_remount_EINVAL__ 16 | #define __test_yaffs_remount_EINVAL__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | #include "test_yaffs_unmount.h" 21 | 22 | int test_yaffs_remount_EINVAL(void); 23 | int test_yaffs_remount_EINVAL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_remount_ENODEV.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_remount_ENODEV__ 16 | #define __test_yaffs_remount_ENODEV__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | #include "test_yaffs_unmount.h" 21 | 22 | int test_yaffs_remount_ENODEV(void); 23 | int test_yaffs_remount_ENODEV_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_remount_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_remount_NULL__ 16 | #define __test_yaffs_remount_NULL__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | #include "test_yaffs_unmount.h" 21 | 22 | int test_yaffs_remount_NULL(void); 23 | int test_yaffs_remount_NULL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_h__ 16 | #define __test_yaffs_rename_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_rename(void); 23 | int test_yaffs_rename_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_EEXISTS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_EEXISTS_h__ 16 | #define __test_yaffs_rename_EEXISTS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_EEXISTS(void); 22 | int test_yaffs_rename_EEXISTS_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_EINVAL_h__ 16 | #define __test_yaffs_rename_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_EINVAL(void); 22 | int test_yaffs_rename_EINVAL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_ELOOP_dir_h__ 16 | #define __test_yaffs_rename_ELOOP_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_ELOOP_dir(void); 22 | int test_yaffs_rename_ELOOP_dir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_ENAMETOOLONG_h__ 16 | #define __test_yaffs_rename_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_ENAMETOOLONG(void); 22 | int test_yaffs_rename_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_ENAMETOOLONG2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_ENAMETOOLONG2_h__ 16 | #define __test_yaffs_rename_ENAMETOOLONG2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_ENAMETOOLONG2(void); 22 | int test_yaffs_rename_ENAMETOOLONG2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_ENOENT_h__ 16 | #define __test_yaffs_rename_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_ENOENT(void); 22 | int test_yaffs_rename_ENOENT_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_ENOTDIR_h__ 16 | #define __test_yaffs_rename_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_ENOTDIR(void); 22 | int test_yaffs_rename_ENOTDIR_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_ENOTEMPTY.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __TEST_YAFFS_RENAME_ENOTEMPTY_H__ 16 | #define __TEST_YAFFS_RENAME_ENOTEMPTY_H__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_ENOTEMPTY(void); 22 | int test_yaffs_rename_ENOTEMPTY_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_EROFS_h__ 16 | #define __test_yaffs_rename_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_EROFS(void); 22 | int test_yaffs_rename_EROFS_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_NULL_h__ 16 | #define __test_yaffs_rename_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_NULL(void); 22 | int test_yaffs_rename_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_NULL2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_NULL2_h__ 16 | #define __test_yaffs_rename_NULL2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_NULL2(void); 22 | int test_yaffs_rename_NULL2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_dir_h__ 16 | #define __test_yaffs_rename_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_rename_dir(void); 23 | int test_yaffs_rename_dir_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_dir_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_dir_ENOENT_h__ 16 | #define __test_yaffs_rename_dir_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_rename_dir_ENOENT(void); 23 | int test_yaffs_rename_dir_ENOENT_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_dir_not_empty.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rename_dir_h__ 16 | #define __test_yaffs_rename_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_rename_dir(void); 23 | int test_yaffs_rename_dir_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_dir_over_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __TEST_YAFFS_RENAME_DIR_OVER_DIR_H__ 16 | #define __TEST_YAFFS_RENAME_DIR_OVER_DIR_H__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_dir_over_dir(void); 22 | int test_yaffs_rename_dir_over_dir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_file_over_file.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_RENAME_FILE_OVER_FILE_H__ 16 | #define __test_yaffs_RENAME_FILE_OVER_FILE_H__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_file_over_file(void); 22 | int test_yaffs_rename_file_over_file_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_full_dir_over_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __TEST_YAFFS_RENAME_FULL_DIR_OVER_DIR_H__ 16 | #define __TEST_YAFFS_RENAME_FULL_DIR_OVER_DIR_H__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rename_full_dir_over_dir(void); 22 | int test_yaffs_rename_full_dir_over_dir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rename_to_null_file.h: -------------------------------------------------------------------------------- 1 | #ifndef __test_yaffs_rename_NULL3_h__ 2 | #define __test_yaffs_rename_NULL3_h__ 3 | 4 | #include "lib.h" 5 | #include "yaffsfs.h" 6 | 7 | int test_yaffs_rename_to_null_file(void); 8 | int test_yaffs_rename_to_null_file_clean(void); 9 | 10 | #endif 11 | 12 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_h__ 16 | #define __test_yaffs_rmdir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir(void); 22 | int test_yaffs_rmdir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir_EBUSY.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_EBUSY_h__ 16 | #define __test_yaffs_rmdir_EBUSY_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir_EBUSY(void); 22 | int test_yaffs_rmdir_EBUSY_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_EINVAL_h__ 16 | #define __test_yaffs_rmdir_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir_EINVAL(void); 22 | int test_yaffs_rmdir_EINVAL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_ELOOP_dir_h__ 16 | #define __test_yaffs_rmdir_ELOOP_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir_ELOOP_dir(void); 22 | int test_yaffs_rmdir_ELOOP_dir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_ENAMETOOLONG_h__ 16 | #define __test_yaffs_rmdir_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir_ENAMETOOLONG(void); 22 | int test_yaffs_rmdir_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_ENOENT_h__ 16 | #define __test_yaffs_rmdir_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir_ENOENT(void); 22 | int test_yaffs_rmdir_ENOENT_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_ENOTDIR_h__ 16 | #define __test_yaffs_rmdir_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir_ENOTDIR(void); 22 | int test_yaffs_rmdir_ENOTDIR_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir_ENOTEMPTY.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_ENOTEMPTY_h__ 16 | #define __test_yaffs_rmdir_ENOTEMPTY_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir_ENOTEMPTY(void); 22 | int test_yaffs_rmdir_ENOTEMPTY_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_EROFS_h__ 16 | #define __test_yaffs_rmdir_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir_EROFS(void); 22 | int test_yaffs_rmdir_EROFS_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_rmdir_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_rmdir_NULL_h__ 16 | #define __test_yaffs_rmdir_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_rmdir_NULL(void); 22 | int test_yaffs_rmdir_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_stat_ELOOP.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_stat_ELOOP_h__ 16 | #define __test_yaffs_stat_ELOOP_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_stat_ELOOP(void); 23 | int test_yaffs_stat_ELOOP_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_stat_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_stat_ELOOP_dir_h__ 16 | #define __test_yaffs_stat_ELOOP_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_stat_ELOOP_dir(void); 23 | int test_yaffs_stat_ELOOP_dir_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_stat_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_stat_ENAMETOOLONG_h__ 16 | #define __test_yaffs_stat_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_stat_ENAMETOOLONG(void); 23 | int test_yaffs_stat_ENAMETOOLONG_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_stat_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_stat_ENOENT_h__ 16 | #define __test_yaffs_stat_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_stat_ENOENT(void); 23 | int test_yaffs_stat_ENOENT_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_stat_ENOENT2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_stat_ENOENT2_h__ 16 | #define __test_yaffs_stat_ENOENT2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_stat_ENOENT2(void); 23 | int test_yaffs_stat_ENOENT2_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_stat_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_stat_ENOTDIR_h__ 16 | #define __test_yaffs_stat_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_stat_ENOTDIR(void); 23 | int test_yaffs_stat_ENOTDIR_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_stat_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_stat_NULL_h__ 16 | #define __test_yaffs_stat_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_stat_NULL(void); 23 | int test_yaffs_stat_NULL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_h__ 16 | #define __test_yaffs_symlink_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink(void); 22 | int test_yaffs_symlink_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink_EEXIST.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_EEXIST_h__ 16 | #define __test_yaffs_symlink_EEXIST_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink_EEXIST(void); 22 | int test_yaffs_symlink_EEXIST_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_ELOOP_dir_h__ 16 | #define __test_yaffs_symlink_ELOOP_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink_ELOOP_dir(void); 22 | int test_yaffs_symlink_ELOOP_dir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_ENAMETOOLONG_h__ 16 | #define __test_yaffs_symlink_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink_ENAMETOOLONG(void); 22 | int test_yaffs_symlink_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_ENOENT_h__ 16 | #define __test_yaffs_symlink_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink_ENOENT(void); 22 | int test_yaffs_symlink_ENOENT_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink_ENOENT2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_ENOENT2_h__ 16 | #define __test_yaffs_symlink_ENOENT2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink_ENOENT2(void); 22 | int test_yaffs_symlink_ENOENT2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_ENOTDIR_h__ 16 | #define __test_yaffs_symlink_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink_ENOTDIR(void); 22 | int test_yaffs_symlink_ENOTDIR_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_EROFS_h__ 16 | #define __test_yaffs_symlink_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink_EROFS(void); 22 | int test_yaffs_symlink_EROFS_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_NULL_h__ 16 | #define __test_yaffs_symlink_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink_NULL(void); 22 | int test_yaffs_symlink_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_symlink_NULL2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_symlink_NULL2_h__ 16 | #define __test_yaffs_symlink_NULL2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_symlink_NULL2(void); 22 | int test_yaffs_symlink_NULL2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_sync.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | #include "test_yaffs_sync.h" 14 | 15 | 16 | int test_yaffs_sync(void) 17 | { 18 | return yaffs_sync(FILE_PATH); 19 | 20 | } 21 | 22 | 23 | int test_yaffs_sync_clean(void) 24 | { 25 | return 1; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_sync.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_sync_h__ 16 | #define __test_yaffs_sync_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_sync(void); 22 | int test_yaffs_sync_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_sync_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_sync_ENAMETOOLONG_h__ 16 | #define __test_yaffs_sync_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_sync_ENAMETOOLONG(void); 22 | int test_yaffs_sync_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_sync_ENODEV.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_sync_ENODEV_h__ 16 | #define __test_yaffs_sync_ENODEV_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_sync_ENODEV(void); 22 | int test_yaffs_sync_ENODEV_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_sync_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_sync_EROFS_h__ 16 | #define __test_yaffs_sync_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_sync_EROFS(void); 22 | int test_yaffs_sync_EROFS_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_sync_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_sync_NULL_h__ 16 | #define __test_yaffs_sync_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_sync_NULL(void); 22 | int test_yaffs_sync_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_totalspace.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | #include "test_yaffs_totalspace.h" 14 | 15 | 16 | 17 | int test_yaffs_totalspace(void) 18 | { 19 | int output=0; 20 | output = yaffs_totalspace(YAFFS_MOUNT_POINT); 21 | return output; 22 | } 23 | 24 | 25 | int test_yaffs_totalspace_clean(void) 26 | { 27 | return 1; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_totalspace.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_totalspace_h__ 16 | #define __test_yaffs_totalspace_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_totalspace(void); 22 | int test_yaffs_totalspace_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_totalspace_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_totalspace_EINVAL_h__ 16 | #define __test_yaffs_totalspace_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_totalspace_EINVAL(void); 22 | int test_yaffs_totalspace_EINVAL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_totalspace_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_ENAMETOOLONG_EINVAL_h__ 16 | #define __test_yaffs_ENAMETOOLONG_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_totalspace_ENAMETOOLONG(void); 22 | int test_yaffs_totalspace_ENAMETOOLONG_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_totalspace_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_totalspace_NULL_h__ 16 | #define __test_yaffs_totalspace_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_totalspace_NULL(void); 22 | int test_yaffs_totalspace_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_h__ 16 | #define __test_yaffs_truncate_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_truncate(void); 23 | int test_yaffs_truncate_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_EINVAL_h__ 16 | #define __test_yaffs_truncate_EINVAL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_truncate_EINVAL(void); 23 | int test_yaffs_truncate_EINVAL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_EISDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_EISDIR_h__ 16 | #define __test_yaffs_truncate_EISDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_truncate_EISDIR(void); 23 | int test_yaffs_truncate_EISDIR_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_ELOOP.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_ELOOP_h__ 16 | #define __test_yaffs_truncate_ELOOP_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | #include "test_yaffs_open.h" 20 | int test_yaffs_truncate_ELOOP(void); 21 | int test_yaffs_truncate_ELOOP_clean(void); 22 | #endif 23 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_ELOOP_dir_h__ 16 | #define __test_yaffs_truncate_ELOOP_dir_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | #include "test_yaffs_open.h" 20 | int test_yaffs_truncate_ELOOP_dir(void); 21 | int test_yaffs_truncate_ELOOP_dir_clean(void); 22 | #endif 23 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_ENOENT_h__ 16 | #define __test_yaffs_truncate_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_truncate_ENOENT(void); 23 | int test_yaffs_truncate_ENOENT_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_ENOENT2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_ENOENT2_h__ 16 | #define __test_yaffs_truncate_ENOENT2_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | #include "test_yaffs_open.h" 20 | int test_yaffs_truncate_ENOENT2(void); 21 | int test_yaffs_truncate_ENOENT2_clean(void); 22 | #endif 23 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_ENOTDIR_h__ 16 | #define __test_yaffs_truncate_ENOTDIR_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | #include "test_yaffs_open.h" 20 | int test_yaffs_truncate_ENOTDIR(void); 21 | int test_yaffs_truncate_ENOTDIR_clean(void); 22 | #endif 23 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_EROFS_h__ 16 | #define __test_yaffs_truncate_EROFS_h__ 17 | #include "lib.h" 18 | #include "yaffsfs.h" 19 | #include "test_yaffs_open.h" 20 | int test_yaffs_truncate_EROFS(void); 21 | int test_yaffs_truncate_EROFS_clean(void); 22 | #endif 23 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_NULL_h__ 16 | #define __test_yaffs_truncate_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_truncate_NULL(void); 23 | int test_yaffs_truncate_NULL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_truncate_big_file.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_truncate_big_file_h__ 16 | #define __test_yaffs_truncate_big_file_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_truncate_big_file(void); 23 | int test_yaffs_truncate_big_file_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unlink.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unlink_h__ 16 | #define __test_yaffs_unlink_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | #include "test_yaffs_access.h" 22 | 23 | int test_yaffs_unlink(void); 24 | int test_yaffs_unlink_clean(void); 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unlink_EISDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unlink_EISDIR_h__ 16 | #define __test_yaffs_unlink_EISDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_unlink_EISDIR(void); 22 | int test_yaffs_unlink_EISDIR_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unlink_ELOOP_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unlink_ELOOP_dir_h__ 16 | #define __test_yaffs_unlink_ELOOP_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_unlink_ELOOP_dir(void); 22 | int test_yaffs_unlink_ELOOP_dir_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unlink_ENAMETOOLONG.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unlink_ENAMETOOLONG_h__ 16 | #define __test_yaffs_unlink_ENAMETOOLONG_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_unlink_ENAMETOOLONG(void); 22 | int test_yaffs_unlink_ENAMETOOLONG_clean(void); 23 | #endif 24 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unlink_ENOENT.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unlink_ENOENT_h__ 16 | #define __test_yaffs_unlink_ENOENT_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_unlink_ENOENT(void); 23 | int test_yaffs_unlink_ENOENT_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unlink_ENOENT2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unlink_ENOENT2_h__ 16 | #define __test_yaffs_unlink_ENOENT2_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_unlink_ENOENT2(void); 22 | int test_yaffs_unlink_ENOENT2_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unlink_ENOTDIR.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unlink_ENOTDIR_h__ 16 | #define __test_yaffs_unlink_ENOTDIR_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_unlink_ENOTDIR(void); 22 | int test_yaffs_unlink_ENOTDIR_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unlink_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unlink_EROFS_dir_h__ 16 | #define __test_yaffs_unlink_EROFS_dir_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_unlink_EROFS(void); 23 | int test_yaffs_unlink_EROFS_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unlink_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unlink_NULL_h__ 16 | #define __test_yaffs_unlink_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_unlink_NULL(void); 23 | int test_yaffs_unlink_NULL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unmount.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | #include "test_yaffs_unmount.h" 14 | 15 | int test_yaffs_unmount(void) 16 | { 17 | return yaffs_unmount(YAFFS_MOUNT_POINT); 18 | } 19 | 20 | int test_yaffs_unmount_clean(void) 21 | { 22 | return test_yaffs_mount(); 23 | } 24 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unmount.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unmount__ 16 | #define __test_yaffs_unmount__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | #include "test_yaffs_mount.h" 21 | 22 | int test_yaffs_unmount(void); 23 | int test_yaffs_unmount_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unmount2.c: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another FFS. A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU General Public License version 2 as 10 | * published by the Free Software Foundation. 11 | */ 12 | 13 | #include "test_yaffs_unmount2.h" 14 | 15 | int test_yaffs_unmount2(void) 16 | { 17 | int output = -1; 18 | 19 | output = yaffs_unmount2(YAFFS_MOUNT_POINT,1); 20 | return output; 21 | } 22 | 23 | int test_yaffs_unmount2_clean(void) 24 | { 25 | return test_yaffs_mount(); 26 | } 27 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unmount2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unmount2__ 16 | #define __test_yaffs_unmount2__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | #include "test_yaffs_mount.h" 21 | 22 | int test_yaffs_unmount2(void); 23 | int test_yaffs_unmount2_clean(void); 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unmount2_EINVAL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unmount2_EINVAL__ 16 | #define __test_yaffs_unmount2_EINVAL__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | #include "test_yaffs_unmount.h" 21 | 22 | int test_yaffs_unmount2_EINVAL(void); 23 | int test_yaffs_unmount2_EINVAL_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unmount2_ENODEV.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unmount2_ENODEV__ 16 | #define __test_yaffs_unmount2_ENODEV__ 17 | 18 | #include "yaffsfs.h" 19 | #include "lib.h" 20 | #include "test_yaffs_unmount.h" 21 | 22 | int test_yaffs_unmount2_ENODEV(void); 23 | int test_yaffs_unmount2_ENODEV_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unmount_ENODEV.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unmount_ENODEV_h__ 16 | #define __test_yaffs_unmount_ENODEV_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_unmount_ENODEV(void); 22 | int test_yaffs_unmount_ENODEV_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_unmount_NULL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_unmount_NULL_h__ 16 | #define __test_yaffs_unmount_NULL_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | 21 | int test_yaffs_unmount_NULL(void); 22 | int test_yaffs_unmount_NULL_clean(void); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_write.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_write_h__ 16 | #define __test_yaffs_write_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_write(void); 23 | int test_yaffs_write_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_write_EBADF.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_write_EBADF_h__ 16 | #define __test_yaffs_write_EBADF_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_write_EBADF(void); 23 | int test_yaffs_write_EBADF_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/unit_tests/quick_tests/test_yaffs_write_EROFS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Timothy Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __test_yaffs_write_EROFS_h__ 16 | #define __test_yaffs_write_EROFS_h__ 17 | 18 | #include "lib.h" 19 | #include "yaffsfs.h" 20 | #include "test_yaffs_open.h" 21 | 22 | int test_yaffs_write_EROFS(void); 23 | int test_yaffs_write_EROFS_clean(void); 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /direct/test-framework/yaffs_fileem2k.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __FILEEM2K_H__ 16 | #define __FILEEM2K_H__ 17 | 18 | 19 | struct yaffs_dev; 20 | 21 | struct yaffs_dev *yflash2_install_drv(const char *name); 22 | 23 | 24 | #endif 25 | 26 | -------------------------------------------------------------------------------- /direct/test-framework/yaffs_m18_drv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | 16 | #ifndef __YAFFS_M18_DRV_H__ 17 | #define __YAFFS_M18_DRV_H__ 18 | 19 | struct yaffs_dev; 20 | struct yaffs_dev *yaffs_m18_install_drv(const char *name); 21 | 22 | #endif 23 | 24 | 25 | -------------------------------------------------------------------------------- /direct/test-framework/yaffs_nand_drv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __YAFFS_NAND_DRV_H__ 16 | #define __YAFFS_NAND_DRV_H__ 17 | 18 | #include "yaffs_guts.h" 19 | #include "nand_chip.h" 20 | 21 | int yaffs_nand_install_drv(struct yaffs_dev *dev, struct nand_chip *chip); 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /direct/test-framework/yaffs_nandsim_file.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __YAFFS_NANDSIM_FILE_H__ 16 | #define __YAFFS_NANDSIM_FILE_H__ 17 | 18 | struct yaffs_dev; 19 | 20 | struct yaffs_dev *yaffs_nandsim_install_drv(const char *dev_name, 21 | const char *backing_file_name, 22 | int n_blocks, 23 | int n_caches, 24 | int inband_tags); 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /direct/test-framework/yaffs_nor_drv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | 16 | #ifndef __YAFFS_NOR_DRV_H__ 17 | #define __YAFFS_NOR_DRV_H__ 18 | 19 | struct yaffs_dev; 20 | struct yaffs_dev *yaffs_nor_install_drv(const char *name); 21 | 22 | #endif 23 | 24 | 25 | -------------------------------------------------------------------------------- /direct/u-boot/fs/yaffs2/stdio.h: -------------------------------------------------------------------------------- 1 | /* Dummy header for u-boot */ 2 | -------------------------------------------------------------------------------- /direct/u-boot/fs/yaffs2/stdlib.h: -------------------------------------------------------------------------------- 1 | /* Dummy header for u-boot */ 2 | -------------------------------------------------------------------------------- /direct/u-boot/fs/yaffs2/string.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | 7 | -------------------------------------------------------------------------------- /direct/yaffs_hweight.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __YAFFS_HWEIGHT_H__ 16 | #define __YAFFS_HWEIGHT_H__ 17 | 18 | #include "yportenv.h" 19 | 20 | int yaffs_hweight8(u8 x); 21 | int yaffs_hweight32(u32 x); 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /linux/Kconfig_single: -------------------------------------------------------------------------------- 1 | # 2 | # yaffs file system configurations 3 | # 4 | 5 | config YAFFS_FS 6 | tristate "yaffs2 file system support" 7 | default n 8 | depends on MTD_BLOCK 9 | select YAFFS_YAFFS1 10 | select YAFFS_YAFFS2 11 | help 12 | yaffs2, or Yet Another Flash File System, is a file system 13 | optimised for NAND Flash chips. 14 | 15 | To compile the yaffs2 file system support as a module, choose M 16 | here: the module will be called yaffs2. 17 | 18 | If unsure, say N. 19 | 20 | Further information on yaffs2 is available at 21 | . 22 | 23 | config YAFFS_DEBUG 24 | bool "Enable yaffs debugging" 25 | depends on YAFFS_FS 26 | default n 27 | help 28 | Enable the yaffs debugging tracing. 29 | 30 | If unsure, say N. 31 | -------------------------------------------------------------------------------- /linux/Makefile.kernel: -------------------------------------------------------------------------------- 1 | # 2 | # Makefile for the linux YAFFS filesystem routines. 3 | # 4 | 5 | obj-$(CONFIG_YAFFS_FS) += yaffs.o 6 | 7 | yaffs-y := yaffs_ecc.o yaffs_vfs.o yaffs_guts.o yaffs_checkptrw.o 8 | yaffs-y += yaffs_packedtags1.o yaffs_packedtags2.o yaffs_nand.o 9 | yaffs-y += yaffs_tagscompat.o yaffs_tagsmarshall.o 10 | yaffs-y += yaffs_endian.o 11 | yaffs-y += yaffs_mtdif.o 12 | yaffs-y += yaffs_nameval.o yaffs_attribs.o 13 | yaffs-y += yaffs_allocator.o 14 | yaffs-y += yaffs_yaffs1.o 15 | yaffs-y += yaffs_yaffs2.o 16 | yaffs-y += yaffs_bitmap.o 17 | yaffs-y += yaffs_summary.o 18 | yaffs-y += yaffs_verify.o 19 | yaffs-y += yaffs_cache.o 20 | 21 | -------------------------------------------------------------------------------- /linux/linux-tests/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS += -Wall -D_FILE_OFFSET_BITS=64 2 | 3 | TARGETS = xattrtest writebigsparse verifybigsparse 4 | all: $(TARGETS) 5 | 6 | xattrtest: xattrtest.c 7 | gcc $(CFLAGS) -o $@ $< 8 | 9 | writebigsparse: writebigsparse.c 10 | gcc $(CFLAGS) -o $@ $< 11 | 12 | verifybigsparse: verifybigsparse.c 13 | gcc $(CFLAGS) -o $@ $< 14 | 15 | 16 | .PHONEY: clean 17 | clean: 18 | rm -f $(TARGETS) 19 | -------------------------------------------------------------------------------- /linux/linux-tests/mkdirtree: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | TREE_BASE=/mnt/dirtree 4 | 5 | for (( d=0; d<50; d++ )) 6 | do 7 | mkdir -p $TREE_BASE/dir$d 8 | 9 | for (( f=0; f<50; f++ )) 10 | do 11 | ls > $TREE_BASE/dir$d/file$f 12 | done 13 | done 14 | 15 | 16 | echo "Foo bar file" > $TREE_BASE/foo_file 17 | 18 | ln $TREE_BASE/foo_file $TREE_BASE/../foo_link 19 | 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /linux/linux-tests/mkfiles: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | TREE_BASE=/mnt/dirtree 4 | 5 | for (( f=0; f<500; f++ )) 6 | do 7 | for (( d=0; d<10; d++ )) 8 | do 9 | mkdir -p $TREE_BASE/dir$d 10 | dd bs=1024 count=5 if=/dev/zero of=$TREE_BASE/dir$d/file$f 11 | done 12 | done 13 | 14 | 15 | echo "Foo bar file" > $TREE_BASE/foo_file 16 | 17 | ln $TREE_BASE/foo_file $TREE_BASE/../foo_link 18 | 19 | 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /linux/linux-tests/write_test.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | TESTDIR=/mnt 4 | 5 | echo "start" 6 | echo " " 7 | cat /proc/yaffs 8 | 9 | for(( i=0; i < 32; i++ )); do 10 | dd of=$TESTDIR/$i if=/dev/urandom bs=1024 count=1024 11 | done 12 | 13 | echo "32 x 1MB written" 14 | cat /proc/yaffs 15 | for(( i=0; i < 32; i++ )); do 16 | dd of=$TESTDIR/xx if=/dev/urandom bs=1024 count=1024 17 | done 18 | 19 | echo "32 x 1MB overwites" 20 | cat /proc/yaffs 21 | 22 | 23 | -------------------------------------------------------------------------------- /linux/moduleconfig.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Martin Fouts 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __YAFFS_CONFIG_H__ 16 | #define __YAFFS_CONFIG_H__ 17 | 18 | #ifdef YAFFS_OUT_OF_TREE 19 | 20 | #define CONFIG_YAFFS_FS 21 | #define CONFIG_YAFFS_DEBUG 22 | 23 | #endif 24 | 25 | #endif 26 | 27 | -------------------------------------------------------------------------------- /linux/patches/README.txt: -------------------------------------------------------------------------------- 1 | This directory holds patches that are useful for Linux integration. 2 | 3 | Right now there is only one patched file, yaffs_mtdif2.c. This has been 4 | patched with a tweaked version of "Sergey's patch" and typically makes a 5 | stock mtd work properly. 6 | 7 | -------------------------------------------------------------------------------- /linux/yaffs_mtdif.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Charles Manning 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifndef __YAFFS_MTDIF_H__ 16 | #define __YAFFS_MTDIF_H__ 17 | 18 | #include "yaffs_guts.h" 19 | 20 | void yaffs_mtd_drv_install(struct yaffs_dev *dev); 21 | void yaffs_put_mtd_device(struct mtd_info *mtd); 22 | int yaffs_verify_mtd(struct mtd_info *mtd, int yaffs_version, int inband_tags); 23 | #endif 24 | -------------------------------------------------------------------------------- /linux/yportenv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 | * 4 | * Copyright (C) 2002-2018 Aleph One Ltd. 5 | * 6 | * Created by Waldemar Rymarkiewicz 7 | * 8 | * This program is free software; you can redistribute it and/or modify 9 | * it under the terms of the GNU Lesser General Public License version 2.1 as 10 | * published by the Free Software Foundation. 11 | * 12 | * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 13 | */ 14 | 15 | #ifdef YAFFS_CURRENT 16 | #include "yportenv_single.h" 17 | #else 18 | #include "yportenv_multi.h" 19 | #endif 20 | -------------------------------------------------------------------------------- /rtems/rtems-y-test/basic-test/README: -------------------------------------------------------------------------------- 1 | The basic tests test common fs operations such as open, close, read, write etc. 2 | 3 | Multiple files and directories are opened, created, read, deleted, truncated etc. 4 | 5 | -------------------------------------------------------------------------------- /rtems/rtems-y-test/common/yaffs-rtems-flashsim.h: -------------------------------------------------------------------------------- 1 | #ifndef __YAFFS_FLASH_SIM_H__ 2 | #define __YAFFS_FLASH_SIM_H__ 3 | 4 | struct yaffs_dev; 5 | 6 | struct yaffs_dev *yaffs_rtems_flashsim_setup(void); 7 | 8 | void yaffs_rtems_flashsim_dump_status(void); 9 | 10 | #endif 11 | 12 | --------------------------------------------------------------------------------