Move tests to the namespace of the code under test (#3244)

Rationale: this convention avoids forcing closely-related code to be far
apart in the namespace hierarchy, and vice versa. By the same token, it
makes the namespace hierarchy more consistent with the directory
hierarchy.

common/check_test.cpp

@@ -6,7 +6,7 @@
 
 #include <gtest/gtest.h>
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 TEST(CheckTest, CheckTrue) { CARBON_CHECK(true); }
@@ -59,4 +59,4 @@ TEST(ErrorTest, FatalNoReturnRequired) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

common/command_line_test.cpp

@@ -10,16 +10,17 @@
 #include "llvm/Support/FormatVariadic.h"
 #include "testing/base/test_raw_ostream.h"
 
-namespace Carbon::Testing {
+namespace Carbon::CommandLine {
 namespace {
 
+using ::Carbon::Testing::TestRawOstream;
 using ::testing::ElementsAre;
 using ::testing::Eq;
 using ::testing::HasSubstr;
 using ::testing::Not;
 using ::testing::StrEq;
 
-constexpr CommandLine::CommandInfo TestCommandInfo = {
+constexpr CommandInfo TestCommandInfo = {
     .name = "test",
     .help = "A test command.",
     .help_epilogue = "TODO",
@@ -40,7 +41,7 @@ TEST(ArgParserTest, BasicCommand) {
   int integer_option = -1;
   llvm::StringRef string_option = "";
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args) {
-    return CommandLine::Parse(
+    return Parse(
         args, llvm::errs(), llvm::errs(), TestCommandInfo, [&](auto& b) {
           b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
           b.AddIntegerOption({.name = "option1"},
@@ -52,7 +53,7 @@ TEST(ArgParserTest, BasicCommand) {
   };
 
   EXPECT_THAT(parse({"--flag", "--option2=value", "--option1=42"}),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
   EXPECT_THAT(integer_option, Eq(42));
   EXPECT_THAT(string_option, StrEq("value"));
@@ -61,46 +62,43 @@ TEST(ArgParserTest, BasicCommand) {
 TEST(ArgParserTest, BooleanFlags) {
   bool flag = false;
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
       b.Do([] {});
     });
   };
 
-  EXPECT_THAT(parse({"--no-flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"--no-flag"}, llvm::errs()), Eq(ParseResult::Success));
   EXPECT_FALSE(flag);
 
   EXPECT_THAT(parse({"--flag", "--no-flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_FALSE(flag);
 
   EXPECT_THAT(parse({"--no-flag", "--flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
 
   EXPECT_THAT(parse({"--no-flag", "--flag", "--flag=false"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_FALSE(flag);
 
   EXPECT_THAT(parse({"--no-flag", "--flag=true"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
 
   EXPECT_THAT(parse({"--no-flag", "--flag=true", "--no-flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_FALSE(flag);
 
   TestRawOstream os;
-  EXPECT_THAT(parse({"--no-flag=true"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--no-flag=true"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(
       os.TakeStr(),
       StrEq("ERROR: Cannot specify a value when using a flag name prefixed "
             "with 'no-' -- that prefix implies a value of 'false'.\n"));
 
-  EXPECT_THAT(parse({"--no-flag=false"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--no-flag=false"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(
       os.TakeStr(),
       StrEq("ERROR: Cannot specify a value when using a flag name prefixed "
@@ -112,7 +110,7 @@ TEST(ArgParserTest, ArgDefaults) {
   int integer_option = -1;
   llvm::StringRef string_option = "";
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddFlag({.name = "flag"}, [&](auto& arg_b) {
         arg_b.Default(true);
         arg_b.Set(&flag);
@@ -129,19 +127,19 @@ TEST(ArgParserTest, ArgDefaults) {
     });
   };
 
-  EXPECT_THAT(parse({}, llvm::errs()), Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({}, llvm::errs()), Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
   EXPECT_THAT(integer_option, Eq(7));
   EXPECT_THAT(string_option, StrEq("default"));
 
   EXPECT_THAT(parse({"--option1", "--option2"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
   EXPECT_THAT(integer_option, Eq(7));
   EXPECT_THAT(string_option, StrEq("default"));
 
   EXPECT_THAT(parse({"--option1=42", "--option2=explicit"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
   EXPECT_THAT(integer_option, Eq(42));
   EXPECT_THAT(string_option, StrEq("explicit"));
@@ -149,7 +147,7 @@ TEST(ArgParserTest, ArgDefaults) {
   EXPECT_THAT(
       parse({"--option1=42", "--option2=explicit", "--option1", "--option2"},
             llvm::errs()),
-      Eq(CommandLine::ParseResult::Success));
+      Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
   EXPECT_THAT(integer_option, Eq(7));
   EXPECT_THAT(string_option, StrEq("default"));
@@ -160,7 +158,7 @@ TEST(ArgParserTest, ShortArgs) {
   bool example = false;
   int integer_option = -1;
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddFlag({.name = "flag", .short_name = "f"},
                 [&](auto& arg_b) { arg_b.Set(&flag); });
       b.AddFlag({.name = "example", .short_name = "x"},
@@ -177,7 +175,7 @@ TEST(ArgParserTest, ShortArgs) {
   };
 
   EXPECT_THAT(parse({"-f", "-o=42", "-x"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
   EXPECT_TRUE(example);
   EXPECT_THAT(integer_option, Eq(42));
@@ -185,18 +183,18 @@ TEST(ArgParserTest, ShortArgs) {
   flag = false;
   example = false;
   EXPECT_THAT(parse({"--option1=13", "-xfo"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
   EXPECT_TRUE(example);
   EXPECT_THAT(integer_option, Eq(123));
 
   TestRawOstream os;
-  EXPECT_THAT(parse({"-xzf"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"-xzf"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(),
               StrEq("ERROR: Option '-z' (short for '--option2') requires a "
                     "value to be provided and none was.\n"));
 
-  EXPECT_THAT(parse({"-xz=123"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"-xz=123"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(
       os.TakeStr(),
       StrEq("ERROR: Cannot provide a value to the group of multiple short "
@@ -210,7 +208,7 @@ TEST(ArgParserTest, PositionalArgs) {
   llvm::StringRef source_string;
   llvm::StringRef dest_string;
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
       b.AddStringOption({.name = "option"},
                         [&](auto& arg_b) { arg_b.Set(&string_option); });
@@ -227,27 +225,25 @@ TEST(ArgParserTest, PositionalArgs) {
   };
 
   TestRawOstream os;
-  EXPECT_THAT(parse({"--flag", "--option=x"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--flag", "--option=x"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(
       os.TakeStr(),
       StrEq("ERROR: Not all required positional arguments were provided. First "
             "missing and required positional argument: 'source'\n"));
 
   EXPECT_THAT(parse({"src", "--flag", "--option=value", "dst"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
   EXPECT_THAT(string_option, StrEq("value"));
   EXPECT_THAT(source_string, StrEq("src"));
   EXPECT_THAT(dest_string, StrEq("dst"));
 
   EXPECT_THAT(parse({"src2", "--", "dst2"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(source_string, StrEq("src2"));
   EXPECT_THAT(dest_string, StrEq("dst2"));
 
-  EXPECT_THAT(parse({"-", "--", "-"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"-", "--", "-"}, llvm::errs()), Eq(ParseResult::Success));
   EXPECT_THAT(source_string, StrEq("-"));
   EXPECT_THAT(dest_string, StrEq("-"));
 }
@@ -258,7 +254,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
   llvm::SmallVector<llvm::StringRef> source_strings;
   llvm::SmallVector<llvm::StringRef> dest_strings;
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
       b.AddStringOption({.name = "option"},
                         [&](auto& arg_b) { arg_b.Set(&string_option); });
@@ -275,8 +271,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
   };
 
   TestRawOstream os;
-  EXPECT_THAT(parse({"--flag", "--option=x"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--flag", "--option=x"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(
       os.TakeStr(),
       StrEq("ERROR: Not all required positional arguments were provided. First "
@@ -285,7 +280,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
   EXPECT_THAT(
       parse({"src1", "--flag", "src2", "--option=value", "--", "--dst--"},
             llvm::errs()),
-      Eq(CommandLine::ParseResult::Success));
+      Eq(ParseResult::Success));
   EXPECT_TRUE(flag);
   EXPECT_THAT(string_option, StrEq("value"));
   EXPECT_THAT(source_strings, ElementsAre(StrEq("src1"), StrEq("src2")));
@@ -295,7 +290,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
   dest_strings.clear();
   EXPECT_THAT(
       parse({"--", "--src1--", "--src2--", "--", "dst1", "dst2"}, llvm::errs()),
-      Eq(CommandLine::ParseResult::Success));
+      Eq(ParseResult::Success));
   EXPECT_THAT(source_strings,
               ElementsAre(StrEq("--src1--"), StrEq("--src2--")));
   EXPECT_THAT(dest_strings, ElementsAre(StrEq("dst1"), StrEq("dst2")));
@@ -303,7 +298,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
   source_strings.clear();
   dest_strings.clear();
   EXPECT_THAT(parse({"--", "--", "dst1", "dst2"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(source_strings, ElementsAre());
   EXPECT_THAT(dest_strings, ElementsAre(StrEq("dst1"), StrEq("dst2")));
 }
@@ -317,7 +312,7 @@ TEST(ArgParserTest, BasicSubcommands) {
   bool subsub_command = false;
 
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddSubcommand({.name = "sub1"}, [&](auto& sub_b) {
         sub_b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
         sub_b.AddStringOption({.name = "option"},
@@ -339,40 +334,39 @@ TEST(ArgParserTest, BasicSubcommands) {
   };
 
   TestRawOstream os;
-  EXPECT_THAT(parse({}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq("ERROR: No subcommand specified. Available "
                                   "subcommands: 'sub1', 'sub2', or 'help'\n"));
 
-  EXPECT_THAT(parse({"--flag"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--flag"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Unknown option '--flag'\n"));
 
-  EXPECT_THAT(parse({"sub3"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"sub3"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Invalid subcommand 'sub3'. Available "
                                   "subcommands: 'sub1', 'sub2', or 'help'\n"));
 
-  EXPECT_THAT(parse({"--flag", "sub1"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--flag", "sub1"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Unknown option '--flag'\n"));
 
   EXPECT_THAT(parse({"sub1", "--flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(subcommand, Eq(TestSubcommand::Sub1));
   EXPECT_TRUE(flag);
 
   EXPECT_THAT(parse({"sub2", "--option=value"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(subcommand, Eq(TestSubcommand::Sub2));
   EXPECT_THAT(option1, StrEq("value"));
 
   EXPECT_THAT(parse({"sub2", "--option=abc", "subsub42", "--option=xyz"}, os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(),
               StrEq("ERROR: Invalid subcommand 'subsub42'. Available "
                     "subcommands: 'subsub', or 'help'\n"));
 
   EXPECT_THAT(
       parse({"sub2", "--option=abc", "subsub", "--option=xyz"}, llvm::errs()),
-      Eq(CommandLine::ParseResult::Success));
+      Eq(ParseResult::Success));
   EXPECT_TRUE(subsub_command);
   EXPECT_THAT(option1, StrEq("abc"));
   EXPECT_THAT(option2, StrEq("xyz"));
@@ -382,7 +376,7 @@ TEST(ArgParserTest, Appending) {
   llvm::SmallVector<int> integers;
   llvm::SmallVector<llvm::StringRef> strings;
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddIntegerOption({.name = "int"},
                          [&](auto& arg_b) { arg_b.Append(&integers); });
       b.AddStringOption({.name = "str"},
@@ -391,22 +385,22 @@ TEST(ArgParserTest, Appending) {
     });
   };
 
-  EXPECT_THAT(parse({}, llvm::errs()), Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({}, llvm::errs()), Eq(ParseResult::Success));
   EXPECT_THAT(integers, ElementsAre());
   EXPECT_THAT(strings, ElementsAre());
 
   EXPECT_THAT(parse({"--int=1", "--int=2", "--int=3"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(integers, ElementsAre(Eq(1), Eq(2), Eq(3)));
   EXPECT_THAT(strings, ElementsAre());
 
   EXPECT_THAT(parse({"--str=a", "--str=b", "--str=c"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(integers, ElementsAre(Eq(1), Eq(2), Eq(3)));
   EXPECT_THAT(strings, ElementsAre(StrEq("a"), StrEq("b"), StrEq("c")));
 
   EXPECT_THAT(parse({"--str=d", "--int=4", "--str=e"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(integers, ElementsAre(Eq(1), Eq(2), Eq(3), Eq(4)));
   EXPECT_THAT(strings, ElementsAre(StrEq("a"), StrEq("b"), StrEq("c"),
                                    StrEq("d"), StrEq("e")));
@@ -418,7 +412,7 @@ TEST(ArgParserTest, PositionalAppending) {
   llvm::SmallVector<llvm::StringRef> strings2;
   llvm::SmallVector<llvm::StringRef> strings3;
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddStringOption({.name = "opt"},
                         [&](auto& arg_b) { arg_b.Append(&option_strings); });
       b.AddStringPositionalArg({.name = "s1"},
@@ -434,7 +428,7 @@ TEST(ArgParserTest, PositionalAppending) {
   EXPECT_THAT(parse({"a", "--opt=x", "b", "--opt=y", "--", "c", "--opt=z", "d",
                      "--", "e", "f"},
                     llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(option_strings, ElementsAre(StrEq("x"), StrEq("y")));
   EXPECT_THAT(strings1, ElementsAre(StrEq("a"), StrEq("b")));
   EXPECT_THAT(strings2, ElementsAre(StrEq("c"), StrEq("--opt=z"), StrEq("d")));
@@ -444,7 +438,7 @@ TEST(ArgParserTest, PositionalAppending) {
 TEST(ArgParserTest, OneOfOption) {
   int value = 0;
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddOneOfOption({.name = "option"}, [&](auto& arg_b) {
         arg_b.SetOneOf(
             {
@@ -458,44 +452,40 @@ TEST(ArgParserTest, OneOfOption) {
     });
   };
 
-  EXPECT_THAT(parse({"--option=x"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"--option=x"}, llvm::errs()), Eq(ParseResult::Success));
   EXPECT_THAT(value, Eq(1));
 
-  EXPECT_THAT(parse({"--option=y"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"--option=y"}, llvm::errs()), Eq(ParseResult::Success));
   EXPECT_THAT(value, Eq(2));
 
-  EXPECT_THAT(parse({"--option=z"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"--option=z"}, llvm::errs()), Eq(ParseResult::Success));
   EXPECT_THAT(value, Eq(3));
 
   constexpr const char* ErrorStr =
       "ERROR: Option '--option={0}' has an invalid value '{0}'; valid values "
       "are: 'x', 'y', or 'z'\n";
   TestRawOstream os;
-  EXPECT_THAT(parse({"--option=a"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--option=a"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "a")));
 
-  EXPECT_THAT(parse({"--option="}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--option="}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "")));
 
-  EXPECT_THAT(parse({"--option=xx"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--option=xx"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "xx")));
 
-  EXPECT_THAT(parse({"--option=\xFF"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--option=\xFF"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "\\FF")));
 
   EXPECT_THAT(parse({llvm::StringRef("--option=\0", 10)}, os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "\\00")));
 }
 
 TEST(ArgParserTest, OneOfOptionAppending) {
   llvm::SmallVector<int> values;
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddOneOfOption({.name = "option"}, [&](auto& arg_b) {
         arg_b.AppendOneOf(
             {
@@ -509,15 +499,15 @@ TEST(ArgParserTest, OneOfOptionAppending) {
     });
   };
 
-  EXPECT_THAT(parse({}, llvm::errs()), Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({}, llvm::errs()), Eq(ParseResult::Success));
   EXPECT_THAT(values, ElementsAre());
 
   EXPECT_THAT(parse({"--option=x", "--option=y", "--option=z"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(values, ElementsAre(Eq(1), Eq(2), Eq(3)));
 
   EXPECT_THAT(parse({"--option=y", "--option=y", "--option=x"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(values, ElementsAre(Eq(1), Eq(2), Eq(3), Eq(2), Eq(2), Eq(1)));
 }
 
@@ -531,7 +521,7 @@ TEST(ArgParserTest, RequiredArgs) {
   TestEnum enum_sub_option;
 
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
       b.AddIntegerOption({.name = "opt1"}, [&](auto& arg_b) {
         arg_b.Required(true);
         arg_b.Set(&integer_option);
@@ -578,28 +568,28 @@ TEST(ArgParserTest, RequiredArgs) {
   constexpr const char* ErrorStr =
       "ERROR: Required option '{0}' not provided.\n";
   TestRawOstream os;
-  EXPECT_THAT(parse({}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({}, os), Eq(ParseResult::Error));
   auto errors = os.TakeStr();
   EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--opt1")));
   EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--opt2")));
 
-  EXPECT_THAT(parse({"--opt2=xyz"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--opt2=xyz"}, os), Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "--opt1")));
 
   EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(integer_option, Eq(42));
   EXPECT_THAT(string_option, StrEq("xyz"));
 
   EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2"}, os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
   errors = os.TakeStr();
   EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt1")));
   EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt2")));
   EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt3")));
 
   EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b"}, os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
   errors = os.TakeStr();
   EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt1")));
   EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt2")));
@@ -608,13 +598,13 @@ TEST(ArgParserTest, RequiredArgs) {
   EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b",
                      "--sub-opt1=13"},
                     os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "--sub-opt2")));
 
   EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b",
                      "--sub-opt1=13", "--sub-opt2=abc"},
                     llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
   EXPECT_THAT(integer_option, Eq(42));
   EXPECT_THAT(string_option, StrEq("xyz"));
   EXPECT_THAT(subcommand, Eq(TestSubcommand::Sub2));
@@ -628,7 +618,7 @@ TEST(ArgParserTest, HelpAndVersion) {
   int storage = -1;
   llvm::StringRef string = "";
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(  // Force line break.
+    return Parse(  // Force line break.
         args, s, s,
         {
             .name = "test",
@@ -747,8 +737,7 @@ A hidden subcommand.
   };
 
   TestRawOstream os;
-  EXPECT_THAT(parse({"--flag", "--help"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"--flag", "--help"}, os), Eq(ParseResult::MetaSuccess));
   std::string help_flag_output = os.TakeStr();
   EXPECT_THAT(help_flag_output, StrEq(llvm::StringRef(R"""(
 Test Command -- version 1.2.3
@@ -790,11 +779,10 @@ Closing remarks.
 
 )""")
                                           .ltrim('\n')));
-  EXPECT_THAT(parse({"help"}, os), Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"help"}, os), Eq(ParseResult::MetaSuccess));
   EXPECT_THAT(os.TakeStr(), StrEq(help_flag_output));
 
-  EXPECT_THAT(parse({"--version"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"--version"}, os), Eq(ParseResult::MetaSuccess));
   std::string version_flag_output = os.TakeStr();
   EXPECT_THAT(version_flag_output, StrEq(llvm::StringRef(R"""(
 Test Command -- version 1.2.3
@@ -803,12 +791,11 @@ Build timestamp: )""" __TIMESTAMP__ R"""(
 Build config: test-config-info
 )""")
                                              .ltrim('\n')));
-  EXPECT_THAT(parse({"version"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"version"}, os), Eq(ParseResult::MetaSuccess));
   EXPECT_THAT(os.TakeStr(), StrEq(version_flag_output));
 
   EXPECT_THAT(parse({"--flag", "edit", "--option=42", "--help"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+              Eq(ParseResult::MetaSuccess));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::StringRef(R"""(
 Edit the widget.
 
@@ -834,7 +821,7 @@ That's all.
                                       .ltrim('\n')));
 
   EXPECT_THAT(parse({"--flag", "run", "--option=abc", "--help"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+              Eq(ParseResult::MetaSuccess));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::StringRef(R"""(
 Run wombats across the screen.
 
@@ -871,7 +858,7 @@ Or it won't, who knows.
 TEST(ArgParserTest, HelpMarkdownLike) {
   bool flag = false;
   auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(  // Force line break.
+    return Parse(  // Force line break.
         args, s, s, {.name = "test"}, [&](auto& b) {
           b.AddFlag(
               {
@@ -902,7 +889,7 @@ x
   };
 
   TestRawOstream os;
-  EXPECT_THAT(parse({"--help"}, os), Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"--help"}, os), Eq(ParseResult::MetaSuccess));
   EXPECT_THAT(os.TakeStr(), StrEq(llvm::StringRef(R"""(
 Usage:
   test [--flag]
@@ -935,4 +922,4 @@ Options:
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon::CommandLine

common/enum_base_test.cpp

@@ -8,7 +8,7 @@
 
 #include "testing/base/test_raw_ostream.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 // These are directly in the Carbon namespace because the defines require it.
@@ -45,7 +45,7 @@ TEST(EnumBaseTest, NamesAndConstants) {
 }
 
 TEST(EnumBaseTest, Printing) {
-  TestRawOstream stream;
+  Testing::TestRawOstream stream;
 
   TestKind kind = TestKind::Beep;
   stream << kind << " " << TestKind::Beep;
@@ -109,4 +109,4 @@ TEST(EnumBaseTest, IntConversion) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

common/error_test.cpp

@@ -8,7 +8,7 @@
 
 #include "testing/base/test_raw_ostream.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 TEST(ErrorTest, Error) {
@@ -107,10 +107,10 @@ TEST(ErrorTest, ErrorBuilderOperatorImplicitCast) {
 
 TEST(ErrorTest, StreamError) {
   Error result = ErrorBuilder("TestFunc") << "msg";
-  TestRawOstream result_stream;
+  Testing::TestRawOstream result_stream;
   result_stream << result;
   EXPECT_EQ(result_stream.TakeStr(), "TestFunc: msg");
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

common/indirect_value_test.cpp

@@ -8,7 +8,7 @@
 
 #include <string>
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 TEST(IndirectValueTest, ConstAccess) {
@@ -126,4 +126,4 @@ TEST(IndirectValueTest, IncompleteType) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

common/string_helpers_test.cpp

@@ -14,7 +14,7 @@
 using ::testing::Eq;
 using ::testing::Optional;
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 TEST(UnescapeStringLiteral, Valid) {
@@ -230,4 +230,4 @@ TEST(ParseBlockStringLiteral, OkMultipleSlashes) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

docs/project/cpp_style_guide.md

@@ -147,8 +147,8 @@ these.
     namespaces. `static` minimizes the context necessary to notice the internal
     linkage of a definition.
     -   Anonymous namespaces are still necessary for classes and enums.
-    -   Tests are an exception and should typically be wrapped with
-        `namespace Carbon::Testing { namespace { ... } }` to keep everything
+    -   Tests are an exception and should typically be wrapped in an anonymous
+        namespace under the namespace of the code under test, to keep everything
         internal.
 
 ### Copyable and movable types

explorer/ast/ast_test_matchers_test.cpp

@@ -13,7 +13,7 @@
 #include "explorer/ast/statement.h"
 #include "explorer/base/arena.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 using ::testing::_;
@@ -159,4 +159,4 @@ TEST(ASTDeclarationsTest, BasicUsage) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

explorer/ast/element_test.cpp

@@ -16,7 +16,7 @@
 #include "explorer/base/arena.h"
 #include "llvm/Support/Casting.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 static auto FakeSourceLoc(int line_num) -> SourceLocation {
@@ -93,4 +93,4 @@ TEST_F(ElementTest, BaseElementIsNamed) {
   EXPECT_FALSE(element.IsNamed("anything"));
 }
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

explorer/ast/expression_test.cpp

@@ -13,7 +13,7 @@
 #include "explorer/base/arena.h"
 #include "llvm/Support/Casting.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 using llvm::cast;
@@ -135,4 +135,4 @@ TEST_F(ExpressionTest, BinaryAsTuple) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

explorer/ast/pattern_test.cpp

@@ -12,7 +12,7 @@
 #include "explorer/base/arena.h"
 #include "llvm/Support/Casting.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 using llvm::cast;
@@ -129,4 +129,4 @@ TEST_F(PatternTest, BinaryAsTuplePattern) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

explorer/base/error_builders_test.cpp

@@ -9,7 +9,7 @@
 #include "explorer/base/source_location.h"
 #include "testing/base/test_raw_ostream.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 TEST(ErrorBuildersTest, ProgramError) {
@@ -17,10 +17,10 @@ TEST(ErrorBuildersTest, ProgramError) {
   EXPECT_EQ(err.location(), "x:1");
   EXPECT_EQ(err.message(), "test");
 
-  TestRawOstream out;
+  Testing::TestRawOstream out;
   out << err;
   EXPECT_EQ(out.TakeStr(), "x:1: test");
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

explorer/base/set_file_context_raii_test.cpp

@@ -7,7 +7,7 @@
 
 #include "explorer/base/trace_stream.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 TEST(SetFileContextRaiiTest, UpdateFileContext) {
@@ -34,4 +34,4 @@ TEST(SetFileContextRaiiTest, UpdateFileContext) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

explorer/base/set_program_phase_raii_test.cpp

@@ -7,7 +7,7 @@
 
 #include "explorer/base/trace_stream.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 TEST(SetProgramPhaseRaiiTest, Simple) {
@@ -33,4 +33,4 @@ TEST(SetProgramPhaseRaiiTest, UpdatePhase) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

explorer/parse_and_execute/parse_and_execute_test.cpp

@@ -7,7 +7,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 using ::testing::MatchesRegex;
@@ -53,4 +53,4 @@ TEST(ParseAndExecuteTest, Recursion) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

explorer/syntax/parse_test.cpp

@@ -12,7 +12,7 @@
 
 #include "explorer/base/arena.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 static constexpr std::string_view FileContents = R"(
@@ -31,4 +31,4 @@ TEST(ParseTest, ParseFromString) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

explorer/syntax/unimplemented_example_test.cpp

@@ -9,7 +9,7 @@
 #include "explorer/syntax/parse.h"
 #include "explorer/syntax/parse_test_matchers.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 using ::testing::ElementsAre;
@@ -34,4 +34,4 @@ TEST(UnimplementedExampleTest, VerifyPrecedence) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

toolchain/diagnostics/diagnostic_emitter_test.cpp

@@ -10,9 +10,11 @@
 #include "llvm/ADT/StringRef.h"
 #include "toolchain/diagnostics/mocks.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
+using ::Carbon::Testing::IsDiagnostic;
+
 struct FakeDiagnosticLocationTranslator : DiagnosticLocationTranslator<int> {
   auto GetLocation(int n) -> DiagnosticLocation override {
     return {.line_number = 1, .column_number = n};
@@ -68,4 +70,4 @@ TEST_F(DiagnosticEmitterTest, EmitNote) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

toolchain/diagnostics/sorting_diagnostic_consumer_test.cpp

@@ -11,9 +11,10 @@
 #include "toolchain/diagnostics/diagnostic_emitter.h"
 #include "toolchain/diagnostics/mocks.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
+using ::Carbon::Testing::IsDiagnostic;
 using ::testing::InSequence;
 
 CARBON_DIAGNOSTIC(TestDiagnostic, Error, "{0}", llvm::StringRef);
@@ -61,4 +62,4 @@ TEST(SortedDiagnosticEmitterTest, SortErrors) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

toolchain/driver/driver_test.cpp

@@ -17,14 +17,17 @@
 #include "testing/base/test_raw_ostream.h"
 #include "toolchain/testing/yaml_test_helpers.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
+using ::Carbon::Testing::TestRawOstream;
 using ::testing::_;
 using ::testing::ContainsRegex;
 using ::testing::HasSubstr;
 using ::testing::StrEq;
 
+namespace Yaml = ::Carbon::Testing::Yaml;
+
 // Reads a file to string.
 // TODO: Extract this to a helper and share it with other tests.
 static auto ReadFile(std::filesystem::path path) -> std::string {
@@ -189,4 +192,4 @@ TEST_F(DriverTest, FileOutput) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon

toolchain/lex/numeric_literal_test.cpp

@@ -11,10 +11,9 @@
 #include "toolchain/diagnostics/diagnostic_emitter.h"
 #include "toolchain/lex/test_helpers.h"
 
-namespace Carbon::Testing {
+namespace Carbon::Lex {
 namespace {
 
-using Lex::NumericLiteral;
 using ::testing::_;
 using ::testing::Field;
 using ::testing::Matcher;
@@ -328,4 +327,4 @@ TEST_F(NumericLiteralTest, TooManyDigits) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon::Lex

toolchain/lex/string_literal_test.cpp

@@ -11,11 +11,9 @@
 #include "toolchain/diagnostics/diagnostic_emitter.h"
 #include "toolchain/lex/test_helpers.h"
 
-namespace Carbon::Testing {
+namespace Carbon::Lex {
 namespace {
 
-using Lex::StringLiteral;
-
 class StringLiteralTest : public ::testing::Test {
  protected:
   StringLiteralTest() : error_tracker(ConsoleDiagnosticConsumer()) {}
@@ -347,4 +345,4 @@ TEST_F(StringLiteralTest, UnicodeTooManyDigits) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon::Lex

toolchain/lex/token_kind_test.cpp

@@ -9,10 +9,9 @@
 
 #include "llvm/ADT/StringRef.h"
 
-namespace Carbon::Testing {
+namespace Carbon::Lex {
 namespace {
 
-using Lex::TokenKind;
 using ::testing::MatchesRegex;
 
 // We restrict symbols to punctuation characters that are expected to be widely
@@ -85,4 +84,4 @@ TEST(TokenKindTest, SymbolsInDescendingLength) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon::Lex

toolchain/lex/tokenized_buffer_test.cpp

@@ -17,18 +17,20 @@
 #include "toolchain/lex/tokenized_buffer_test_helpers.h"
 #include "toolchain/testing/yaml_test_helpers.h"
 
-namespace Carbon::Testing {
+namespace Carbon::Lex {
 namespace {
 
-using Lex::Token;
-using Lex::TokenizedBuffer;
-using Lex::TokenKind;
+using ::Carbon::Testing::ExpectedToken;
+using ::Carbon::Testing::IsDiagnostic;
+using ::Carbon::Testing::TestRawOstream;
 using ::testing::_;
 using ::testing::ElementsAre;
 using ::testing::Eq;
 using ::testing::HasSubstr;
 using ::testing::Pair;
 
+namespace Yaml = ::Carbon::Testing::Yaml;
+
 class LexerTest : public ::testing::Test {
  protected:
   auto GetSourceBuffer(llvm::StringRef text) -> SourceBuffer& {
@@ -1030,4 +1032,4 @@ TEST_F(LexerTest, PrintingAsYaml) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon::Lex

toolchain/parse/precedence_test.cpp

@@ -9,12 +9,9 @@
 
 #include "toolchain/lex/token_kind.h"
 
-namespace Carbon::Testing {
+namespace Carbon::Parse {
 namespace {
 
-using Parse::Associativity;
-using Parse::OperatorPriority;
-using Parse::PrecedenceGroup;
 using ::testing::Eq;
 
 TEST(PrecedenceTest, OperatorsAreRecognized) {
@@ -158,4 +155,4 @@ TEST(PrecedenceTest, IncomparableOperators) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon::Parse

toolchain/parse/tree_test.cpp

@@ -15,13 +15,15 @@
 #include "toolchain/lex/tokenized_buffer.h"
 #include "toolchain/testing/yaml_test_helpers.h"
 
-namespace Carbon::Testing {
+namespace Carbon::Parse {
 namespace {
 
-using Parse::Tree;
+using ::Carbon::Testing::TestRawOstream;
 using ::testing::ElementsAre;
 using ::testing::Pair;
 
+namespace Yaml = ::Carbon::Testing::Yaml;
+
 class TreeTest : public ::testing::Test {
  protected:
   auto GetSourceBuffer(llvm::StringRef t) -> SourceBuffer& {
@@ -126,4 +128,4 @@ TEST_F(TreeTest, HighRecursion) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon::Parse

toolchain/sem_ir/file_test.cpp

@@ -12,9 +12,10 @@
 #include "toolchain/driver/driver.h"
 #include "toolchain/testing/yaml_test_helpers.h"
 
-namespace Carbon::Testing {
+namespace Carbon::SemIR {
 namespace {
 
+using ::Carbon::Testing::TestRawOstream;
 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::Contains;
@@ -25,6 +26,8 @@ using ::testing::MatchesRegex;
 using ::testing::Pair;
 using ::testing::SizeIs;
 
+namespace Yaml = ::Carbon::Testing::Yaml;
+
 TEST(SemIRTest, YAML) {
   llvm::vfs::InMemoryFileSystem fs;
   CARBON_CHECK(fs.addFile(
@@ -77,4 +80,4 @@ TEST(SemIRTest, YAML) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon::SemIR

toolchain/source/source_buffer_test.cpp

@@ -10,7 +10,7 @@
 #include "llvm/Support/VirtualFileSystem.h"
 #include "toolchain/diagnostics/diagnostic_emitter.h"
 
-namespace Carbon::Testing {
+namespace Carbon {
 namespace {
 
 static constexpr llvm::StringLiteral TestFileName = "test.carbon";
@@ -66,4 +66,4 @@ TEST(SourceBufferTest, EmptyFile) {
 }
 
 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon