unittests/tests/TextFileTest.cpp

   1 #include <wx/arrstr.h>
   2
   3 #include <muleunit/test.h>
   4 #include <common/TextFile.h>
   5 #include <common/Path.h>
   6
   7 using namespace muleunit;
   8
   9 DECLARE_SIMPLE(TextFile)
  10
  11 const wxChar* g_filesDefault[] = {
  12         wxT("TextFileTest_dos.txt"),
  13         wxT("TextFileTest_unix.txt")
  14 };
  15
  16
  17 wxString ArrToStr(const wxArrayString& arr)
  18 {
  19         wxString str = wxT("[");
  20
  21         for (size_t i = 0; i < arr.Count(); ++i) {
  22                 if (str != wxT("[")) {
  23                         str << wxT(", \"") << arr[i] << wxT('"');
  24                 } else {
  25                         str << wxT('"') << arr[i] << wxT('"');
  26                 }
  27         }
  28
  29         str << wxT("]");
  30
  31         return str;
  32 }
  33
  34
  35 wxString ArrToStr(size_t count, const wxChar* arr[])
  36 {
  37         return ArrToStr(wxArrayString(count, arr));
  38 }
  39
  40
  41
  42 void CompareReadLines(size_t count, const wxChar* expected[], EReadTextFile criteria)
  43 {
  44         CTextFile file;
  45         ASSERT_FALSE(file.IsOpened());
  46         ASSERT_TRUE(file.Eof());
  47         for (size_t j = 0; j < ArraySize(g_filesDefault); ++j) {
  48                 CONTEXT(wxString(wxT("Checking file: ")) + g_filesDefault[j]);
  49
  50                 ASSERT_TRUE(file.Open(CPath(wxSTRINGIZE_T(SRCDIR)).JoinPaths(CPath(g_filesDefault[j])).GetRaw(), CTextFile::read));
  51
  52                 wxArrayString lines = file.ReadLines(criteria);
  53
  54                 ASSERT_EQUALS(ArrToStr(count, expected), ArrToStr(lines));
  55                 ASSERT_EQUALS(count, lines.GetCount());
  56         }
  57         ASSERT_TRUE(file.IsOpened());
  58         ASSERT_TRUE(file.Eof());
  59 };
  60
  61
  62
  63 TEST(TextFile, ReadLines)
  64 {
  65         {
  66                 CONTEXT(wxT("Checking default parameters"));
  67
  68                 const wxChar* lines[] = {
  69                         wxT("abc"),
  70                         wxT("def ghi"),
  71                         wxT("xyz"),
  72                 };
  73
  74                 CompareReadLines(ArraySize(lines), lines, txtReadDefault);
  75         }
  76
  77         {
  78                 CONTEXT(wxT("Checking without criteria"));
  79
  80                 const wxChar* lines[] = {
  81                         wxT(" # comment"),
  82                         wxT("abc"),
  83                         wxT("# foo bar"),
  84                         wxT(" "),
  85                         wxT("def ghi "),
  86                         wxT(""),
  87                         wxT("# xyz"),
  88                         wxT(" xyz"),
  89                         wxT(" "),
  90                         wxT("")
  91                 };
  92
  93                 CompareReadLines(ArraySize(lines), lines, (EReadTextFile)0);
  94         }
  95
  96         {
  97                 CONTEXT(wxT("Checking txtIgnoreEmptyLines"));
  98
  99                 const wxChar* lines[] = {
 100                         wxT(" # comment"),
 101                         wxT("abc"),
 102                         wxT("# foo bar"),
 103                         wxT(" "),
 104                         wxT("def ghi "),
 105                         wxT("# xyz"),
 106                         wxT(" xyz"),
 107                         wxT(" "),
 108                 };
 109
 110                 CompareReadLines(ArraySize(lines), lines, txtIgnoreEmptyLines);
 111         }
 112
 113         {
 114                 CONTEXT(wxT("Checking txtIgnoreComments"));
 115
 116                 const wxChar* lines[] = {
 117                         wxT("abc"),
 118                         wxT(" "),
 119                         wxT("def ghi "),
 120                         wxT(""),
 121                         wxT(" xyz"),
 122                         wxT(" "),
 123                         wxT("")
 124                 };
 125
 126                 CompareReadLines(ArraySize(lines), lines, txtIgnoreComments);
 127         }
 128
 129         {
 130                 CONTEXT(wxT("Checking txtStripWhitespace"));
 131
 132                 const wxChar* lines[] = {
 133                         wxT("# comment"),
 134                         wxT("abc"),
 135                         wxT("# foo bar"),
 136                         wxT(""),
 137                         wxT("def ghi"),
 138                         wxT(""),
 139                         wxT("# xyz"),
 140                         wxT("xyz"),
 141                         wxT(""),
 142                         wxT("")
 143                 };
 144
 145                 CompareReadLines(ArraySize(lines), lines, txtStripWhitespace);
 146         }
 147 }
 148
 149
 150 class TextFileTest : public Test
 151 {
 152 public:
 153         TextFileTest()
 154                 : Test(wxT("TextFile"), wxT("WriteLines"))
 155         {
 156         }
 157
 158         virtual void setUp()
 159         {
 160                 const CPath path = CPath(wxT("testfile.txt"));
 161                 if (path.FileExists()) {
 162                         ASSERT_TRUE(CPath::RemoveFile(path));
 163                 }
 164
 165         }
 166
 167         virtual void tearDown()
 168         {
 169                 setUp();
 170         }
 171
 172         virtual void run()
 173         {
 174                 const wxChar* lines[] = {
 175                         wxT(" # comment"),
 176                         wxT("abc"),
 177                         wxT("# foo bar"),
 178                         wxT(" "),
 179                         wxT("def ghi "),
 180                         wxT(""),
 181                         wxT("# xyz"),
 182                         wxT(" xyz"),
 183                         wxT(" "),
 184                         wxT("")
 185                 };
 186
 187                 {
 188                         CONTEXT(wxT("Writing lines manually"));
 189
 190                         CTextFile file;
 191                         ASSERT_TRUE(file.Open(wxT("testfile.txt"), CTextFile::write));
 192
 193                         for (size_t i = 0; i < ArraySize(lines); ++i) {
 194                                 CONTEXT(wxString::Format(wxT("Writing the %i'th line."), i));
 195
 196                                 ASSERT_TRUE(file.WriteLine(lines[i]));
 197                         }
 198                 }
 199
 200                 {
 201                         CONTEXT(wxT("Reading manually written lines"));
 202
 203                         CTextFile file;
 204                         ASSERT_TRUE(file.Open(wxT("testfile.txt"), CTextFile::read));
 205                         ASSERT_FALSE(file.Eof());
 206
 207                         for (size_t i = 0; i < ArraySize(lines); ++i) {
 208                                 CONTEXT(wxString::Format(wxT("Reading the %i'th line."), i));
 209
 210                                 ASSERT_EQUALS(lines[i], file.GetNextLine());
 211                         }
 212                         ASSERT_TRUE(file.Eof());
 213                 }
 214
 215                 {
 216                         CONTEXT(wxT("Writing lines automatically"));
 217
 218                         CTextFile file;
 219                         ASSERT_FALSE(file.IsOpened());
 220                         ASSERT_TRUE(file.Open(wxT("testfile.txt"), CTextFile::write));
 221                         ASSERT_TRUE(file.WriteLines(wxArrayString(ArraySize(lines), lines)));
 222                         ASSERT_TRUE(file.IsOpened());
 223                 }
 224
 225                 {
 226                         CONTEXT(wxT("Reading automatically written lines"));
 227
 228                         CTextFile file;
 229                         ASSERT_FALSE(file.IsOpened());
 230                         ASSERT_TRUE(file.Open(wxT("testfile.txt"), CTextFile::read));
 231                         ASSERT_TRUE(file.IsOpened());
 232                         ASSERT_FALSE(file.Eof());
 233
 234                         for (size_t i = 0; i < ArraySize(lines); ++i) {
 235                                 CONTEXT(wxString::Format(wxT("Reading the %i'th line."), i));
 236
 237                                 ASSERT_EQUALS(lines[i], file.GetNextLine());
 238                         }
 239
 240                         ASSERT_TRUE(file.Eof());
 241                 }
 242         }
 243 } testInstance;
 244