Unit test for spellchecking 96- through 102-character words

chrome/tools/convert_dict/aff_reader.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/tools/convert_dict/aff_reader.h"
 
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 236 matching lines @@
           std::string before_flags = part.substr(0, slash_index + 1);
 
           // After the slash are both the flags, then whitespace, then the part
           // that tells us what to strip.
           std::vector<std::string> after_slash;
           base::SplitString(part.substr(slash_index + 1), ' ', &after_slash);
           if (after_slash.size() == 0) {
             printf("ERROR: Found 0 terms after slash in affix rule '%s', "
                       "but need at least 2.\n",
                    part.c_str());
-            return;
+            exit(1);
           }
           if (after_slash.size() == 1) {
             printf("WARNING: Found 1 term after slash in affix rule '%s', "
                       "but expected at least 2. Adding '.'.\n",
                    part.c_str());
             after_slash.push_back(".");
           }
           // Note that we may get a third term here which is the morphological
           // description of this rule. This happens in the tests only, so we can
           // just ignore it.
 
           part = base::StringPrintf("%s%d %s",
                                     before_flags.c_str(),
                                     GetAFIndexForAFString(after_slash[0]),
                                     after_slash[1].c_str());
         }
 
         // Reencode from here
         std::string reencoded;
         if (!EncodingToUTF8(part, &reencoded)) {
           printf("ERROR: Cannot encode affix rule part '%s' to utf8.\n",
                  part.c_str());
-          break;
+          exit(1);
         }
 
         *rule = rule->substr(0, part_start) + reencoded;
         break;
       }
       token.clear();
     } else {
       token.push_back((*rule)[i]);
     }
   }
 
   affix_rules_.push_back(*rule);
 }
 
 void AffReader::AddReplacement(std::string* rule) {
   TrimLine(rule);
   CollapseDuplicateSpaces(rule);
 
   std::string utf8rule;
   if (!EncodingToUTF8(*rule, &utf8rule)) {
     printf("ERROR: Cannot encode replacement rule '%s' to utf8.\n",
            rule->c_str());
-    return;
+    exit(1);
   }
 
   // The first space separates key and value.
   size_t space_index = utf8rule.find(' ');
   if (space_index == std::string::npos) {
     printf("ERROR: Did not find a space in '%s'.\n", utf8rule.c_str());
-    return;
+    exit(1);
   }
   std::vector<std::string> split;
   split.push_back(utf8rule.substr(0, space_index));
   split.push_back(utf8rule.substr(space_index + 1));
 
   // Underscores are used to represent spaces in most aff files
   // (since the line is parsed on spaces).
   std::replace(split[0].begin(), split[0].end(), '_', ' ');
   std::replace(split[1].begin(), split[1].end(), '_', ' ');
 
   replacements_.push_back(std::make_pair(split[0], split[1]));
 }
 
 void AffReader::HandleRawCommand(const std::string& line) {
   other_commands_.push_back(line);
 }
 
 void AffReader::HandleEncodedCommand(const std::string& line) {
   std::string utf8;
   if (!EncodingToUTF8(line, &utf8)) {
     printf("ERROR: Cannot encode command '%s' to utf8.\n", line.c_str());
-    return;
+    exit(1);
   }
   other_commands_.push_back(utf8);
 }
 
 }  // namespace convert_dict