external/spirv-tools/src/test/text_word_get_test.cpp

   1 // Copyright (c) 2015-2016 The Khronos Group Inc.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "unit_spirv.h"
  16
  17 namespace {
  18
  19 using libspirv::AssemblyContext;
  20 using spvtest::AutoText;
  21
  22 #define TAB "\t"
  23 #define NEWLINE "\n"
  24 #define BACKSLASH R"(\)"
  25 #define QUOTE R"(")"
  26
  27 TEST(TextWordGet, NullTerminator) {
  28   std::string word;
  29   spv_position_t endPosition = {};
  30   ASSERT_EQ(
  31       SPV_SUCCESS,
  32       AssemblyContext(AutoText("Word"), nullptr).getWord(&word, &endPosition));
  33   ASSERT_EQ(4u, endPosition.column);
  34   ASSERT_EQ(0u, endPosition.line);
  35   ASSERT_EQ(4u, endPosition.index);
  36   ASSERT_STREQ("Word", word.c_str());
  37 }
  38
  39 TEST(TextWordGet, TabTerminator) {
  40   std::string word;
  41   spv_position_t endPosition = {};
  42   ASSERT_EQ(SPV_SUCCESS, AssemblyContext(AutoText("Word\t"), nullptr)
  43                              .getWord(&word, &endPosition));
  44   ASSERT_EQ(4u, endPosition.column);
  45   ASSERT_EQ(0u, endPosition.line);
  46   ASSERT_EQ(4u, endPosition.index);
  47   ASSERT_STREQ("Word", word.c_str());
  48 }
  49
  50 TEST(TextWordGet, SpaceTerminator) {
  51   std::string word;
  52   spv_position_t endPosition = {};
  53   ASSERT_EQ(
  54       SPV_SUCCESS,
  55       AssemblyContext(AutoText("Word "), nullptr).getWord(&word, &endPosition));
  56   ASSERT_EQ(4u, endPosition.column);
  57   ASSERT_EQ(0u, endPosition.line);
  58   ASSERT_EQ(4u, endPosition.index);
  59   ASSERT_STREQ("Word", word.c_str());
  60 }
  61
  62 TEST(TextWordGet, SemicolonTerminator) {
  63   std::string word;
  64   spv_position_t endPosition = {};
  65   ASSERT_EQ(
  66       SPV_SUCCESS,
  67       AssemblyContext(AutoText("Wo;rd"), nullptr).getWord(&word, &endPosition));
  68   ASSERT_EQ(2u, endPosition.column);
  69   ASSERT_EQ(0u, endPosition.line);
  70   ASSERT_EQ(2u, endPosition.index);
  71   ASSERT_STREQ("Wo", word.c_str());
  72 }
  73
  74 TEST(TextWordGet, NoTerminator) {
  75   const std::string full_text = "abcdefghijklmn";
  76   for (size_t len = 1; len <= full_text.size(); ++len) {
  77     std::string word;
  78     spv_text_t text = {full_text.data(), len};
  79     spv_position_t endPosition = {};
  80     ASSERT_EQ(SPV_SUCCESS,
  81               AssemblyContext(&text, nullptr).getWord(&word, &endPosition));
  82     ASSERT_EQ(0u, endPosition.line);
  83     ASSERT_EQ(len, endPosition.column);
  84     ASSERT_EQ(len, endPosition.index);
  85     ASSERT_EQ(full_text.substr(0, len), word);
  86   }
  87 }
  88
  89 TEST(TextWordGet, MultipleWords) {
  90   AutoText input("Words in a sentence");
  91   AssemblyContext data(input, nullptr);
  92
  93   spv_position_t endPosition = {};
  94   const char* words[] = {"Words", "in", "a", "sentence"};
  95
  96   std::string word;
  97   for (uint32_t wordIndex = 0; wordIndex < 4; ++wordIndex) {
  98     ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition));
  99     ASSERT_EQ(strlen(words[wordIndex]),
 100               endPosition.column - data.position().column);
 101     ASSERT_EQ(0u, endPosition.line);
 102     ASSERT_EQ(strlen(words[wordIndex]),
 103               endPosition.index - data.position().index);
 104     ASSERT_STREQ(words[wordIndex], word.c_str());
 105
 106     data.setPosition(endPosition);
 107     if (3 != wordIndex) {
 108       ASSERT_EQ(SPV_SUCCESS, data.advance());
 109     } else {
 110       ASSERT_EQ(SPV_END_OF_STREAM, data.advance());
 111     }
 112   }
 113 }
 114
 115 TEST(TextWordGet, QuotesAreKept) {
 116   AutoText input(R"("quotes" "around words")");
 117   const char* expected[] = {R"("quotes")", R"("around words")"};
 118   AssemblyContext data(input, nullptr);
 119
 120   std::string word;
 121   spv_position_t endPosition = {};
 122   ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition));
 123   EXPECT_EQ(8u, endPosition.column);
 124   EXPECT_EQ(0u, endPosition.line);
 125   EXPECT_EQ(8u, endPosition.index);
 126   EXPECT_STREQ(expected[0], word.c_str());
 127
 128   // Move to the next word.
 129   data.setPosition(endPosition);
 130   data.seekForward(1);
 131
 132   ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition));
 133   EXPECT_EQ(23u, endPosition.column);
 134   EXPECT_EQ(0u, endPosition.line);
 135   EXPECT_EQ(23u, endPosition.index);
 136   EXPECT_STREQ(expected[1], word.c_str());
 137 }
 138
 139 TEST(TextWordGet, QuotesBetweenWordsActLikeGlue) {
 140   AutoText input(R"(quotes" "between words)");
 141   const char* expected[] = {R"(quotes" "between)", "words"};
 142   AssemblyContext data(input, nullptr);
 143
 144   std::string word;
 145   spv_position_t endPosition = {};
 146   ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition));
 147   EXPECT_EQ(16u, endPosition.column);
 148   EXPECT_EQ(0u, endPosition.line);
 149   EXPECT_EQ(16u, endPosition.index);
 150   EXPECT_STREQ(expected[0], word.c_str());
 151
 152   // Move to the next word.
 153   data.setPosition(endPosition);
 154   data.seekForward(1);
 155
 156   ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &endPosition));
 157   EXPECT_EQ(22u, endPosition.column);
 158   EXPECT_EQ(0u, endPosition.line);
 159   EXPECT_EQ(22u, endPosition.index);
 160   EXPECT_STREQ(expected[1], word.c_str());
 161 }
 162
 163 TEST(TextWordGet, QuotingWhitespace) {
 164   AutoText input(QUOTE "white " NEWLINE TAB " space" QUOTE);
 165   // Whitespace surrounded by quotes acts like glue.
 166   std::string word;
 167   spv_position_t endPosition = {};
 168   ASSERT_EQ(SPV_SUCCESS,
 169             AssemblyContext(input, nullptr).getWord(&word, &endPosition));
 170   EXPECT_EQ(input.str.length(), endPosition.column);
 171   EXPECT_EQ(0u, endPosition.line);
 172   EXPECT_EQ(input.str.length(), endPosition.index);
 173   EXPECT_EQ(input.str, word);
 174 }
 175
 176 TEST(TextWordGet, QuoteAlone) {
 177   AutoText input(QUOTE);
 178   std::string word;
 179   spv_position_t endPosition = {};
 180   ASSERT_EQ(SPV_SUCCESS,
 181             AssemblyContext(input, nullptr).getWord(&word, &endPosition));
 182   ASSERT_EQ(1u, endPosition.column);
 183   ASSERT_EQ(0u, endPosition.line);
 184   ASSERT_EQ(1u, endPosition.index);
 185   ASSERT_STREQ(QUOTE, word.c_str());
 186 }
 187
 188 TEST(TextWordGet, EscapeAlone) {
 189   AutoText input(BACKSLASH);
 190   std::string word;
 191   spv_position_t endPosition = {};
 192   ASSERT_EQ(SPV_SUCCESS,
 193             AssemblyContext(input, nullptr).getWord(&word, &endPosition));
 194   ASSERT_EQ(1u, endPosition.column);
 195   ASSERT_EQ(0u, endPosition.line);
 196   ASSERT_EQ(1u, endPosition.index);
 197   ASSERT_STREQ(BACKSLASH, word.c_str());
 198 }
 199
 200 TEST(TextWordGet, EscapeAtEndOfInput) {
 201   AutoText input("word" BACKSLASH);
 202   std::string word;
 203   spv_position_t endPosition = {};
 204   ASSERT_EQ(SPV_SUCCESS,
 205             AssemblyContext(input, nullptr).getWord(&word, &endPosition));
 206   ASSERT_EQ(5u, endPosition.column);
 207   ASSERT_EQ(0u, endPosition.line);
 208   ASSERT_EQ(5u, endPosition.index);
 209   ASSERT_STREQ("word" BACKSLASH, word.c_str());
 210 }
 211
 212 TEST(TextWordGet, Escaping) {
 213   AutoText input("w" BACKSLASH QUOTE "o" BACKSLASH NEWLINE "r" BACKSLASH ";d");
 214   std::string word;
 215   spv_position_t endPosition = {};
 216   ASSERT_EQ(SPV_SUCCESS,
 217             AssemblyContext(input, nullptr).getWord(&word, &endPosition));
 218   ASSERT_EQ(10u, endPosition.column);
 219   ASSERT_EQ(0u, endPosition.line);
 220   ASSERT_EQ(10u, endPosition.index);
 221   ASSERT_EQ(input.str, word);
 222 }
 223
 224 TEST(TextWordGet, EscapingEscape) {
 225   AutoText input("word" BACKSLASH BACKSLASH " abc");
 226   std::string word;
 227   spv_position_t endPosition = {};
 228   ASSERT_EQ(SPV_SUCCESS,
 229             AssemblyContext(input, nullptr).getWord(&word, &endPosition));
 230   ASSERT_EQ(6u, endPosition.column);
 231   ASSERT_EQ(0u, endPosition.line);
 232   ASSERT_EQ(6u, endPosition.index);
 233   ASSERT_STREQ("word" BACKSLASH BACKSLASH, word.c_str());
 234 }
 235
 236 TEST(TextWordGet, CRLF) {
 237   AutoText input("abc\r\nd");
 238   AssemblyContext data(input, nullptr);
 239   std::string word;
 240   spv_position_t pos = {};
 241   ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &pos));
 242   EXPECT_EQ(3u, pos.column);
 243   EXPECT_STREQ("abc", word.c_str());
 244   data.setPosition(pos);
 245   data.advance();
 246   ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &pos));
 247   EXPECT_EQ(1u, pos.column);
 248   EXPECT_STREQ("d", word.c_str());
 249 }
 250
 251 }  // anonymous namespace