Daiki Kato / sd-driver-hs

High-speed access version sd-driver.

Dependents:   SDBlockDevice_GR_PEACH SDBlockDevice_GR_PEACH HagridOS5

This library has modified SDBlockDevice.h based on revision "14: c7dba87" of sd-driver.
https://github.com/ARMmbed/sd-driver

features/TESTS/filesystem/basic/basic.cpp@0:b22a1df967cb, 2017-03-23 (annotated)

Committer:
dkato
Date:
Thu Mar 23 08:25:54 2017 +0000
Revision:
0:b22a1df967cb
Initial commit

Who changed what in which revision?

UserRevisionLine numberNew contents of line
dkato 0:b22a1df967cb 1 /*
dkato 0:b22a1df967cb 2 * mbed Microcontroller Library
dkato 0:b22a1df967cb 3 * Copyright (c) 2006-2016 ARM Limited
dkato 0:b22a1df967cb 4 *
dkato 0:b22a1df967cb 5 * Licensed under the Apache License, Version 2.0 (the "License");
dkato 0:b22a1df967cb 6 * you may not use this file except in compliance with the License.
dkato 0:b22a1df967cb 7 * You may obtain a copy of the License at
dkato 0:b22a1df967cb 8 *
dkato 0:b22a1df967cb 9 * http://www.apache.org/licenses/LICENSE-2.0
dkato 0:b22a1df967cb 10 *
dkato 0:b22a1df967cb 11 * Unless required by applicable law or agreed to in writing, software
dkato 0:b22a1df967cb 12 * distributed under the License is distributed on an "AS IS" BASIS,
dkato 0:b22a1df967cb 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
dkato 0:b22a1df967cb 14 * See the License for the specific language governing permissions and
dkato 0:b22a1df967cb 15 * limitations under the License.
dkato 0:b22a1df967cb 16 *
dkato 0:b22a1df967cb 17 */
dkato 0:b22a1df967cb 18
dkato 0:b22a1df967cb 19 /* The following copyright notice is reproduced from the glibc project
dkato 0:b22a1df967cb 20 * REF_LICENCE_GLIBC
dkato 0:b22a1df967cb 21 *
dkato 0:b22a1df967cb 22 * Copyright (C) 1991, 1992 Free Software Foundation, Inc.
dkato 0:b22a1df967cb 23 * This file is part of the GNU C Library.
dkato 0:b22a1df967cb 24 *
dkato 0:b22a1df967cb 25 * The GNU C Library is free software; you can redistribute it and/or
dkato 0:b22a1df967cb 26 * modify it under the terms of the GNU Library General Public License as
dkato 0:b22a1df967cb 27 * published by the Free Software Foundation; either version 2 of the
dkato 0:b22a1df967cb 28 * License, or (at your option) any later version.
dkato 0:b22a1df967cb 29 *
dkato 0:b22a1df967cb 30 * The GNU C Library is distributed in the hope that it will be useful,
dkato 0:b22a1df967cb 31 * but WITHOUT ANY WARRANTY; without even the implied warranty of
dkato 0:b22a1df967cb 32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
dkato 0:b22a1df967cb 33 * Library General Public License for more details.
dkato 0:b22a1df967cb 34 *
dkato 0:b22a1df967cb 35 * You should have received a copy of the GNU Library General Public
dkato 0:b22a1df967cb 36 * License along with the GNU C Library; see the file COPYING.LIB. If
dkato 0:b22a1df967cb 37 * not, write to the Free Software Foundation, Inc., 675 Mass Ave,
dkato 0:b22a1df967cb 38 * Cambridge, MA 02139, USA.
dkato 0:b22a1df967cb 39 */
dkato 0:b22a1df967cb 40
dkato 0:b22a1df967cb 41
dkato 0:b22a1df967cb 42 /** @file basic.cpp POSIX File API (stdio) test cases
dkato 0:b22a1df967cb 43 *
dkato 0:b22a1df967cb 44 * Consult the documentation under the test-case functions for
dkato 0:b22a1df967cb 45 * a description of the individual test case.
dkato 0:b22a1df967cb 46 *
dkato 0:b22a1df967cb 47 * this file includes ports for the mbed 2 test cases from the following locations:
dkato 0:b22a1df967cb 48 * - https://github.com:/armmbed/mbed-os/features/unsupported/tests/mbed/dir_sd/main.cpp.
dkato 0:b22a1df967cb 49 * - https://github.com:/armmbed/mbed-os/features/unsupported/tests/mbed/file/main.cpp.
dkato 0:b22a1df967cb 50 * - https://github.com:/armmbed/mbed-os/features/unsupported/tests/mbed/sd/main.cpp
dkato 0:b22a1df967cb 51 * - https://github.com:/armmbed/mbed-os/features/unsupported/tests/mbed/sd_perf_handle/main.cpp
dkato 0:b22a1df967cb 52 * - https://github.com:/armmbed/mbed-os/features/unsupported/tests/mbed/sd_perf_stdio/main.cpp.
dkato 0:b22a1df967cb 53 */
dkato 0:b22a1df967cb 54
dkato 0:b22a1df967cb 55 #include "mbed.h"
dkato 0:b22a1df967cb 56 #include "mbed_config.h"
dkato 0:b22a1df967cb 57 #include "FATFileSystem.h"
dkato 0:b22a1df967cb 58 #include "SDBlockDevice.h"
dkato 0:b22a1df967cb 59 #include "test_env.h"
dkato 0:b22a1df967cb 60 #include "fsfat_debug.h"
dkato 0:b22a1df967cb 61 #include "fsfat_test.h"
dkato 0:b22a1df967cb 62 #include "utest/utest.h"
dkato 0:b22a1df967cb 63 #include "unity/unity.h"
dkato 0:b22a1df967cb 64 #include "greentea-client/test_env.h"
dkato 0:b22a1df967cb 65
dkato 0:b22a1df967cb 66 #include <stdio.h>
dkato 0:b22a1df967cb 67 #include <stdlib.h>
dkato 0:b22a1df967cb 68 #include <string.h>
dkato 0:b22a1df967cb 69 #include <errno.h>
dkato 0:b22a1df967cb 70 #include <algorithm>
dkato 0:b22a1df967cb 71 /* retarget.h is included after errno.h so symbols are mapped to
dkato 0:b22a1df967cb 72 * consistent values for all toolchains */
dkato 0:b22a1df967cb 73 #include "platform/mbed_retarget.h"
dkato 0:b22a1df967cb 74
dkato 0:b22a1df967cb 75 using namespace utest::v1;
dkato 0:b22a1df967cb 76
dkato 0:b22a1df967cb 77 /* DEVICE_SPI
dkato 0:b22a1df967cb 78 * This symbol is defined in targets.json if the target has a SPI interface, which is required for SDCard support.
dkato 0:b22a1df967cb 79 *
dkato 0:b22a1df967cb 80 * MBED_CONF_APP_FSFAT_SDCARD_INSTALLED
dkato 0:b22a1df967cb 81 * For testing purposes, an SDCard must be installed on the target for the test cases in this file to succeed.
dkato 0:b22a1df967cb 82 * If the target has an SD card installed then the MBED_CONF_APP_FSFAT_SDCARD_INSTALLED will be generated
dkato 0:b22a1df967cb 83 * from the mbed_app.json, which includes the line
dkato 0:b22a1df967cb 84 * {
dkato 0:b22a1df967cb 85 * "config": {
dkato 0:b22a1df967cb 86 * "UART_RX": "D0",
dkato 0:b22a1df967cb 87 * <<< lines removed >>>
dkato 0:b22a1df967cb 88 * "DEVICE_SPI": 1,
dkato 0:b22a1df967cb 89 * "MBED_CONF_APP_FSFAT_SDCARD_INSTALLED": 1
dkato 0:b22a1df967cb 90 * },
dkato 0:b22a1df967cb 91 * <<< lines removed >>>
dkato 0:b22a1df967cb 92 */
dkato 0:b22a1df967cb 93 #if defined(DEVICE_SPI) && defined(MBED_CONF_APP_FSFAT_SDCARD_INSTALLED)
dkato 0:b22a1df967cb 94
dkato 0:b22a1df967cb 95 #define FSFAT_BASIC_TEST_00 fsfat_basic_test_00
dkato 0:b22a1df967cb 96 #define FSFAT_BASIC_TEST_01 fsfat_basic_test_01
dkato 0:b22a1df967cb 97 #define FSFAT_BASIC_TEST_02 fsfat_basic_test_02
dkato 0:b22a1df967cb 98 #define FSFAT_BASIC_TEST_03 fsfat_basic_test_03
dkato 0:b22a1df967cb 99 #define FSFAT_BASIC_TEST_04 fsfat_basic_test_04
dkato 0:b22a1df967cb 100 #define FSFAT_BASIC_TEST_05 fsfat_basic_test_05
dkato 0:b22a1df967cb 101 #define FSFAT_BASIC_TEST_06 fsfat_basic_test_06
dkato 0:b22a1df967cb 102 #define FSFAT_BASIC_TEST_07 fsfat_basic_test_07
dkato 0:b22a1df967cb 103 #define FSFAT_BASIC_TEST_08 fsfat_basic_test_08
dkato 0:b22a1df967cb 104 #define FSFAT_BASIC_TEST_09 fsfat_basic_test_09
dkato 0:b22a1df967cb 105 #define FSFAT_BASIC_TEST_10 fsfat_basic_test_10
dkato 0:b22a1df967cb 106
dkato 0:b22a1df967cb 107 #define FSFAT_BASIC_MSG_BUF_SIZE 256
dkato 0:b22a1df967cb 108 #define FSFAT_BASIC_TEST_05_TEST_STRING "Hello World!"
dkato 0:b22a1df967cb 109
dkato 0:b22a1df967cb 110 static const char *sd_file_path = "/sd/out.txt";
dkato 0:b22a1df967cb 111 static const char *sd_mount_pt = "sd";
dkato 0:b22a1df967cb 112 static const int FSFAT_BASIC_DATA_SIZE = 256;
dkato 0:b22a1df967cb 113 static char fsfat_basic_msg_g[FSFAT_BASIC_MSG_BUF_SIZE];
dkato 0:b22a1df967cb 114 static char fsfat_basic_buffer[1024];
dkato 0:b22a1df967cb 115 static const int FSFAT_BASIC_KIB_RW = 128;
dkato 0:b22a1df967cb 116 static Timer fsfat_basic_timer;
dkato 0:b22a1df967cb 117 static const char *fsfat_basic_bin_filename = "/sd/testfile.bin";
dkato 0:b22a1df967cb 118 static const char *fsfat_basic_bin_filename_test_08 = "testfile.bin";
dkato 0:b22a1df967cb 119 static const char *fsfat_basic_bin_filename_test_10 = "0:testfile.bin";
dkato 0:b22a1df967cb 120
dkato 0:b22a1df967cb 121
dkato 0:b22a1df967cb 122
dkato 0:b22a1df967cb 123 SDBlockDevice sd(MBED_CONF_APP_SPI_MOSI, MBED_CONF_APP_SPI_MISO, MBED_CONF_APP_SPI_CLK, MBED_CONF_APP_SPI_CS);
dkato 0:b22a1df967cb 124 FATFileSystem fs(sd_mount_pt, &sd);
dkato 0:b22a1df967cb 125
dkato 0:b22a1df967cb 126 #define FSFAT_BASIC_MSG(_buf, _max_len, _fmt, ...) \
dkato 0:b22a1df967cb 127 do \
dkato 0:b22a1df967cb 128 { \
dkato 0:b22a1df967cb 129 snprintf((_buf), (_max_len), (_fmt), __VA_ARGS__); \
dkato 0:b22a1df967cb 130 }while(0);
dkato 0:b22a1df967cb 131
dkato 0:b22a1df967cb 132 /** @brief fopen test case
dkato 0:b22a1df967cb 133 *
dkato 0:b22a1df967cb 134 * - open a file
dkato 0:b22a1df967cb 135 * - generate random data items, write the item to the file and store a coy in a buffer for later use.
dkato 0:b22a1df967cb 136 * - close the file.
dkato 0:b22a1df967cb 137 * - open the file.
dkato 0:b22a1df967cb 138 * - read the data items from the file and check they are the same as write.
dkato 0:b22a1df967cb 139 * - close the file.
dkato 0:b22a1df967cb 140 *
dkato 0:b22a1df967cb 141 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 142 */
dkato 0:b22a1df967cb 143 static control_t fsfat_basic_test_00()
dkato 0:b22a1df967cb 144 {
dkato 0:b22a1df967cb 145
dkato 0:b22a1df967cb 146 uint8_t data_written[FSFAT_BASIC_DATA_SIZE] = { 0 };
dkato 0:b22a1df967cb 147 bool read_result = false;
dkato 0:b22a1df967cb 148 bool write_result = false;
dkato 0:b22a1df967cb 149
dkato 0:b22a1df967cb 150 // Fill data_written buffer with random data
dkato 0:b22a1df967cb 151 // Write these data into the file
dkato 0:b22a1df967cb 152 FSFAT_FENTRYLOG("%s:entered\n", __func__);
dkato 0:b22a1df967cb 153 {
dkato 0:b22a1df967cb 154 FSFAT_DBGLOG("%s:SD: Writing ... ", __func__);
dkato 0:b22a1df967cb 155 FILE *f = fopen(sd_file_path, "w");
dkato 0:b22a1df967cb 156 if (f) {
dkato 0:b22a1df967cb 157 for (int i = 0; i < FSFAT_BASIC_DATA_SIZE; i++) {
dkato 0:b22a1df967cb 158 data_written[i] = rand() % 0XFF;
dkato 0:b22a1df967cb 159 fprintf(f, "%c", data_written[i]);
dkato 0:b22a1df967cb 160 }
dkato 0:b22a1df967cb 161 write_result = true;
dkato 0:b22a1df967cb 162 fclose(f);
dkato 0:b22a1df967cb 163 }
dkato 0:b22a1df967cb 164 FSFAT_DBGLOG("[%s]\n", write_result ? "OK" : "FAIL");
dkato 0:b22a1df967cb 165 }
dkato 0:b22a1df967cb 166 TEST_ASSERT_MESSAGE(write_result == true, "Error: write_result is set to false.");
dkato 0:b22a1df967cb 167
dkato 0:b22a1df967cb 168 // Read back the data from the file and store them in data_read
dkato 0:b22a1df967cb 169 {
dkato 0:b22a1df967cb 170 FSFAT_DBGLOG("%s:SD: Reading data ... ", __func__);
dkato 0:b22a1df967cb 171 FILE *f = fopen(sd_file_path, "r");
dkato 0:b22a1df967cb 172 if (f) {
dkato 0:b22a1df967cb 173 read_result = true;
dkato 0:b22a1df967cb 174 for (int i = 0; i < FSFAT_BASIC_DATA_SIZE; i++) {
dkato 0:b22a1df967cb 175 uint8_t data = fgetc(f);
dkato 0:b22a1df967cb 176 if (data != data_written[i]) {
dkato 0:b22a1df967cb 177 read_result = false;
dkato 0:b22a1df967cb 178 break;
dkato 0:b22a1df967cb 179 }
dkato 0:b22a1df967cb 180 }
dkato 0:b22a1df967cb 181 fclose(f);
dkato 0:b22a1df967cb 182 }
dkato 0:b22a1df967cb 183 FSFAT_DBGLOG("[%s]\n", read_result ? "OK" : "FAIL");
dkato 0:b22a1df967cb 184 }
dkato 0:b22a1df967cb 185 TEST_ASSERT_MESSAGE(read_result == true, "Error: read_result is set to false.");
dkato 0:b22a1df967cb 186 return CaseNext;
dkato 0:b22a1df967cb 187 }
dkato 0:b22a1df967cb 188
dkato 0:b22a1df967cb 189
dkato 0:b22a1df967cb 190 /** @brief test-fseek.c test ported from glibc project. See the licence at REF_LICENCE_GLIBC.
dkato 0:b22a1df967cb 191 *
dkato 0:b22a1df967cb 192 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 193 */
dkato 0:b22a1df967cb 194 static control_t fsfat_basic_test_01()
dkato 0:b22a1df967cb 195 {
dkato 0:b22a1df967cb 196 FILE *fp, *fp1;
dkato 0:b22a1df967cb 197 int i, j;
dkato 0:b22a1df967cb 198 int ret = 0;
dkato 0:b22a1df967cb 199
dkato 0:b22a1df967cb 200 FSFAT_FENTRYLOG("%s:entered\n", __func__);
dkato 0:b22a1df967cb 201 fp = fopen (sd_file_path, "w+");
dkato 0:b22a1df967cb 202 if (fp == NULL) {
dkato 0:b22a1df967cb 203 FSFAT_DBGLOG("errno=%d\n", errno);
dkato 0:b22a1df967cb 204 TEST_ASSERT_MESSAGE(false, "error");
dkato 0:b22a1df967cb 205 return CaseNext;
dkato 0:b22a1df967cb 206 }
dkato 0:b22a1df967cb 207
dkato 0:b22a1df967cb 208 for (i = 0; i < 256; i++) {
dkato 0:b22a1df967cb 209 putc (i, fp);
dkato 0:b22a1df967cb 210 }
dkato 0:b22a1df967cb 211 /* FIXME: freopen() should open the specified file closing the first stream. As can be seen from the
dkato 0:b22a1df967cb 212 * code below, the old file descriptor fp can still be used, and this should not happen.
dkato 0:b22a1df967cb 213 */
dkato 0:b22a1df967cb 214 fp1 = freopen (sd_file_path, "r", fp);
dkato 0:b22a1df967cb 215 TEST_ASSERT_MESSAGE(fp1 == fp, "Error: cannot open file for reading");
dkato 0:b22a1df967cb 216
dkato 0:b22a1df967cb 217 for (i = 1; i <= 255; i++) {
dkato 0:b22a1df967cb 218 ret = fseek (fp, (long) -i, SEEK_END);
dkato 0:b22a1df967cb 219 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s:Error: fseek() failed (ret=%d).\n", __func__, (int) ret);
dkato 0:b22a1df967cb 220 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 221
dkato 0:b22a1df967cb 222 if ((j = getc (fp)) != 256 - i) {
dkato 0:b22a1df967cb 223 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: SEEK_END failed (j=%d)\n", __func__, j);
dkato 0:b22a1df967cb 224 TEST_ASSERT_MESSAGE(false, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 225 }
dkato 0:b22a1df967cb 226 ret = fseek (fp, (long) i, SEEK_SET);
dkato 0:b22a1df967cb 227 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: Cannot SEEK_SET (ret=%d).\n", __func__, (int) ret);
dkato 0:b22a1df967cb 228 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 229
dkato 0:b22a1df967cb 230 if ((j = getc (fp)) != i) {
dkato 0:b22a1df967cb 231 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: Cannot SEEK_SET (j=%d).\n", __func__, j);
dkato 0:b22a1df967cb 232 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 233 }
dkato 0:b22a1df967cb 234 if ((ret = fseek (fp, (long) i, SEEK_SET))) {
dkato 0:b22a1df967cb 235 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: Cannot SEEK_SET (ret=%d).\n", __func__, (int) ret);
dkato 0:b22a1df967cb 236 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 237 }
dkato 0:b22a1df967cb 238 if ((ret = fseek (fp, (long) (i >= 128 ? -128 : 128), SEEK_CUR))) {
dkato 0:b22a1df967cb 239 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: Cannot SEEK_CUR (ret=%d).\n", __func__, (int) ret);
dkato 0:b22a1df967cb 240 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 241 }
dkato 0:b22a1df967cb 242 if ((j = getc (fp)) != (i >= 128 ? i - 128 : i + 128)) {
dkato 0:b22a1df967cb 243 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: Cannot SEEK_CUR (j=%d).\n", __func__, j);
dkato 0:b22a1df967cb 244 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 245 }
dkato 0:b22a1df967cb 246 }
dkato 0:b22a1df967cb 247 fclose (fp);
dkato 0:b22a1df967cb 248 remove(sd_file_path);
dkato 0:b22a1df967cb 249 return CaseNext;
dkato 0:b22a1df967cb 250 }
dkato 0:b22a1df967cb 251
dkato 0:b22a1df967cb 252
dkato 0:b22a1df967cb 253 /** @brief test_rdwr.c test ported from glibc project. See the licence at REF_LICENCE_GLIBC.
dkato 0:b22a1df967cb 254 *
dkato 0:b22a1df967cb 255 * WARNING: this test does not currently work. See WARNING comments below.
dkato 0:b22a1df967cb 256 *
dkato 0:b22a1df967cb 257 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 258 */
dkato 0:b22a1df967cb 259 static control_t fsfat_basic_test_02()
dkato 0:b22a1df967cb 260 {
dkato 0:b22a1df967cb 261 static const char hello[] = "Hello, world.\n";
dkato 0:b22a1df967cb 262 static const char replace[] = "Hewwo, world.\n";
dkato 0:b22a1df967cb 263 static const size_t replace_from = 2, replace_to = 4;
dkato 0:b22a1df967cb 264 const char *filename = sd_file_path;
dkato 0:b22a1df967cb 265 char buf[BUFSIZ];
dkato 0:b22a1df967cb 266 FILE *f;
dkato 0:b22a1df967cb 267 int lose = 0;
dkato 0:b22a1df967cb 268 int32_t ret = 0;
dkato 0:b22a1df967cb 269 char *rets = NULL;
dkato 0:b22a1df967cb 270
dkato 0:b22a1df967cb 271 FSFAT_FENTRYLOG("%s:entered\n", __func__);
dkato 0:b22a1df967cb 272 f = fopen(filename, "w+");
dkato 0:b22a1df967cb 273 if (f == NULL) {
dkato 0:b22a1df967cb 274 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: Cannot open file for writing (filename=%s).\n", __func__, filename);
dkato 0:b22a1df967cb 275 TEST_ASSERT_MESSAGE(false, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 276 }
dkato 0:b22a1df967cb 277
dkato 0:b22a1df967cb 278 ret = fputs(hello, f);
dkato 0:b22a1df967cb 279 if (ret == EOF) {
dkato 0:b22a1df967cb 280 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fputs() failed to write string to file (filename=%s, string=%s).\n", __func__, filename, hello);
dkato 0:b22a1df967cb 281 TEST_ASSERT_MESSAGE(false, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 282 }
dkato 0:b22a1df967cb 283
dkato 0:b22a1df967cb 284 rewind(f);
dkato 0:b22a1df967cb 285 rets = fgets(buf, sizeof(buf), f);
dkato 0:b22a1df967cb 286 if (rets == NULL) {
dkato 0:b22a1df967cb 287 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fgets() failed to get string from file (filename=%s).\n", __func__, filename);
dkato 0:b22a1df967cb 288 TEST_ASSERT_MESSAGE(false, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 289 }
dkato 0:b22a1df967cb 290 rets = NULL;
dkato 0:b22a1df967cb 291
dkato 0:b22a1df967cb 292 rewind(f);
dkato 0:b22a1df967cb 293 ret = fputs(buf, f);
dkato 0:b22a1df967cb 294 if (ret == EOF) {
dkato 0:b22a1df967cb 295 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fputs() failed to write string to file (filename=%s, string=%s).\n", __func__, filename, buf);
dkato 0:b22a1df967cb 296 TEST_ASSERT_MESSAGE(false, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 297 }
dkato 0:b22a1df967cb 298
dkato 0:b22a1df967cb 299 rewind(f);
dkato 0:b22a1df967cb 300 {
dkato 0:b22a1df967cb 301 register size_t i;
dkato 0:b22a1df967cb 302 for (i = 0; i < replace_from; ++i)
dkato 0:b22a1df967cb 303 {
dkato 0:b22a1df967cb 304 int c = getc(f);
dkato 0:b22a1df967cb 305 if (c == EOF)
dkato 0:b22a1df967cb 306 {
dkato 0:b22a1df967cb 307 FSFAT_DBGLOG("EOF at %u.\n", i);
dkato 0:b22a1df967cb 308 lose = 1;
dkato 0:b22a1df967cb 309 break;
dkato 0:b22a1df967cb 310 }
dkato 0:b22a1df967cb 311 else if (c != hello[i])
dkato 0:b22a1df967cb 312 {
dkato 0:b22a1df967cb 313 FSFAT_DBGLOG("Got '%c' instead of '%c' at %u.\n",
dkato 0:b22a1df967cb 314 (unsigned char) c, hello[i], i);
dkato 0:b22a1df967cb 315 lose = 1;
dkato 0:b22a1df967cb 316 break;
dkato 0:b22a1df967cb 317 }
dkato 0:b22a1df967cb 318 }
dkato 0:b22a1df967cb 319 }
dkato 0:b22a1df967cb 320 /* WARNING: printf("%s: here1. (lose = %d)\n", __func__, lose); */
dkato 0:b22a1df967cb 321 {
dkato 0:b22a1df967cb 322 long int where = ftell(f);
dkato 0:b22a1df967cb 323 if (where == replace_from)
dkato 0:b22a1df967cb 324 {
dkato 0:b22a1df967cb 325 register size_t i;
dkato 0:b22a1df967cb 326 for (i = replace_from; i < replace_to; ++i) {
dkato 0:b22a1df967cb 327 if (putc(replace[i], f) == EOF) {
dkato 0:b22a1df967cb 328 FSFAT_DBGLOG("putc('%c') got %s at %u.\n",
dkato 0:b22a1df967cb 329 replace[i], strerror(errno), i);
dkato 0:b22a1df967cb 330 lose = 1;
dkato 0:b22a1df967cb 331 break;
dkato 0:b22a1df967cb 332 }
dkato 0:b22a1df967cb 333 /* WARNING: The problem seems to be that putc() is not writing the 'w' chars into the file
dkato 0:b22a1df967cb 334 * FSFAT_DBGLOG("%s: here1.5. (char = %c, char as int=%d, ret=%d) \n", __func__, replace[i], (int) replace[i], ret);
dkato 0:b22a1df967cb 335 */
dkato 0:b22a1df967cb 336 }
dkato 0:b22a1df967cb 337 }
dkato 0:b22a1df967cb 338 else if (where == -1L)
dkato 0:b22a1df967cb 339 {
dkato 0:b22a1df967cb 340 FSFAT_DBGLOG("ftell got %s (should be at %u).\n",
dkato 0:b22a1df967cb 341 strerror(errno), replace_from);
dkato 0:b22a1df967cb 342 lose = 1;
dkato 0:b22a1df967cb 343 }
dkato 0:b22a1df967cb 344 else
dkato 0:b22a1df967cb 345 {
dkato 0:b22a1df967cb 346 FSFAT_DBGLOG("ftell returns %ld; should be %u.\n", where, replace_from);
dkato 0:b22a1df967cb 347 lose = 1;
dkato 0:b22a1df967cb 348 }
dkato 0:b22a1df967cb 349 }
dkato 0:b22a1df967cb 350
dkato 0:b22a1df967cb 351 if (!lose)
dkato 0:b22a1df967cb 352 {
dkato 0:b22a1df967cb 353 rewind(f);
dkato 0:b22a1df967cb 354 memset(buf, 0, BUFSIZ);
dkato 0:b22a1df967cb 355 if (fgets(buf, sizeof(buf), f) == NULL)
dkato 0:b22a1df967cb 356 {
dkato 0:b22a1df967cb 357 FSFAT_DBGLOG("fgets got %s.\n", strerror(errno));
dkato 0:b22a1df967cb 358 lose = 1;
dkato 0:b22a1df967cb 359 }
dkato 0:b22a1df967cb 360 else if (strcmp(buf, replace))
dkato 0:b22a1df967cb 361 {
dkato 0:b22a1df967cb 362 FSFAT_DBGLOG("Read \"%s\" instead of \"%s\".\n", buf, replace);
dkato 0:b22a1df967cb 363 lose = 1;
dkato 0:b22a1df967cb 364 }
dkato 0:b22a1df967cb 365 }
dkato 0:b22a1df967cb 366
dkato 0:b22a1df967cb 367 if (lose) {
dkato 0:b22a1df967cb 368 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: Test Failed. Losing file (filename=%s).\n", __func__, filename);
dkato 0:b22a1df967cb 369 TEST_ASSERT_MESSAGE(false, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 370 }
dkato 0:b22a1df967cb 371 remove(filename);
dkato 0:b22a1df967cb 372 return CaseNext;
dkato 0:b22a1df967cb 373 }
dkato 0:b22a1df967cb 374
dkato 0:b22a1df967cb 375 /** @brief temptest.c test ported from glibc project. See the licence at REF_LICENCE_GLIBC.
dkato 0:b22a1df967cb 376 *
dkato 0:b22a1df967cb 377 * tmpnam() is currently not implemented
dkato 0:b22a1df967cb 378 *
dkato 0:b22a1df967cb 379 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 380 */
dkato 0:b22a1df967cb 381 static control_t fsfat_basic_test_03()
dkato 0:b22a1df967cb 382 {
dkato 0:b22a1df967cb 383 char *fn = NULL;
dkato 0:b22a1df967cb 384
dkato 0:b22a1df967cb 385 FSFAT_FENTRYLOG("%s:entered\n", __func__);
dkato 0:b22a1df967cb 386 fn = tmpnam((char *) NULL);
dkato 0:b22a1df967cb 387 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: appeared to generate a filename when function is not implemented.\n", __func__);
dkato 0:b22a1df967cb 388 TEST_ASSERT_MESSAGE(fn == NULL, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 389 return CaseNext;
dkato 0:b22a1df967cb 390 }
dkato 0:b22a1df967cb 391
dkato 0:b22a1df967cb 392
dkato 0:b22a1df967cb 393 static bool fsfat_basic_fileno_check(const char *name, FILE *stream, int fd)
dkato 0:b22a1df967cb 394 {
dkato 0:b22a1df967cb 395 /* ARMCC stdio.h currently does not define fileno() */
dkato 0:b22a1df967cb 396 #ifndef __ARMCC_VERSION
dkato 0:b22a1df967cb 397 int sfd = fileno (stream);
dkato 0:b22a1df967cb 398 FSFAT_DBGLOG("(fileno (%s) = %d) %c= %d\n", name, sfd, sfd == fd ? '=' : '!', fd);
dkato 0:b22a1df967cb 399
dkato 0:b22a1df967cb 400 if (sfd == fd) {
dkato 0:b22a1df967cb 401 return true;
dkato 0:b22a1df967cb 402 } else {
dkato 0:b22a1df967cb 403 return false;
dkato 0:b22a1df967cb 404 }
dkato 0:b22a1df967cb 405 #else
dkato 0:b22a1df967cb 406 /* For ARMCC behave as though test had passed. */
dkato 0:b22a1df967cb 407 return true;
dkato 0:b22a1df967cb 408 #endif /* __ARMCC_VERSION */
dkato 0:b22a1df967cb 409 }
dkato 0:b22a1df967cb 410
dkato 0:b22a1df967cb 411 /* defines for next test case */
dkato 0:b22a1df967cb 412 #ifndef STDIN_FILENO
dkato 0:b22a1df967cb 413 #define STDIN_FILENO 0
dkato 0:b22a1df967cb 414 #endif
dkato 0:b22a1df967cb 415
dkato 0:b22a1df967cb 416 #ifndef STDOUT_FILENO
dkato 0:b22a1df967cb 417 #define STDOUT_FILENO 1
dkato 0:b22a1df967cb 418 #endif
dkato 0:b22a1df967cb 419
dkato 0:b22a1df967cb 420 #ifndef STDERR_FILENO
dkato 0:b22a1df967cb 421 #define STDERR_FILENO 2
dkato 0:b22a1df967cb 422 #endif
dkato 0:b22a1df967cb 423
dkato 0:b22a1df967cb 424
dkato 0:b22a1df967cb 425 /** @brief tst-fileno.c test ported from glibc project. See the licence at REF_LICENCE_GLIBC.
dkato 0:b22a1df967cb 426 *
dkato 0:b22a1df967cb 427 * WARNING: this test does not currently work. See WARNING comments below.
dkato 0:b22a1df967cb 428 *
dkato 0:b22a1df967cb 429 *
dkato 0:b22a1df967cb 430 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 431 */
dkato 0:b22a1df967cb 432 static control_t fsfat_basic_test_04()
dkato 0:b22a1df967cb 433 {
dkato 0:b22a1df967cb 434 /* ARMCC stdio.h currently does not define fileno() */
dkato 0:b22a1df967cb 435 #ifndef __ARMCC_VERSION
dkato 0:b22a1df967cb 436 int ret = -1;
dkato 0:b22a1df967cb 437 ret = fsfat_basic_fileno_check("stdin", stdin, STDIN_FILENO);
dkato 0:b22a1df967cb 438 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: stdin does not have expected file number (expected=%d, fileno=%d.\n", __func__, stdin, fileno(stdin));
dkato 0:b22a1df967cb 439 TEST_ASSERT_MESSAGE(ret == true, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 440
dkato 0:b22a1df967cb 441 ret = fsfat_basic_fileno_check("stdout", stdout, STDOUT_FILENO);
dkato 0:b22a1df967cb 442 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: stdout does not have expected file number (expected=%d, fileno=%d.\n", __func__, stdout, fileno(stdout));
dkato 0:b22a1df967cb 443 TEST_ASSERT_MESSAGE(ret == true, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 444
dkato 0:b22a1df967cb 445 ret = fsfat_basic_fileno_check("stderr", stderr, STDERR_FILENO);
dkato 0:b22a1df967cb 446 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: stderr does not have expected file number (expected=%d, fileno=%d.\n", __func__, stderr, fileno(stderr));
dkato 0:b22a1df967cb 447 TEST_ASSERT_MESSAGE(ret == true, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 448 #endif /* __ARMCC_VERSION */
dkato 0:b22a1df967cb 449 return CaseNext;
dkato 0:b22a1df967cb 450 }
dkato 0:b22a1df967cb 451
dkato 0:b22a1df967cb 452
dkato 0:b22a1df967cb 453 /** @brief basic test to opendir() on a directory.
dkato 0:b22a1df967cb 454 *
dkato 0:b22a1df967cb 455 * This test has been ported from armmbed/mbed-os/features/unsupported/tests/mbed/dir_sd/main.cpp.
dkato 0:b22a1df967cb 456 *
dkato 0:b22a1df967cb 457 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 458 */
dkato 0:b22a1df967cb 459 static control_t fsfat_basic_test_05()
dkato 0:b22a1df967cb 460 {
dkato 0:b22a1df967cb 461 FILE *f;
dkato 0:b22a1df967cb 462 char *str = FSFAT_BASIC_TEST_05_TEST_STRING;
dkato 0:b22a1df967cb 463 char *buffer = (char *)malloc(sizeof(unsigned char) * strlen(FSFAT_BASIC_TEST_05_TEST_STRING));
dkato 0:b22a1df967cb 464 int str_len = strlen(FSFAT_BASIC_TEST_05_TEST_STRING);
dkato 0:b22a1df967cb 465 int ret = 0;
dkato 0:b22a1df967cb 466
dkato 0:b22a1df967cb 467 FSFAT_DBGLOG("%s:Write files\n", __func__);
dkato 0:b22a1df967cb 468 char filename[32];
dkato 0:b22a1df967cb 469 for (int i = 0; i < 10; i++) {
dkato 0:b22a1df967cb 470 sprintf(filename, "/sd/test_%d.txt", i);
dkato 0:b22a1df967cb 471 FSFAT_DBGLOG("Creating file: %s\n", filename);
dkato 0:b22a1df967cb 472 f = fopen(filename, "w");
dkato 0:b22a1df967cb 473 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fopen() failed.\n", __func__);
dkato 0:b22a1df967cb 474 TEST_ASSERT_MESSAGE(f != NULL, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 475
dkato 0:b22a1df967cb 476 ret = fprintf(f, str);
dkato 0:b22a1df967cb 477 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: writing file.\n", __func__);
dkato 0:b22a1df967cb 478 TEST_ASSERT_MESSAGE(ret == strlen(str), fsfat_basic_msg_g);
dkato 0:b22a1df967cb 479
dkato 0:b22a1df967cb 480 ret = fclose(f);
dkato 0:b22a1df967cb 481 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fclose() failed.\n", __func__);
dkato 0:b22a1df967cb 482 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 483 }
dkato 0:b22a1df967cb 484
dkato 0:b22a1df967cb 485 FSFAT_DBGLOG("%s:List files:\n", __func__);
dkato 0:b22a1df967cb 486 DIR *d = opendir("/sd");
dkato 0:b22a1df967cb 487 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: opendir() failed.\n", __func__);
dkato 0:b22a1df967cb 488 TEST_ASSERT_MESSAGE(d != NULL, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 489
dkato 0:b22a1df967cb 490 struct dirent *p;
dkato 0:b22a1df967cb 491 while ((p = readdir(d)) != NULL)
dkato 0:b22a1df967cb 492 FSFAT_DBGLOG("%s\n", p->d_name);
dkato 0:b22a1df967cb 493 closedir(d);
dkato 0:b22a1df967cb 494
dkato 0:b22a1df967cb 495 return CaseNext;
dkato 0:b22a1df967cb 496 }
dkato 0:b22a1df967cb 497
dkato 0:b22a1df967cb 498
dkato 0:b22a1df967cb 499 /** @brief basic test to write a file to sd card, and read it back again
dkato 0:b22a1df967cb 500 *
dkato 0:b22a1df967cb 501 * This test has been ported from armmbed/mbed-os/features/unsupported/tests/mbed/file/main.cpp.
dkato 0:b22a1df967cb 502 *
dkato 0:b22a1df967cb 503 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 504 */
dkato 0:b22a1df967cb 505 static control_t fsfat_basic_test_06()
dkato 0:b22a1df967cb 506 {
dkato 0:b22a1df967cb 507 int ret = -1;
dkato 0:b22a1df967cb 508 char mac[16];
dkato 0:b22a1df967cb 509 mbed_mac_address(mac);
dkato 0:b22a1df967cb 510 FSFAT_DBGLOG("mac address: %02x,%02x,%02x,%02x,%02x,%02x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
dkato 0:b22a1df967cb 511
dkato 0:b22a1df967cb 512 FILE *f;
dkato 0:b22a1df967cb 513 char *str = FSFAT_BASIC_TEST_05_TEST_STRING;
dkato 0:b22a1df967cb 514 char *buffer = (char *)malloc(sizeof(unsigned char) * strlen(FSFAT_BASIC_TEST_05_TEST_STRING));
dkato 0:b22a1df967cb 515 int str_len = strlen(FSFAT_BASIC_TEST_05_TEST_STRING);
dkato 0:b22a1df967cb 516
dkato 0:b22a1df967cb 517 f = fopen(sd_file_path, "w");
dkato 0:b22a1df967cb 518 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fopen() failed.\n", __func__);
dkato 0:b22a1df967cb 519 TEST_ASSERT_MESSAGE(f != NULL, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 520
dkato 0:b22a1df967cb 521 ret = fprintf(f, str);
dkato 0:b22a1df967cb 522 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: writing file.\n", __func__);
dkato 0:b22a1df967cb 523 TEST_ASSERT_MESSAGE(ret == strlen(str), fsfat_basic_msg_g);
dkato 0:b22a1df967cb 524
dkato 0:b22a1df967cb 525 ret = fclose(f);
dkato 0:b22a1df967cb 526 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fclose() failed.\n", __func__);
dkato 0:b22a1df967cb 527 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 528
dkato 0:b22a1df967cb 529 // Read
dkato 0:b22a1df967cb 530 f = fopen(sd_file_path, "r");
dkato 0:b22a1df967cb 531 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fopen() failed.\n", __func__);
dkato 0:b22a1df967cb 532 TEST_ASSERT_MESSAGE(f != NULL, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 533
dkato 0:b22a1df967cb 534 int n = fread(fsfat_basic_buffer, sizeof(unsigned char), str_len, f);
dkato 0:b22a1df967cb 535 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fread() failed.\n", __func__);
dkato 0:b22a1df967cb 536 TEST_ASSERT_MESSAGE(n == str_len, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 537
dkato 0:b22a1df967cb 538 ret = fclose(f);
dkato 0:b22a1df967cb 539 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: fclose() failed.\n", __func__);
dkato 0:b22a1df967cb 540 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 541
dkato 0:b22a1df967cb 542 return CaseNext;
dkato 0:b22a1df967cb 543 }
dkato 0:b22a1df967cb 544
dkato 0:b22a1df967cb 545
dkato 0:b22a1df967cb 546 /** @brief basic test to write a file to sd card.
dkato 0:b22a1df967cb 547 *
dkato 0:b22a1df967cb 548 * This test has been ported from armmbed/mbed-os/features/unsupported/tests/mbed/sd/main.cpp.
dkato 0:b22a1df967cb 549 *
dkato 0:b22a1df967cb 550 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 551 */
dkato 0:b22a1df967cb 552 static control_t fsfat_basic_test_07()
dkato 0:b22a1df967cb 553 {
dkato 0:b22a1df967cb 554 uint8_t data_written[FSFAT_BASIC_DATA_SIZE] = { 0 };
dkato 0:b22a1df967cb 555
dkato 0:b22a1df967cb 556 // Fill data_written buffer with random data
dkato 0:b22a1df967cb 557 // Write these data into the file
dkato 0:b22a1df967cb 558 bool write_result = false;
dkato 0:b22a1df967cb 559 {
dkato 0:b22a1df967cb 560 FSFAT_DBGLOG("%s:SD: Writing ... ", __func__);
dkato 0:b22a1df967cb 561 FILE *f = fopen(sd_file_path, "w");
dkato 0:b22a1df967cb 562 if (f) {
dkato 0:b22a1df967cb 563 for (int i = 0; i < FSFAT_BASIC_DATA_SIZE; i++) {
dkato 0:b22a1df967cb 564 data_written[i] = rand() % 0XFF;
dkato 0:b22a1df967cb 565 fprintf(f, "%c", data_written[i]);
dkato 0:b22a1df967cb 566 }
dkato 0:b22a1df967cb 567 write_result = true;
dkato 0:b22a1df967cb 568 fclose(f);
dkato 0:b22a1df967cb 569 }
dkato 0:b22a1df967cb 570 FSFAT_DBGLOG("[%s]\n", write_result ? "OK" : "FAIL");
dkato 0:b22a1df967cb 571 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: unexpected write failure.\n", __func__);
dkato 0:b22a1df967cb 572 TEST_ASSERT_MESSAGE(write_result == true, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 573 }
dkato 0:b22a1df967cb 574
dkato 0:b22a1df967cb 575 // Read back the data from the file and store them in data_read
dkato 0:b22a1df967cb 576 bool read_result = false;
dkato 0:b22a1df967cb 577 {
dkato 0:b22a1df967cb 578 FSFAT_DBGLOG("%s:SD: Reading data ... ", __func__);
dkato 0:b22a1df967cb 579 FILE *f = fopen(sd_file_path, "r");
dkato 0:b22a1df967cb 580 if (f) {
dkato 0:b22a1df967cb 581 read_result = true;
dkato 0:b22a1df967cb 582 for (int i = 0; i < FSFAT_BASIC_DATA_SIZE; i++) {
dkato 0:b22a1df967cb 583 uint8_t data = fgetc(f);
dkato 0:b22a1df967cb 584 if (data != data_written[i]) {
dkato 0:b22a1df967cb 585 read_result = false;
dkato 0:b22a1df967cb 586 break;
dkato 0:b22a1df967cb 587 }
dkato 0:b22a1df967cb 588 }
dkato 0:b22a1df967cb 589 fclose(f);
dkato 0:b22a1df967cb 590 }
dkato 0:b22a1df967cb 591 FSFAT_DBGLOG("[%s]\n", read_result ? "OK" : "FAIL");
dkato 0:b22a1df967cb 592 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: unexpected read failure.\n", __func__);
dkato 0:b22a1df967cb 593 TEST_ASSERT_MESSAGE(read_result == true, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 594 }
dkato 0:b22a1df967cb 595 return CaseNext;
dkato 0:b22a1df967cb 596 }
dkato 0:b22a1df967cb 597
dkato 0:b22a1df967cb 598
dkato 0:b22a1df967cb 599 static bool fsfat_basic_test_file_write_fhandle(const char *filename, const int kib_rw)
dkato 0:b22a1df967cb 600 {
dkato 0:b22a1df967cb 601 int ret = -1;
dkato 0:b22a1df967cb 602 File file;
dkato 0:b22a1df967cb 603
dkato 0:b22a1df967cb 604 ret = file.open(&fs, filename, O_WRONLY | O_CREAT | O_TRUNC);
dkato 0:b22a1df967cb 605 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to open file.\n", __func__);
dkato 0:b22a1df967cb 606 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 607
dkato 0:b22a1df967cb 608 int byte_write = 0;
dkato 0:b22a1df967cb 609 fsfat_basic_timer.start();
dkato 0:b22a1df967cb 610 for (int i = 0; i < kib_rw; i++) {
dkato 0:b22a1df967cb 611 ret = file.write(fsfat_basic_buffer, sizeof(fsfat_basic_buffer));
dkato 0:b22a1df967cb 612 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to write to file.\n", __func__);
dkato 0:b22a1df967cb 613 TEST_ASSERT_MESSAGE(ret == sizeof(fsfat_basic_buffer), fsfat_basic_msg_g);
dkato 0:b22a1df967cb 614 byte_write++;
dkato 0:b22a1df967cb 615 }
dkato 0:b22a1df967cb 616 fsfat_basic_timer.stop();
dkato 0:b22a1df967cb 617 file.close();
dkato 0:b22a1df967cb 618 double test_time_sec = fsfat_basic_timer.read_us() / 1000000.0;
dkato 0:b22a1df967cb 619 double speed = kib_rw / test_time_sec;
dkato 0:b22a1df967cb 620 FSFAT_DBGLOG("%d KiB write in %.3f sec with speed of %.4f KiB/s\n", byte_write, test_time_sec, speed);
dkato 0:b22a1df967cb 621 fsfat_basic_timer.reset();
dkato 0:b22a1df967cb 622 return true;
dkato 0:b22a1df967cb 623 }
dkato 0:b22a1df967cb 624
dkato 0:b22a1df967cb 625
dkato 0:b22a1df967cb 626 static bool fsfat_basic_test_file_read_fhandle(const char *filename, const int kib_rw)
dkato 0:b22a1df967cb 627 {
dkato 0:b22a1df967cb 628 int ret = -1;
dkato 0:b22a1df967cb 629 File file;
dkato 0:b22a1df967cb 630 ret = file.open(&fs, filename, O_RDONLY);
dkato 0:b22a1df967cb 631
dkato 0:b22a1df967cb 632 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to open file.\n", __func__);
dkato 0:b22a1df967cb 633 TEST_ASSERT_MESSAGE(ret == 0, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 634
dkato 0:b22a1df967cb 635 fsfat_basic_timer.start();
dkato 0:b22a1df967cb 636 int byte_read = 0;
dkato 0:b22a1df967cb 637 while (file.read(fsfat_basic_buffer, sizeof(fsfat_basic_buffer)) == sizeof(fsfat_basic_buffer)) {
dkato 0:b22a1df967cb 638 byte_read++;
dkato 0:b22a1df967cb 639 }
dkato 0:b22a1df967cb 640 fsfat_basic_timer.stop();
dkato 0:b22a1df967cb 641 file.close();
dkato 0:b22a1df967cb 642 double test_time_sec = fsfat_basic_timer.read_us() / 1000000.0;
dkato 0:b22a1df967cb 643 double speed = kib_rw / test_time_sec;
dkato 0:b22a1df967cb 644 FSFAT_DBGLOG("%d KiB read in %.3f sec with speed of %.4f KiB/s\n", byte_read, test_time_sec, speed);
dkato 0:b22a1df967cb 645 fsfat_basic_timer.reset();
dkato 0:b22a1df967cb 646 return true;
dkato 0:b22a1df967cb 647 }
dkato 0:b22a1df967cb 648
dkato 0:b22a1df967cb 649
dkato 0:b22a1df967cb 650 static char fsfat_basic_test_random_char()
dkato 0:b22a1df967cb 651 {
dkato 0:b22a1df967cb 652 return rand() % 100;
dkato 0:b22a1df967cb 653 }
dkato 0:b22a1df967cb 654
dkato 0:b22a1df967cb 655
dkato 0:b22a1df967cb 656 /** @brief basic sd card performance test
dkato 0:b22a1df967cb 657 *
dkato 0:b22a1df967cb 658 * This test has been ported from armmbed/mbed-os/features/unsupported/tests/mbed/sd_perf_handle/main.cpp.
dkato 0:b22a1df967cb 659 *
dkato 0:b22a1df967cb 660 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 661 */
dkato 0:b22a1df967cb 662 static control_t fsfat_basic_test_08()
dkato 0:b22a1df967cb 663 {
dkato 0:b22a1df967cb 664 // Test header
dkato 0:b22a1df967cb 665 FSFAT_DBGLOG("\n%s:SD Card FileHandle Performance Test\n", __func__);
dkato 0:b22a1df967cb 666 FSFAT_DBGLOG("File name: %s\n", fsfat_basic_bin_filename);
dkato 0:b22a1df967cb 667 FSFAT_DBGLOG("Buffer size: %d KiB\n", (FSFAT_BASIC_KIB_RW * sizeof(fsfat_basic_buffer)) / 1024);
dkato 0:b22a1df967cb 668
dkato 0:b22a1df967cb 669 // Initialize buffer
dkato 0:b22a1df967cb 670 srand(0);
dkato 0:b22a1df967cb 671 char *buffer_end = fsfat_basic_buffer + sizeof(fsfat_basic_buffer);
dkato 0:b22a1df967cb 672 std::generate (fsfat_basic_buffer, buffer_end, fsfat_basic_test_random_char);
dkato 0:b22a1df967cb 673
dkato 0:b22a1df967cb 674 bool result = true;
dkato 0:b22a1df967cb 675 for (;;) {
dkato 0:b22a1df967cb 676 FSFAT_DBGLOG("%s:Write test...\n", __func__);
dkato 0:b22a1df967cb 677 if (fsfat_basic_test_file_write_fhandle(fsfat_basic_bin_filename_test_08, FSFAT_BASIC_KIB_RW) == false) {
dkato 0:b22a1df967cb 678 result = false;
dkato 0:b22a1df967cb 679 break;
dkato 0:b22a1df967cb 680 }
dkato 0:b22a1df967cb 681
dkato 0:b22a1df967cb 682 FSFAT_DBGLOG("%s:Read test...\n", __func__);
dkato 0:b22a1df967cb 683 if (fsfat_basic_test_file_read_fhandle(fsfat_basic_bin_filename_test_08, FSFAT_BASIC_KIB_RW) == false) {
dkato 0:b22a1df967cb 684 result = false;
dkato 0:b22a1df967cb 685 break;
dkato 0:b22a1df967cb 686 }
dkato 0:b22a1df967cb 687 break;
dkato 0:b22a1df967cb 688 }
dkato 0:b22a1df967cb 689 return CaseNext;
dkato 0:b22a1df967cb 690 }
dkato 0:b22a1df967cb 691
dkato 0:b22a1df967cb 692
dkato 0:b22a1df967cb 693 bool fsfat_basic_test_sf_file_write_stdio(const char *filename, const int kib_rw)
dkato 0:b22a1df967cb 694 {
dkato 0:b22a1df967cb 695 int ret = -1;
dkato 0:b22a1df967cb 696 FILE* file = fopen(filename, "w");
dkato 0:b22a1df967cb 697
dkato 0:b22a1df967cb 698 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to open file.\n", __func__);
dkato 0:b22a1df967cb 699 TEST_ASSERT_MESSAGE(file != NULL, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 700
dkato 0:b22a1df967cb 701 int byte_write = 0;
dkato 0:b22a1df967cb 702 fsfat_basic_timer.start();
dkato 0:b22a1df967cb 703 for (int i = 0; i < kib_rw; i++) {
dkato 0:b22a1df967cb 704 ret = fwrite(fsfat_basic_buffer, sizeof(char), sizeof(fsfat_basic_buffer), file);
dkato 0:b22a1df967cb 705 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to write to file.\n", __func__);
dkato 0:b22a1df967cb 706 TEST_ASSERT_MESSAGE(ret == sizeof(fsfat_basic_buffer), fsfat_basic_msg_g);
dkato 0:b22a1df967cb 707 byte_write++;
dkato 0:b22a1df967cb 708 }
dkato 0:b22a1df967cb 709 fsfat_basic_timer.stop();
dkato 0:b22a1df967cb 710 fclose(file);
dkato 0:b22a1df967cb 711 double test_time_sec = fsfat_basic_timer.read_us() / 1000000.0;
dkato 0:b22a1df967cb 712 double speed = kib_rw / test_time_sec;
dkato 0:b22a1df967cb 713 FSFAT_DBGLOG("%d KiB write in %.3f sec with speed of %.4f KiB/s\n", byte_write, test_time_sec, speed);
dkato 0:b22a1df967cb 714 fsfat_basic_timer.reset();
dkato 0:b22a1df967cb 715 return true;
dkato 0:b22a1df967cb 716 }
dkato 0:b22a1df967cb 717
dkato 0:b22a1df967cb 718
dkato 0:b22a1df967cb 719 bool fsfat_basic_test_sf_file_read_stdio(const char *filename, const int kib_rw)
dkato 0:b22a1df967cb 720 {
dkato 0:b22a1df967cb 721 bool result = true;
dkato 0:b22a1df967cb 722 FILE* file = fopen(filename, "r");
dkato 0:b22a1df967cb 723
dkato 0:b22a1df967cb 724 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to open file.\n", __func__);
dkato 0:b22a1df967cb 725 TEST_ASSERT_MESSAGE(file != NULL, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 726 fsfat_basic_timer.start();
dkato 0:b22a1df967cb 727 int byte_read = 0;
dkato 0:b22a1df967cb 728 while (fread(fsfat_basic_buffer, sizeof(char), sizeof(fsfat_basic_buffer), file) == sizeof(fsfat_basic_buffer)) {
dkato 0:b22a1df967cb 729 byte_read++;
dkato 0:b22a1df967cb 730 }
dkato 0:b22a1df967cb 731 fsfat_basic_timer.stop();
dkato 0:b22a1df967cb 732 fclose(file);
dkato 0:b22a1df967cb 733 double test_time_sec = fsfat_basic_timer.read_us() / 1000000.0;
dkato 0:b22a1df967cb 734 double speed = kib_rw / test_time_sec;
dkato 0:b22a1df967cb 735 FSFAT_DBGLOG("%d KiB read in %.3f sec with speed of %.4f KiB/s\n", byte_read, test_time_sec, speed);
dkato 0:b22a1df967cb 736
dkato 0:b22a1df967cb 737 fsfat_basic_timer.reset();
dkato 0:b22a1df967cb 738 return true;
dkato 0:b22a1df967cb 739 }
dkato 0:b22a1df967cb 740
dkato 0:b22a1df967cb 741
dkato 0:b22a1df967cb 742 /** @brief basic test to write a file to sd card.
dkato 0:b22a1df967cb 743 *
dkato 0:b22a1df967cb 744 * This test has been ported from armmbed/mbed-os/features/unsupported/tests/mbed/sd_perf_stdio/main.cpp.
dkato 0:b22a1df967cb 745 *
dkato 0:b22a1df967cb 746 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 747 */
dkato 0:b22a1df967cb 748 static control_t fsfat_basic_test_09()
dkato 0:b22a1df967cb 749 {
dkato 0:b22a1df967cb 750 // Test header
dkato 0:b22a1df967cb 751 FSFAT_DBGLOG("\n%s:SD Card Stdio Performance Test\n", __func__);
dkato 0:b22a1df967cb 752 FSFAT_DBGLOG("File name: %s\n", fsfat_basic_bin_filename);
dkato 0:b22a1df967cb 753 FSFAT_DBGLOG("Buffer size: %d KiB\n", (FSFAT_BASIC_KIB_RW * sizeof(fsfat_basic_buffer)) / 1024);
dkato 0:b22a1df967cb 754
dkato 0:b22a1df967cb 755 // Initialize buffer
dkato 0:b22a1df967cb 756 srand(0);
dkato 0:b22a1df967cb 757 char *buffer_end = fsfat_basic_buffer + sizeof(fsfat_basic_buffer);
dkato 0:b22a1df967cb 758 std::generate (fsfat_basic_buffer, buffer_end, fsfat_basic_test_random_char);
dkato 0:b22a1df967cb 759
dkato 0:b22a1df967cb 760 bool result = true;
dkato 0:b22a1df967cb 761 for (;;) {
dkato 0:b22a1df967cb 762 FSFAT_DBGLOG("%s:Write test...\n", __func__);
dkato 0:b22a1df967cb 763 if (fsfat_basic_test_sf_file_write_stdio(fsfat_basic_bin_filename, FSFAT_BASIC_KIB_RW) == false) {
dkato 0:b22a1df967cb 764 result = false;
dkato 0:b22a1df967cb 765 break;
dkato 0:b22a1df967cb 766 }
dkato 0:b22a1df967cb 767
dkato 0:b22a1df967cb 768 FSFAT_DBGLOG("%s:Read test...\n", __func__);
dkato 0:b22a1df967cb 769 if (fsfat_basic_test_sf_file_read_stdio(fsfat_basic_bin_filename, FSFAT_BASIC_KIB_RW) == false) {
dkato 0:b22a1df967cb 770 result = false;
dkato 0:b22a1df967cb 771 break;
dkato 0:b22a1df967cb 772 }
dkato 0:b22a1df967cb 773 break;
dkato 0:b22a1df967cb 774 }
dkato 0:b22a1df967cb 775 return CaseNext;
dkato 0:b22a1df967cb 776 }
dkato 0:b22a1df967cb 777
dkato 0:b22a1df967cb 778
dkato 0:b22a1df967cb 779 bool fsfat_basic_test_file_write_fatfs(const char *filename, const int kib_rw)
dkato 0:b22a1df967cb 780 {
dkato 0:b22a1df967cb 781 FIL file;
dkato 0:b22a1df967cb 782 FRESULT res = f_open(&file, filename, FA_WRITE | FA_CREATE_ALWAYS);
dkato 0:b22a1df967cb 783
dkato 0:b22a1df967cb 784 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to open file.\n", __func__);
dkato 0:b22a1df967cb 785 TEST_ASSERT_MESSAGE(res == FR_OK, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 786
dkato 0:b22a1df967cb 787 int byte_write = 0;
dkato 0:b22a1df967cb 788 unsigned int bytes = 0;
dkato 0:b22a1df967cb 789 fsfat_basic_timer.start();
dkato 0:b22a1df967cb 790 for (int i = 0; i < kib_rw; i++) {
dkato 0:b22a1df967cb 791 res = f_write(&file, fsfat_basic_buffer, sizeof(fsfat_basic_buffer), &bytes);
dkato 0:b22a1df967cb 792 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to write to file.\n", __func__);
dkato 0:b22a1df967cb 793 TEST_ASSERT_MESSAGE(res == FR_OK, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 794 byte_write++;
dkato 0:b22a1df967cb 795 }
dkato 0:b22a1df967cb 796 fsfat_basic_timer.stop();
dkato 0:b22a1df967cb 797 f_close(&file);
dkato 0:b22a1df967cb 798 double test_time_sec = fsfat_basic_timer.read_us() / 1000000.0;
dkato 0:b22a1df967cb 799 double speed = kib_rw / test_time_sec;
dkato 0:b22a1df967cb 800 FSFAT_DBGLOG("%d KiB write in %.3f sec with speed of %.4f KiB/s\n", byte_write, test_time_sec, speed);
dkato 0:b22a1df967cb 801 fsfat_basic_timer.reset();
dkato 0:b22a1df967cb 802 return true;
dkato 0:b22a1df967cb 803 }
dkato 0:b22a1df967cb 804
dkato 0:b22a1df967cb 805 bool fsfat_basic_test_file_read_fatfs(const char *filename, const int kib_rw)
dkato 0:b22a1df967cb 806 {
dkato 0:b22a1df967cb 807 FIL file;
dkato 0:b22a1df967cb 808 FRESULT res = f_open(&file, filename, FA_READ | FA_OPEN_EXISTING);
dkato 0:b22a1df967cb 809
dkato 0:b22a1df967cb 810 FSFAT_BASIC_MSG(fsfat_basic_msg_g, FSFAT_BASIC_MSG_BUF_SIZE, "%s: Error: failed to open file.\n", __func__);
dkato 0:b22a1df967cb 811 TEST_ASSERT_MESSAGE(res == FR_OK, fsfat_basic_msg_g);
dkato 0:b22a1df967cb 812
dkato 0:b22a1df967cb 813 fsfat_basic_timer.start();
dkato 0:b22a1df967cb 814 int byte_read = 0;
dkato 0:b22a1df967cb 815 unsigned int bytes = 0;
dkato 0:b22a1df967cb 816 do {
dkato 0:b22a1df967cb 817 res = f_read(&file, fsfat_basic_buffer, sizeof(fsfat_basic_buffer), &bytes);
dkato 0:b22a1df967cb 818 byte_read++;
dkato 0:b22a1df967cb 819 } while (res == FR_OK && bytes == sizeof(fsfat_basic_buffer));
dkato 0:b22a1df967cb 820 fsfat_basic_timer.stop();
dkato 0:b22a1df967cb 821 f_close(&file);
dkato 0:b22a1df967cb 822 double test_time_sec = fsfat_basic_timer.read_us() / 1000000.0;
dkato 0:b22a1df967cb 823 double speed = kib_rw / test_time_sec;
dkato 0:b22a1df967cb 824 FSFAT_DBGLOG("%d KiB read in %.3f sec with speed of %.4f KiB/s\n", byte_read, test_time_sec, speed);
dkato 0:b22a1df967cb 825 fsfat_basic_timer.reset();
dkato 0:b22a1df967cb 826 return true;
dkato 0:b22a1df967cb 827 }
dkato 0:b22a1df967cb 828
dkato 0:b22a1df967cb 829 /** @brief basic test to write a file to sd card.
dkato 0:b22a1df967cb 830 *
dkato 0:b22a1df967cb 831 * This test has been ported from armmbed/mbed-os/features/unsupported/tests/mbed/sd_perf_stdio/main.cpp.
dkato 0:b22a1df967cb 832 *
dkato 0:b22a1df967cb 833 * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
dkato 0:b22a1df967cb 834 */
dkato 0:b22a1df967cb 835 static control_t fsfat_basic_test_10()
dkato 0:b22a1df967cb 836 {
dkato 0:b22a1df967cb 837 // Test header
dkato 0:b22a1df967cb 838 FSFAT_DBGLOG("\n%sSD Card FatFS Performance Test\n", __func__);
dkato 0:b22a1df967cb 839 FSFAT_DBGLOG("File name: %s\n", fsfat_basic_bin_filename_test_10);
dkato 0:b22a1df967cb 840 FSFAT_DBGLOG("Buffer size: %d KiB\n", (FSFAT_BASIC_KIB_RW * sizeof(fsfat_basic_buffer)) / 1024);
dkato 0:b22a1df967cb 841
dkato 0:b22a1df967cb 842 // Initialize buffer
dkato 0:b22a1df967cb 843 srand(1);
dkato 0:b22a1df967cb 844 char *buffer_end = fsfat_basic_buffer + sizeof(fsfat_basic_buffer);
dkato 0:b22a1df967cb 845 std::generate (fsfat_basic_buffer, buffer_end, fsfat_basic_test_random_char);
dkato 0:b22a1df967cb 846
dkato 0:b22a1df967cb 847 bool result = true;
dkato 0:b22a1df967cb 848 for (;;) {
dkato 0:b22a1df967cb 849 FSFAT_DBGLOG("%s:Write test...\n", __func__);
dkato 0:b22a1df967cb 850 if (fsfat_basic_test_file_write_fatfs(fsfat_basic_bin_filename_test_10, FSFAT_BASIC_KIB_RW) == false) {
dkato 0:b22a1df967cb 851 result = false;
dkato 0:b22a1df967cb 852 break;
dkato 0:b22a1df967cb 853 }
dkato 0:b22a1df967cb 854
dkato 0:b22a1df967cb 855 FSFAT_DBGLOG("%s:Read test...\n", __func__);
dkato 0:b22a1df967cb 856 if (fsfat_basic_test_file_read_fatfs(fsfat_basic_bin_filename_test_10, FSFAT_BASIC_KIB_RW) == false) {
dkato 0:b22a1df967cb 857 result = false;
dkato 0:b22a1df967cb 858 break;
dkato 0:b22a1df967cb 859 }
dkato 0:b22a1df967cb 860 break;
dkato 0:b22a1df967cb 861 }
dkato 0:b22a1df967cb 862 return CaseNext;
dkato 0:b22a1df967cb 863 }
dkato 0:b22a1df967cb 864
dkato 0:b22a1df967cb 865 #else
dkato 0:b22a1df967cb 866
dkato 0:b22a1df967cb 867 #define FSFAT_BASIC_TEST_00 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 868 #define FSFAT_BASIC_TEST_01 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 869 #define FSFAT_BASIC_TEST_02 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 870 #define FSFAT_BASIC_TEST_03 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 871 #define FSFAT_BASIC_TEST_04 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 872 #define FSFAT_BASIC_TEST_05 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 873 #define FSFAT_BASIC_TEST_06 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 874 #define FSFAT_BASIC_TEST_07 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 875 #define FSFAT_BASIC_TEST_08 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 876 #define FSFAT_BASIC_TEST_09 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 877 #define FSFAT_BASIC_TEST_10 fsfat_basic_test_dummy
dkato 0:b22a1df967cb 878
dkato 0:b22a1df967cb 879
dkato 0:b22a1df967cb 880 /** @brief fsfat_basic_test_dummy Dummy test case for testing when platform doesnt have an SDCard installed.
dkato 0:b22a1df967cb 881 *
dkato 0:b22a1df967cb 882 * @return success always
dkato 0:b22a1df967cb 883 */
dkato 0:b22a1df967cb 884 static control_t fsfat_basic_test_dummy()
dkato 0:b22a1df967cb 885 {
dkato 0:b22a1df967cb 886 printf("Null test\n");
dkato 0:b22a1df967cb 887 return CaseNext;
dkato 0:b22a1df967cb 888 }
dkato 0:b22a1df967cb 889
dkato 0:b22a1df967cb 890 #endif /* defined(DEVICE_SPI) && defined(MBED_CONF_APP_FSFAT_SDCARD_INSTALLED) */
dkato 0:b22a1df967cb 891
dkato 0:b22a1df967cb 892 utest::v1::status_t greentea_setup(const size_t number_of_cases)
dkato 0:b22a1df967cb 893 {
dkato 0:b22a1df967cb 894 GREENTEA_SETUP(300, "default_auto");
dkato 0:b22a1df967cb 895 return greentea_test_setup_handler(number_of_cases);
dkato 0:b22a1df967cb 896 }
dkato 0:b22a1df967cb 897
dkato 0:b22a1df967cb 898
dkato 0:b22a1df967cb 899 Case cases[] = {
dkato 0:b22a1df967cb 900 /* 1 2 3 4 5 6 7 */
dkato 0:b22a1df967cb 901 /* 1234567890123456789012345678901234567890123456789012345678901234567890 */
dkato 0:b22a1df967cb 902 Case("FSFAT_BASIC_TEST_00: fopen()/fgetc()/fprintf()/fclose() test.", FSFAT_BASIC_TEST_00),
dkato 0:b22a1df967cb 903 Case("FSFAT_BASIC_TEST_01: fopen()/fseek()/fclose() test.", FSFAT_BASIC_TEST_01),
dkato 0:b22a1df967cb 904 /* WARNING: Test case not working but currently not required for PAL support
dkato 0:b22a1df967cb 905 * Case("FSFAT_BASIC_TEST_02: fopen()/fgets()/fputs()/ftell()/rewind()/remove() test.", FSFAT_BASIC_TEST_02) */
dkato 0:b22a1df967cb 906 Case("FSFAT_BASIC_TEST_03: tmpnam() test.", FSFAT_BASIC_TEST_03),
dkato 0:b22a1df967cb 907 Case("FSFAT_BASIC_TEST_04: fileno() test.", FSFAT_BASIC_TEST_04),
dkato 0:b22a1df967cb 908 Case("FSFAT_BASIC_TEST_05: opendir() basic test.", FSFAT_BASIC_TEST_05),
dkato 0:b22a1df967cb 909 Case("FSFAT_BASIC_TEST_06: fread()/fwrite() file to sdcard.", FSFAT_BASIC_TEST_06),
dkato 0:b22a1df967cb 910 Case("FSFAT_BASIC_TEST_07: sdcard fwrite() file test.", FSFAT_BASIC_TEST_07),
dkato 0:b22a1df967cb 911 Case("FSFAT_BASIC_TEST_08: FATFileSystem::read()/write() test.", FSFAT_BASIC_TEST_08),
dkato 0:b22a1df967cb 912 Case("FSFAT_BASIC_TEST_09: POSIX FILE API fread()/fwrite() test.", FSFAT_BASIC_TEST_09),
dkato 0:b22a1df967cb 913 Case("FSFAT_BASIC_TEST_10: ChanFS read()/write()) test.", FSFAT_BASIC_TEST_10),
dkato 0:b22a1df967cb 914 };
dkato 0:b22a1df967cb 915
dkato 0:b22a1df967cb 916
dkato 0:b22a1df967cb 917 /* Declare your test specification with a custom setup handler */
dkato 0:b22a1df967cb 918 Specification specification(greentea_setup, cases);
dkato 0:b22a1df967cb 919
dkato 0:b22a1df967cb 920 int main()
dkato 0:b22a1df967cb 921 {
dkato 0:b22a1df967cb 922 return !Harness::run(specification);
dkato 0:b22a1df967cb 923 }