[randstruct] Add test for "-frandomize-layout-seed-file" flag

[void]

Summary

This test makes sure that the "-frandomize-layout-seed" and
"-frandomize-layout-seed-file" flags generate the same layout for the
record.

[aaron.ballman]

clang/unittests/AST/RandstructTest.cpp

43

I think this is a case where you want to use ASSERT_FALSE because if this fails, the rest of the test also fails.

59

Why not keep these as unique pointers and move them into the tuple? Then the callers don't have to call delete manually.

[void]

clang/unittests/AST/RandstructTest.cpp

43

There's an explanation below.

59

The d'tors for the unique_ptrs is called if I place them in the tuple. I think it's because I can't do something like this:

const unique_ptr<ASTUnit> std::tie(AST, ASTFileSeed) = makeAST(...);

in the test functions. When I assign it as a non-initializer, it apparently calls the d'tor. So, kinda stumped on what to do.

And the EXPECT_FALSE above is used because the ASSERT_FALSE adds an extra return point, which messes with the lambda.

[aaron.ballman]

LGTM but please wait a bit in case @MaskRay has comments.

clang/unittests/AST/RandstructTest.cpp

59

Okay, thank you for the explanations!

[MaskRay]

clang/unittests/AST/RandstructTest.cpp

39–40

constexpr llvm::StringLiteral Seed = ... or constexpr char Seed[]

41

Change this to a normal function

static std::pair<std::unique_ptr<ASTUnit>, std::unique_ptr<ASTUnit>>
makeAST(llvm::StringRef SourceCode) {

59

I think std::unique_ptr should and can be used here. See comment above.

85

return getFieldNamesFromRecord(LHSRD) == getFieldNamesFromRecord(RHSRD);

[void]

clang/unittests/AST/RandstructTest.cpp

59

Yeah, it's just that it doesn't work. I actually tried it a lot of different ways before, of course, and it just doesn't work. Sorry about that.

/usr/local/google/home/morbo/llvm/llvm-project/clang/unittests/AST/RandstructTest.cpp:73:10: error: no matching constructor for initialization of 'std::pair<std::unique_ptr<ASTUnit>, std::unique_ptr<ASTUnit>>'
  return std::pair<std::unique_ptr<ASTUnit>, std::unique_ptr<ASTUnit>>(AST, ASTFileSeed);
         ^                                                             ~~~~~~~~~~~~~~~~
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:266:17: note: candidate template ignored: requirement '_PCC<true, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>>::_ConstructiblePair()' was not satisfied [with _U1 = std::unique_ptr<clang::ASTUnit>, _U2 = std::unique_ptr<clang::ASTUnit>]
      constexpr pair(const _T1& __a, const _T2& __b)
                ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:276:26: note: candidate template ignored: requirement '_PCC<true, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>>::_ConstructiblePair()' was not satisfied [with _U1 = std::unique_ptr<clang::ASTUnit>, _U2 = std::unique_ptr<clang::ASTUnit>]
      explicit constexpr pair(const _T1& __a, const _T2& __b)
                         ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:322:18: note: candidate template ignored: requirement '_PCC<true, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>>::_MoveCopyPair()' was not satisfied [with _U1 = std::unique_ptr<clang::ASTUnit> &]
       constexpr pair(_U1&& __x, const _T2& __y)
                 ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:329:27: note: candidate template ignored: requirement '_PCC<true, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>>::_MoveCopyPair()' was not satisfied [with _U1 = std::unique_ptr<clang::ASTUnit> &]
       explicit constexpr pair(_U1&& __x, const _T2& __y)
                          ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:336:18: note: candidate template ignored: requirement '_PCC<true, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>>::_CopyMovePair()' was not satisfied [with _U2 = std::unique_ptr<clang::ASTUnit> &]
       constexpr pair(const _T1& __x, _U2&& __y)
                 ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:343:17: note: candidate template ignored: requirement '_PCC<true, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>>::_CopyMovePair()' was not satisfied [with _U2 = std::unique_ptr<clang::ASTUnit> &]
       explicit pair(const _T1& __x, _U2&& __y)
                ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:352:12: note: candidate template ignored: requirement '_PCC<true, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>>::_MoveConstructiblePair()' was not satisfied [with _U1 = std::unique_ptr<clang::ASTUnit> &, _U2 = std::unique_ptr<clang::ASTUnit> &]
        constexpr pair(_U1&& __x, _U2&& __y)
                  ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:361:21: note: candidate template ignored: requirement '_PCC<true, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit>>>::_MoveConstructiblePair()' was not satisfied [with _U1 = std::unique_ptr<clang::ASTUnit> &, _U2 = std::unique_ptr<clang::ASTUnit> &]
        explicit constexpr pair(_U1&& __x, _U2&& __y)
                           ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:300:19: note: candidate constructor template not viable: requires single argument '__p', but 2 arguments were provided
        constexpr pair(const pair<_U1, _U2>& __p)
                  ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:309:21: note: candidate constructor template not viable: requires single argument '__p', but 2 arguments were provided
        explicit constexpr pair(const pair<_U1, _U2>& __p)
                           ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:314:17: note: candidate constructor not viable: requires 1 argument, but 2 were provided
      constexpr pair(const pair&) = default;    ///< Copy constructor
                ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:315:17: note: candidate constructor not viable: requires 1 argument, but 2 were provided
      constexpr pair(pair&&) = default;         ///< Move constructor
                ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:371:12: note: candidate constructor template not viable: requires single argument '__p', but 2 arguments were provided
        constexpr pair(pair<_U1, _U2>&& __p)
                  ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:381:21: note: candidate constructor template not viable: requires single argument '__p', but 2 arguments were provided
        explicit constexpr pair(pair<_U1, _U2>&& __p)
                           ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:387:9: note: candidate constructor template not viable: requires 3 arguments, but 2 were provided
        pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
        ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:232:26: note: candidate constructor template not viable: requires 0 arguments, but 2 were provided
      _GLIBCXX_CONSTEXPR pair()
                         ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:245:26: note: candidate constructor template not viable: requires 0 arguments, but 2 were provided
      explicit constexpr pair()
                         ^
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h:452:9: note: candidate constructor template not viable: requires 4 arguments, but 2 were provided
        pair(tuple<_Args1...>&, tuple<_Args2...>&,
        ^
1 error generated.

[MaskRay]

clang/unittests/AST/RandstructTest.cpp

59

I think it will work if you change makeAST a function and use

return {std::move(...), std::move(...)};

I have tested it locally.

[void]

Use "unique_ptr" when possible.

[void]

clang/unittests/AST/RandstructTest.cpp

59

I went a different path. PTAL.

[void]

Rebase.

clang/unittests/AST/RandstructTest.cpp

 #include "gtest/gtest.h"
 
 #include "DeclMatcher.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Testing/CommandLineArgs.h"
 #include "clang/Tooling/Tooling.h"
+#include "llvm/Support/ToolOutputFile.h"
 
 #include <vector>
 
 using namespace clang;
 using namespace clang::ast_matchers;
 using namespace clang::randstruct;
 
 using field_names = std::vector<std::string>;
 
-static std::unique_ptr<ASTUnit> makeAST(const std::string &SourceCode) {
-  std::vector<std::string> Args = getCommandLineArgsForTesting(Lang_C99);
-  Args.push_back("-frandomize-layout-seed=1234567890abcdef");
-
-  IgnoringDiagConsumer IgnoringConsumer = IgnoringDiagConsumer();
-
-  return tooling::buildASTFromCodeWithArgs(
-      SourceCode, Args, "input.c", "clang-tool",
-      std::make_shared<PCHContainerOperations>(),
-      tooling::getClangStripDependencyFileAdjuster(),
-      tooling::FileContentMappings(), &IgnoringConsumer);
-}
+constexpr const char Seed[] = "1234567890abcdef";
 
 static RecordDecl *getRecordDeclFromAST(const ASTContext &C,
                                         const std::string &Name) {
   RecordDecl *RD = FirstDeclMatcher<RecordDecl>().match(
       C.getTranslationUnitDecl(), recordDecl(hasName(Name)));
   return RD;
 }
 
 static std::vector<std::string> getFieldNamesFromRecord(const RecordDecl *RD) {
   std::vector<std::string> Fields;
 
   Fields.reserve(8);
   for (auto *Field : RD->fields())
     Fields.push_back(Field->getNameAsString());
 
   return Fields;
 }
 
 static bool isSubsequence(const field_names &Seq, const field_names &Subseq) {
   unsigned SeqLen = Seq.size();
   unsigned SubLen = Subseq.size();
 
   bool IsSubseq = false;
   for (unsigned I = 0; I < SeqLen; ++I)
     if (Seq[I] == Subseq[0]) {
       IsSubseq = true;
       for (unsigned J = 0; J + I < SeqLen && J < SubLen; ++J) {
         if (Seq[J + I] != Subseq[J]) {
           IsSubseq = false;
           break;
         }
       }
     }
 
   return IsSubseq;
 }
 
+static bool recordsEqual(const std::unique_ptr<ASTUnit> &LHS,
+                         const std::unique_ptr<ASTUnit> &RHS,
+                         const std::string &RecordName) {
+  const RecordDecl *LHSRD =
+      getRecordDeclFromAST(LHS->getASTContext(), RecordName);
+  const RecordDecl *RHSRD =
+      getRecordDeclFromAST(LHS->getASTContext(), RecordName);
+
+  return getFieldNamesFromRecord(LHSRD) == getFieldNamesFromRecord(RHSRD);
+}
+
+static std::unique_ptr<ASTUnit>
+makeAST(const std::string &SourceCode, bool ExpectError = false,
+        std::vector<std::string> RecordNames = std::vector<std::string>()) {
+  std::vector<std::string> Args = getCommandLineArgsForTesting(Lang_C99);
+  Args.push_back("-frandomize-layout-seed=" + std::string(Seed));
+
+  IgnoringDiagConsumer IgnoringConsumer = IgnoringDiagConsumer();
+
+  std::unique_ptr<ASTUnit> AST = tooling::buildASTFromCodeWithArgs(
+      SourceCode, Args, "input.c", "clang-tool",
+      std::make_shared<PCHContainerOperations>(),
+      tooling::getClangStripDependencyFileAdjuster(),
+      tooling::FileContentMappings(), &IgnoringConsumer);
+
+  int SeedFileFD = -1;
+  llvm::SmallString<256> SeedFilename;
+  EXPECT_FALSE(llvm::sys::fs::createTemporaryFile("seed", "rng", SeedFileFD,
+                                                  SeedFilename));
+  llvm::ToolOutputFile SeedFile(SeedFilename, SeedFileFD);
+  SeedFile.os() << Seed << "\n";
+
+  Args.clear();
+  Args = getCommandLineArgsForTesting(Lang_C99);
+  Args.push_back("-frandomize-layout-seed-file=" +
+                 SeedFile.getFilename().str());
+
+  std::unique_ptr<ASTUnit> ASTFileSeed = tooling::buildASTFromCodeWithArgs(
+      SourceCode, Args, "input.c", "clang-tool",
+      std::make_shared<PCHContainerOperations>(),
+      tooling::getClangStripDependencyFileAdjuster(),
+      tooling::FileContentMappings(), &IgnoringConsumer);
+
+  if (!ExpectError) {
+    if (RecordNames.empty())
+      RecordNames.push_back("test");
+
+    for (std::string Name : RecordNames)
+      EXPECT_TRUE(recordsEqual(AST, ASTFileSeed, Name));
+  }
+
+  return AST;
+}
+
 namespace clang {
 namespace ast_matchers {
 
-#define RANDSTRUCT_TEST_SUITE_TEST StructureLayoutRandomizationTestSuiteTest
+#define RANDSTRUCT_TEST_SUITE_TEST RecordLayoutRandomizationTestSuiteTest
 
 TEST(RANDSTRUCT_TEST_SUITE_TEST, CanDetermineIfSubsequenceExists) {
   const field_names Seq = {"a", "b", "c", "d"};
 
   EXPECT_TRUE(isSubsequence(Seq, {"b", "c"}));
   EXPECT_TRUE(isSubsequence(Seq, {"a", "b", "c", "d"}));
   EXPECT_TRUE(isSubsequence(Seq, {"b", "c", "d"}));
   EXPECT_TRUE(isSubsequence(Seq, {"a"}));
   EXPECT_FALSE(isSubsequence(Seq, {"a", "d"}));
 }
 
-#define RANDSTRUCT_TEST StructureLayoutRandomization
+#define RANDSTRUCT_TEST RecordLayoutRandomization
 
 TEST(RANDSTRUCT_TEST, UnmarkedStruct) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
     struct test {
         int bacon;
         long lettuce;
         long long tomato;
         float mayonnaise;
     };
   )c");
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
   const RecordDecl *RD = getRecordDeclFromAST(AST->getASTContext(), "test");
 
   EXPECT_FALSE(RD->hasAttr<RandomizeLayoutAttr>());
   EXPECT_FALSE(RD->isRandomized());
 }
 
 TEST(RANDSTRUCT_TEST, MarkedNoRandomize) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
     struct test {
         int bacon;
         long lettuce;
         long long tomato;
         float mayonnaise;
     } __attribute__((no_randomize_layout));
   )c");
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
   const RecordDecl *RD = getRecordDeclFromAST(AST->getASTContext(), "test");
 
   EXPECT_TRUE(RD->hasAttr<NoRandomizeLayoutAttr>());
   EXPECT_FALSE(RD->isRandomized());
 }
 
 TEST(RANDSTRUCT_TEST, MarkedRandomize) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
     struct test {
         int bacon;
         long lettuce;
         long long tomato;
         float mayonnaise;
     } __attribute__((randomize_layout));
   )c");
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
   const RecordDecl *RD = getRecordDeclFromAST(AST->getASTContext(), "test");
 
   EXPECT_TRUE(RD->hasAttr<RandomizeLayoutAttr>());
   EXPECT_TRUE(RD->isRandomized());
 }
 
 TEST(RANDSTRUCT_TEST, MismatchedAttrsDeclVsDef) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
     struct test __attribute__((randomize_layout));
     struct test {
         int bacon;
         long lettuce;
         long long tomato;
         float mayonnaise;
     } __attribute__((no_randomize_layout));
-  )c");
+  )c",
+                                         true);
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
-  DiagnosticsEngine &Diags = AST->getDiagnostics();
+  const DiagnosticsEngine &Diags = AST->getDiagnostics();
 
   EXPECT_FALSE(Diags.hasFatalErrorOccurred());
   EXPECT_FALSE(Diags.hasUncompilableErrorOccurred());
   EXPECT_FALSE(Diags.hasUnrecoverableErrorOccurred());
   EXPECT_EQ(Diags.getNumWarnings(), 1u);
   EXPECT_EQ(Diags.getNumErrors(), 0u);
 }
 
 TEST(RANDSTRUCT_TEST, MismatchedAttrsRandomizeVsNoRandomize) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
-    struct test2 {
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+    struct test {
         int bacon;
         long lettuce;
         long long tomato;
         float mayonnaise;
     } __attribute__((randomize_layout)) __attribute__((no_randomize_layout));
-  )c");
+  )c",
+                                         true);
 
   EXPECT_TRUE(AST->getDiagnostics().hasErrorOccurred());
 
-  DiagnosticsEngine &Diags = AST->getDiagnostics();
+  const DiagnosticsEngine &Diags = AST->getDiagnostics();
 
   EXPECT_TRUE(Diags.hasUncompilableErrorOccurred());
   EXPECT_TRUE(Diags.hasUnrecoverableErrorOccurred());
   EXPECT_EQ(Diags.getNumWarnings(), 0u);
   EXPECT_EQ(Diags.getNumErrors(), 1u);
 }
 
 TEST(RANDSTRUCT_TEST, MismatchedAttrsNoRandomizeVsRandomize) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
     struct test3 {
         int bacon;
         long lettuce;
         long long tomato;
         float mayonnaise;
     } __attribute__((no_randomize_layout)) __attribute__((randomize_layout));
-  )c");
+  )c",
+                                         true);
 
   EXPECT_TRUE(AST->getDiagnostics().hasErrorOccurred());
 
-  DiagnosticsEngine &Diags = AST->getDiagnostics();
+  const DiagnosticsEngine &Diags = AST->getDiagnostics();
 
   EXPECT_TRUE(Diags.hasUncompilableErrorOccurred());
   EXPECT_TRUE(Diags.hasUnrecoverableErrorOccurred());
   EXPECT_EQ(Diags.getNumWarnings(), 0u);
   EXPECT_EQ(Diags.getNumErrors(), 1u);
 }
 
 TEST(RANDSTRUCT_TEST, CheckAdjacentBitfieldsRemainAdjacentAfterRandomization) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
     struct test {
         int a;
         int b;
         int x : 1;
         int y : 1;
         int z : 1;
         int c;
     } __attribute__((randomize_layout));
   )c");
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
   const RecordDecl *RD = getRecordDeclFromAST(AST->getASTContext(), "test");
   const field_names Actual = getFieldNamesFromRecord(RD);
   const field_names Subseq = {"x", "y", "z"};
 
   EXPECT_TRUE(RD->isRandomized());
   EXPECT_TRUE(isSubsequence(Actual, Subseq));
 }
 
 TEST(RANDSTRUCT_TEST, CheckVariableLengthArrayMemberRemainsAtEndOfStructure) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
     struct test {
         int a;
         double b;
         short c;
         char name[];
     } __attribute__((randomize_layout));
   )c");
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
   const RecordDecl *RD = getRecordDeclFromAST(AST->getASTContext(), "test");
 
   EXPECT_TRUE(RD->isRandomized());
 }
 
 TEST(RANDSTRUCT_TEST, RandstructDoesNotOverrideThePackedAttr) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+  std::unique_ptr<ASTUnit> AST =
+      makeAST(R"c(
     struct test_struct {
         char a;
         float b[3];
         short c;
         int d;
     } __attribute__((packed, randomize_layout));
 
     struct another_struct {
         char a;
         char b[5];
         int c;
     } __attribute__((packed, randomize_layout));
 
     struct last_struct {
         char a;
         long long b;
         int c[];
     } __attribute__((packed, randomize_layout));
-  )c");
+  )c",
+              false,
+              std::vector<std::string>(
+                  {"test_struct", "another_struct", "last_struct"}));
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
   // FIXME (?): calling getASTRecordLayout is probably a necessary evil so that
   // Clang's RecordBuilders can actually flesh out the information like
   // alignment, etc.
   {
     const RecordDecl *RD =
const ASTRecordLayout *Layout =
         &AST->getASTContext().getASTRecordLayout(RD);
 
     EXPECT_TRUE(RD->isRandomized());
     EXPECT_EQ(9, Layout->getSize().getQuantity());
   }
 }
 
 TEST(RANDSTRUCT_TEST, ZeroWidthBitfieldsSeparateAllocationUnits) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
     struct test {
         int a : 1;
         int   : 0;
         int b : 1;
     } __attribute__((randomize_layout));
   )c");
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
   const RecordDecl *RD = getRecordDeclFromAST(AST->getASTContext(), "test");
 
   EXPECT_TRUE(RD->isRandomized());
 }
 
 TEST(RANDSTRUCT_TEST, RandstructDoesNotRandomizeUnionFieldOrder) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
-    union test_union {
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+    union test {
         int a;
         int b;
         int c;
         int d;
         int e;
         int f;
     } __attribute__((randomize_layout));
   )c");
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
   const RecordDecl *RD =
       getRecordDeclFromAST(AST->getASTContext(), "test_union");
 
   EXPECT_FALSE(RD->isRandomized());
 }
 
 TEST(RANDSTRUCT_TEST, AnonymousStructsAndUnionsRetainFieldOrder) {
-  const std::unique_ptr<ASTUnit> AST = makeAST(R"c(
-    struct test_struct {
+  std::unique_ptr<ASTUnit> AST = makeAST(R"c(
+    struct test {
         int a;
         struct sub_struct {
             int b;
             int c;
             int d;
             int e;
             int f;
         } __attribute__((randomize_layout)) s;
struct test {
             int q;
         };
         int r;
     } __attribute__((randomize_layout));
   )c");
 
   EXPECT_FALSE(AST->getDiagnostics().hasErrorOccurred());
 
-  const RecordDecl *RD =
-      getRecordDeclFromAST(AST->getASTContext(), "test_struct");
+  const RecordDecl *RD = getRecordDeclFromAST(AST->getASTContext(), "test");
 
   EXPECT_TRUE(RD->isRandomized());
 
   bool AnonStructTested = false;
   bool AnonUnionTested = false;
 
   for (const Decl *D : RD->decls())
     if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) {