llvm/unittests/Support/LineIteratorTest.cpp

   1 //===- LineIterator.cpp - Unit tests --------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/Support/LineIterator.h"
  10 #include "llvm/Support/MemoryBuffer.h"
  11 #include "gtest/gtest.h"
  12
  13 using namespace llvm;
  14 using namespace llvm::sys;
  15
  16 namespace {
  17
  18 TEST(LineIteratorTest, Basic) {
  19   std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer("line 1\n"
  20                                                                     "line 2\n"
  21                                                                     "line 3");
  22
  23   line_iterator I = line_iterator(*Buffer), E;
  24
  25   EXPECT_FALSE(I.is_at_eof());
  26   EXPECT_NE(E, I);
  27
  28   EXPECT_EQ("line 1", *I);
  29   EXPECT_EQ(1, I.line_number());
  30   ++I;
  31   EXPECT_EQ("line 2", *I);
  32   EXPECT_EQ(2, I.line_number());
  33   ++I;
  34   EXPECT_EQ("line 3", *I);
  35   EXPECT_EQ(3, I.line_number());
  36   ++I;
  37
  38   EXPECT_TRUE(I.is_at_eof());
  39   EXPECT_EQ(E, I);
  40 }
  41
  42 TEST(LineIteratorTest, Ref) {
  43   std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer("line 1\n"
  44                                                                     "line 2\n"
  45                                                                     "line 3");
  46
  47   line_iterator I = line_iterator(Buffer->getMemBufferRef()), E;
  48
  49   EXPECT_FALSE(I.is_at_eof());
  50   EXPECT_NE(E, I);
  51
  52   EXPECT_EQ("line 1", *I);
  53   EXPECT_EQ(1, I.line_number());
  54   ++I;
  55   EXPECT_EQ("line 2", *I);
  56   EXPECT_EQ(2, I.line_number());
  57   ++I;
  58   EXPECT_EQ("line 3", *I);
  59   EXPECT_EQ(3, I.line_number());
  60   ++I;
  61
  62   EXPECT_TRUE(I.is_at_eof());
  63   EXPECT_EQ(E, I);
  64 }
  65
  66 TEST(LineIteratorTest, CommentAndBlankSkipping) {
  67   std::unique_ptr<MemoryBuffer> Buffer(
  68       MemoryBuffer::getMemBuffer("line 1\n"
  69                                  "line 2\n"
  70                                  "# Comment 1\n"
  71                                  "\n"
  72                                  "line 5\n"
  73                                  "\n"
  74                                  "# Comment 2"));
  75
  76   line_iterator I = line_iterator(*Buffer, true, '#'), E;
  77
  78   EXPECT_FALSE(I.is_at_eof());
  79   EXPECT_NE(E, I);
  80
  81   EXPECT_EQ("line 1", *I);
  82   EXPECT_EQ(1, I.line_number());
  83   ++I;
  84   EXPECT_EQ("line 2", *I);
  85   EXPECT_EQ(2, I.line_number());
  86   ++I;
  87   EXPECT_EQ("line 5", *I);
  88   EXPECT_EQ(5, I.line_number());
  89   ++I;
  90
  91   EXPECT_TRUE(I.is_at_eof());
  92   EXPECT_EQ(E, I);
  93 }
  94
  95 TEST(LineIteratorTest, CommentSkippingKeepBlanks) {
  96   std::unique_ptr<MemoryBuffer> Buffer(
  97       MemoryBuffer::getMemBuffer("line 1\n"
  98                                  "line 2\n"
  99                                  "# Comment 1\n"
 100                                  "# Comment 2\n"
 101                                  "\n"
 102                                  "line 6\n"
 103                                  "\n"
 104                                  "# Comment 3"));
 105
 106   line_iterator I = line_iterator(*Buffer, false, '#'), E;
 107
 108   EXPECT_FALSE(I.is_at_eof());
 109   EXPECT_NE(E, I);
 110
 111   EXPECT_EQ("line 1", *I);
 112   EXPECT_EQ(1, I.line_number());
 113   ++I;
 114   EXPECT_EQ("line 2", *I);
 115   EXPECT_EQ(2, I.line_number());
 116   ++I;
 117   EXPECT_EQ("", *I);
 118   EXPECT_EQ(5, I.line_number());
 119   ++I;
 120   EXPECT_EQ("line 6", *I);
 121   EXPECT_EQ(6, I.line_number());
 122   ++I;
 123   EXPECT_EQ("", *I);
 124   EXPECT_EQ(7, I.line_number());
 125   ++I;
 126
 127   EXPECT_TRUE(I.is_at_eof());
 128   EXPECT_EQ(E, I);
 129 }
 130
 131
 132 TEST(LineIteratorTest, BlankSkipping) {
 133   std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer("\n\n\n"
 134                                                                     "line 1\n"
 135                                                                     "\n\n\n"
 136                                                                     "line 2\n"
 137                                                                     "\n\n\n");
 138
 139   line_iterator I = line_iterator(*Buffer), E;
 140
 141   EXPECT_FALSE(I.is_at_eof());
 142   EXPECT_NE(E, I);
 143
 144   EXPECT_EQ("line 1", *I);
 145   EXPECT_EQ(4, I.line_number());
 146   ++I;
 147   EXPECT_EQ("line 2", *I);
 148   EXPECT_EQ(8, I.line_number());
 149   ++I;
 150
 151   EXPECT_TRUE(I.is_at_eof());
 152   EXPECT_EQ(E, I);
 153 }
 154
 155 TEST(LineIteratorTest, BlankKeeping) {
 156   std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer("\n\n"
 157                                                                     "line 3\n"
 158                                                                     "\n"
 159                                                                     "line 5\n"
 160                                                                     "\n\n");
 161   line_iterator I = line_iterator(*Buffer, false), E;
 162
 163   EXPECT_FALSE(I.is_at_eof());
 164   EXPECT_NE(E, I);
 165
 166   EXPECT_EQ("", *I);
 167   EXPECT_EQ(1, I.line_number());
 168   ++I;
 169   EXPECT_EQ("", *I);
 170   EXPECT_EQ(2, I.line_number());
 171   ++I;
 172   EXPECT_EQ("line 3", *I);
 173   EXPECT_EQ(3, I.line_number());
 174   ++I;
 175   EXPECT_EQ("", *I);
 176   EXPECT_EQ(4, I.line_number());
 177   ++I;
 178   EXPECT_EQ("line 5", *I);
 179   EXPECT_EQ(5, I.line_number());
 180   ++I;
 181   EXPECT_EQ("", *I);
 182   EXPECT_EQ(6, I.line_number());
 183   ++I;
 184   EXPECT_EQ("", *I);
 185   EXPECT_EQ(7, I.line_number());
 186   ++I;
 187
 188   EXPECT_TRUE(I.is_at_eof());
 189   EXPECT_EQ(E, I);
 190 }
 191
 192 TEST(LineIteratorTest, EmptyBuffers) {
 193   std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer("");
 194   EXPECT_TRUE(line_iterator(*Buffer).is_at_eof());
 195   EXPECT_EQ(line_iterator(), line_iterator(*Buffer));
 196   EXPECT_TRUE(line_iterator(*Buffer, false).is_at_eof());
 197   EXPECT_EQ(line_iterator(), line_iterator(*Buffer, false));
 198
 199   Buffer = MemoryBuffer::getMemBuffer("\n\n\n");
 200   EXPECT_TRUE(line_iterator(*Buffer).is_at_eof());
 201   EXPECT_EQ(line_iterator(), line_iterator(*Buffer));
 202
 203   Buffer = MemoryBuffer::getMemBuffer("# foo\n"
 204                                       "\n"
 205                                       "# bar");
 206   EXPECT_TRUE(line_iterator(*Buffer, true, '#').is_at_eof());
 207   EXPECT_EQ(line_iterator(), line_iterator(*Buffer, true, '#'));
 208
 209   Buffer = MemoryBuffer::getMemBuffer("\n"
 210                                       "# baz\n"
 211                                       "\n");
 212   EXPECT_TRUE(line_iterator(*Buffer, true, '#').is_at_eof());
 213   EXPECT_EQ(line_iterator(), line_iterator(*Buffer, true, '#'));
 214 }
 215
 216 } // anonymous namespace