1 //===- unittest/ProfileData/SampleProfTest.cpp ------------------*- C++ -*-===//
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/ProfileData/SampleProf.h"
10 #include "llvm/ADT/StringMap.h"
11 #include "llvm/ADT/StringRef.h"
12 #include "llvm/IR/DebugInfoMetadata.h"
13 #include "llvm/IR/LLVMContext.h"
14 #include "llvm/IR/Metadata.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/ProfileData/SampleProfReader.h"
17 #include "llvm/ProfileData/SampleProfWriter.h"
18 #include "llvm/Support/Casting.h"
19 #include "llvm/Support/ErrorOr.h"
20 #include "llvm/Support/FileSystem.h"
21 #include "llvm/Support/MemoryBuffer.h"
22 #include "llvm/Support/raw_ostream.h"
23 #include "llvm/Testing/Support/SupportHelpers.h"
24 #include "gtest/gtest.h"
25 #include <string>
26 #include <vector>
27 
28 using namespace llvm;
29 using namespace sampleprof;
30 
31 using llvm::unittest::TempFile;
32 
33 static ::testing::AssertionResult NoError(std::error_code EC) {
34   if (!EC)
35     return ::testing::AssertionSuccess();
36   return ::testing::AssertionFailure() << "error " << EC.value() << ": "
37                                        << EC.message();
38 }
39 
40 namespace {
41 
42 struct SampleProfTest : ::testing::Test {
43   LLVMContext Context;
44   std::unique_ptr<SampleProfileWriter> Writer;
45   std::unique_ptr<SampleProfileReader> Reader;
46 
47   SampleProfTest() : Writer(), Reader() {}
48 
49   void createWriter(SampleProfileFormat Format, StringRef Profile) {
50     std::error_code EC;
51     std::unique_ptr<raw_ostream> OS(
52         new raw_fd_ostream(Profile, EC, sys::fs::OF_None));
53     auto WriterOrErr = SampleProfileWriter::create(OS, Format);
54     ASSERT_TRUE(NoError(WriterOrErr.getError()));
55     Writer = std::move(WriterOrErr.get());
56   }
57 
58   void readProfile(const Module &M, StringRef Profile,
59                    StringRef RemapFile = "") {
60     auto ReaderOrErr = SampleProfileReader::create(
61         std::string(Profile), Context, FSDiscriminatorPass::Base,
62         std::string(RemapFile));
63     ASSERT_TRUE(NoError(ReaderOrErr.getError()));
64     Reader = std::move(ReaderOrErr.get());
65     Reader->setModule(&M);
66   }
67 
68   TempFile createRemapFile() {
69     return TempFile("remapfile", "", R"(
70       # Types 'int' and 'long' are equivalent
71       type i l
72       # Function names 'foo' and 'faux' are equivalent
73       name 3foo 4faux
74     )",
75                     /*Unique*/ true);
76   }
77 
78   // Verify profile summary is consistent in the roundtrip to and from
79   // Metadata. \p AddPartialField is to choose whether the Metadata
80   // contains the IsPartialProfile field which is optional.
81   void verifyProfileSummary(ProfileSummary &Summary, Module &M,
82                             const bool AddPartialField,
83                             const bool AddPartialProfileRatioField) {
84     LLVMContext &Context = M.getContext();
85     const bool IsPartialProfile = Summary.isPartialProfile();
86     const double PartialProfileRatio = Summary.getPartialProfileRatio();
87     auto VerifySummary = [IsPartialProfile, PartialProfileRatio](
88                              ProfileSummary &Summary) mutable {
89       ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind());
90       ASSERT_EQ(138211u, Summary.getTotalCount());
91       ASSERT_EQ(10u, Summary.getNumCounts());
92       ASSERT_EQ(4u, Summary.getNumFunctions());
93       ASSERT_EQ(1437u, Summary.getMaxFunctionCount());
94       ASSERT_EQ(60351u, Summary.getMaxCount());
95       ASSERT_EQ(IsPartialProfile, Summary.isPartialProfile());
96       ASSERT_EQ(PartialProfileRatio, Summary.getPartialProfileRatio());
97 
98       uint32_t Cutoff = 800000;
99       auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) {
100         return PE.Cutoff == Cutoff;
101       };
102       std::vector<ProfileSummaryEntry> &Details = Summary.getDetailedSummary();
103       auto EightyPerc = find_if(Details, Predicate);
104       Cutoff = 900000;
105       auto NinetyPerc = find_if(Details, Predicate);
106       Cutoff = 950000;
107       auto NinetyFivePerc = find_if(Details, Predicate);
108       Cutoff = 990000;
109       auto NinetyNinePerc = find_if(Details, Predicate);
110       ASSERT_EQ(60000u, EightyPerc->MinCount);
111       ASSERT_EQ(12557u, NinetyPerc->MinCount);
112       ASSERT_EQ(12557u, NinetyFivePerc->MinCount);
113       ASSERT_EQ(600u, NinetyNinePerc->MinCount);
114     };
115     VerifySummary(Summary);
116 
117     // Test that conversion of summary to and from Metadata works.
118     Metadata *MD =
119         Summary.getMD(Context, AddPartialField, AddPartialProfileRatioField);
120     ASSERT_TRUE(MD);
121     ProfileSummary *PS = ProfileSummary::getFromMD(MD);
122     ASSERT_TRUE(PS);
123     VerifySummary(*PS);
124     delete PS;
125 
126     // Test that summary can be attached to and read back from module.
127     M.eraseNamedMetadata(M.getOrInsertModuleFlagsMetadata());
128     M.setProfileSummary(MD, ProfileSummary::PSK_Sample);
129     MD = M.getProfileSummary(/* IsCS */ false);
130     ASSERT_TRUE(MD);
131     PS = ProfileSummary::getFromMD(MD);
132     ASSERT_TRUE(PS);
133     VerifySummary(*PS);
134     delete PS;
135   }
136 
137   void testRoundTrip(SampleProfileFormat Format, bool Remap, bool UseMD5) {
138     TempFile ProfileFile("profile", "", "", /*Unique*/ true);
139     createWriter(Format, ProfileFile.path());
140     if (Format == SampleProfileFormat::SPF_Ext_Binary && UseMD5)
141       static_cast<SampleProfileWriterExtBinary *>(Writer.get())->setUseMD5();
142 
143     StringRef FooName("_Z3fooi");
144     FunctionSamples FooSamples;
145     FooSamples.setName(FooName);
146     FooSamples.addTotalSamples(7711);
147     FooSamples.addHeadSamples(610);
148     FooSamples.addBodySamples(1, 0, 610);
149     FooSamples.addBodySamples(2, 0, 600);
150     FooSamples.addBodySamples(4, 0, 60000);
151     FooSamples.addBodySamples(8, 0, 60351);
152     FooSamples.addBodySamples(10, 0, 605);
153 
154     // Add inline instance with name "_Z3gooi".
155     StringRef GooName("_Z3gooi");
156     auto &GooSamples =
157         FooSamples.functionSamplesAt(LineLocation(7, 0))[GooName.str()];
158     GooSamples.setName(GooName);
159     GooSamples.addTotalSamples(502);
160     GooSamples.addBodySamples(3, 0, 502);
161 
162     // Add inline instance with name "_Z3hooi".
163     StringRef HooName("_Z3hooi");
164     auto &HooSamples =
165         GooSamples.functionSamplesAt(LineLocation(9, 0))[HooName.str()];
166     HooSamples.setName(HooName);
167     HooSamples.addTotalSamples(317);
168     HooSamples.addBodySamples(4, 0, 317);
169 
170     StringRef BarName("_Z3bari");
171     FunctionSamples BarSamples;
172     BarSamples.setName(BarName);
173     BarSamples.addTotalSamples(20301);
174     BarSamples.addHeadSamples(1437);
175     BarSamples.addBodySamples(1, 0, 1437);
176     // Test how reader/writer handles unmangled names.
177     StringRef MconstructName("_M_construct<char *>");
178     StringRef StringviewName("string_view<std::allocator<char> >");
179     BarSamples.addCalledTargetSamples(1, 0, MconstructName, 1000);
180     BarSamples.addCalledTargetSamples(1, 0, StringviewName, 437);
181 
182     StringRef BazName("_Z3bazi");
183     FunctionSamples BazSamples;
184     BazSamples.setName(BazName);
185     BazSamples.addTotalSamples(12557);
186     BazSamples.addHeadSamples(1257);
187     BazSamples.addBodySamples(1, 0, 12557);
188 
189     StringRef BooName("_Z3booi");
190     FunctionSamples BooSamples;
191     BooSamples.setName(BooName);
192     BooSamples.addTotalSamples(1232);
193     BooSamples.addHeadSamples(1);
194     BooSamples.addBodySamples(1, 0, 1232);
195 
196     SampleProfileMap Profiles;
197     Profiles[FooName] = std::move(FooSamples);
198     Profiles[BarName] = std::move(BarSamples);
199     Profiles[BazName] = std::move(BazSamples);
200     Profiles[BooName] = std::move(BooSamples);
201 
202     Module M("my_module", Context);
203     FunctionType *fn_type =
204         FunctionType::get(Type::getVoidTy(Context), {}, false);
205 
206     TempFile RemapFile(createRemapFile());
207     if (Remap) {
208       FooName = "_Z4fauxi";
209       BarName = "_Z3barl";
210       GooName = "_Z3gool";
211       HooName = "_Z3hool";
212     }
213 
214     M.getOrInsertFunction(FooName, fn_type);
215     M.getOrInsertFunction(BarName, fn_type);
216     M.getOrInsertFunction(BooName, fn_type);
217 
218     ProfileSymbolList List;
219     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
220       List.add("zoo", true);
221       List.add("moo", true);
222     }
223     Writer->setProfileSymbolList(&List);
224 
225     std::error_code EC;
226     EC = Writer->write(Profiles);
227     ASSERT_TRUE(NoError(EC));
228 
229     Writer->getOutputStream().flush();
230 
231     readProfile(M, ProfileFile.path(), RemapFile.path());
232     EC = Reader->read();
233     ASSERT_TRUE(NoError(EC));
234 
235     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
236       std::unique_ptr<ProfileSymbolList> ReaderList =
237           Reader->getProfileSymbolList();
238       ReaderList->contains("zoo");
239       ReaderList->contains("moo");
240     }
241 
242     FunctionSamples *ReadFooSamples = Reader->getSamplesFor(FooName);
243     ASSERT_TRUE(ReadFooSamples != nullptr);
244     if (!UseMD5) {
245       ASSERT_EQ("_Z3fooi", ReadFooSamples->getName());
246     }
247     ASSERT_EQ(7711u, ReadFooSamples->getTotalSamples());
248     ASSERT_EQ(610u, ReadFooSamples->getHeadSamples());
249 
250     // Try to find a FunctionSamples with GooName at given callsites containing
251     // inline instance for GooName. Test the correct FunctionSamples can be
252     // found with Remapper support.
253     const FunctionSamples *ReadGooSamples =
254         ReadFooSamples->findFunctionSamplesAt(LineLocation(7, 0), GooName,
255                                               Reader->getRemapper());
256     ASSERT_TRUE(ReadGooSamples != nullptr);
257     ASSERT_EQ(502u, ReadGooSamples->getTotalSamples());
258 
259     // Try to find a FunctionSamples with GooName at given callsites containing
260     // no inline instance for GooName. Test no FunctionSamples will be
261     // found with Remapper support.
262     const FunctionSamples *ReadGooSamplesAgain =
263         ReadFooSamples->findFunctionSamplesAt(LineLocation(9, 0), GooName,
264                                               Reader->getRemapper());
265     ASSERT_TRUE(ReadGooSamplesAgain == nullptr);
266 
267     // The inline instance of Hoo is inside of the inline instance of Goo.
268     // Try to find a FunctionSamples with HooName at given callsites containing
269     // inline instance for HooName. Test the correct FunctionSamples can be
270     // found with Remapper support.
271     const FunctionSamples *ReadHooSamples =
272         ReadGooSamples->findFunctionSamplesAt(LineLocation(9, 0), HooName,
273                                               Reader->getRemapper());
274     ASSERT_TRUE(ReadHooSamples != nullptr);
275     ASSERT_EQ(317u, ReadHooSamples->getTotalSamples());
276 
277     FunctionSamples *ReadBarSamples = Reader->getSamplesFor(BarName);
278     ASSERT_TRUE(ReadBarSamples != nullptr);
279     if (!UseMD5) {
280       ASSERT_EQ("_Z3bari", ReadBarSamples->getName());
281     }
282     ASSERT_EQ(20301u, ReadBarSamples->getTotalSamples());
283     ASSERT_EQ(1437u, ReadBarSamples->getHeadSamples());
284     ErrorOr<SampleRecord::CallTargetMap> CTMap =
285         ReadBarSamples->findCallTargetMapAt(1, 0);
286     ASSERT_FALSE(CTMap.getError());
287 
288     // Because _Z3bazi is not defined in module M, expect _Z3bazi's profile
289     // is not loaded when the profile is ExtBinary or Compact format because
290     // these formats support loading function profiles on demand.
291     FunctionSamples *ReadBazSamples = Reader->getSamplesFor(BazName);
292     if (Format == SampleProfileFormat::SPF_Ext_Binary ||
293         Format == SampleProfileFormat::SPF_Compact_Binary) {
294       ASSERT_TRUE(ReadBazSamples == nullptr);
295       ASSERT_EQ(3u, Reader->getProfiles().size());
296     } else {
297       ASSERT_TRUE(ReadBazSamples != nullptr);
298       ASSERT_EQ(12557u, ReadBazSamples->getTotalSamples());
299       ASSERT_EQ(4u, Reader->getProfiles().size());
300     }
301 
302     FunctionSamples *ReadBooSamples = Reader->getSamplesFor(BooName);
303     ASSERT_TRUE(ReadBooSamples != nullptr);
304     ASSERT_EQ(1232u, ReadBooSamples->getTotalSamples());
305 
306     std::string MconstructGUID;
307     StringRef MconstructRep =
308         getRepInFormat(MconstructName, UseMD5, MconstructGUID);
309     std::string StringviewGUID;
310     StringRef StringviewRep =
311         getRepInFormat(StringviewName, UseMD5, StringviewGUID);
312     ASSERT_EQ(1000u, CTMap.get()[MconstructRep]);
313     ASSERT_EQ(437u, CTMap.get()[StringviewRep]);
314 
315 
316     ProfileSummary &Summary = Reader->getSummary();
317     Summary.setPartialProfile(true);
318     verifyProfileSummary(Summary, M, true, false);
319 
320     Summary.setPartialProfile(false);
321     verifyProfileSummary(Summary, M, true, false);
322 
323     verifyProfileSummary(Summary, M, false, false);
324 
325     Summary.setPartialProfile(true);
326     Summary.setPartialProfileRatio(0.5);
327     verifyProfileSummary(Summary, M, true, true);
328   }
329 
330   void addFunctionSamples(SampleProfileMap *Smap, const char *Fname,
331                           uint64_t TotalSamples, uint64_t HeadSamples) {
332     StringRef Name(Fname);
333     FunctionSamples FcnSamples;
334     FcnSamples.setName(Name);
335     FcnSamples.addTotalSamples(TotalSamples);
336     FcnSamples.addHeadSamples(HeadSamples);
337     FcnSamples.addBodySamples(1, 0, HeadSamples);
338     (*Smap)[Name] = FcnSamples;
339   }
340 
341   SampleProfileMap setupFcnSamplesForElisionTest(StringRef Policy) {
342     SampleProfileMap Smap;
343     addFunctionSamples(&Smap, "foo", uint64_t(20301), uint64_t(1437));
344     if (Policy == "" || Policy == "all")
345       return Smap;
346     addFunctionSamples(&Smap, "foo.bar", uint64_t(20303), uint64_t(1439));
347     if (Policy == "selected")
348       return Smap;
349     addFunctionSamples(&Smap, "foo.llvm.2465", uint64_t(20305), uint64_t(1441));
350     return Smap;
351   }
352 
353   void createFunctionWithSampleProfileElisionPolicy(Module *M,
354                                                     const char *Fname,
355                                                     StringRef Policy) {
356     FunctionType *FnType =
357         FunctionType::get(Type::getVoidTy(Context), {}, false);
358     auto Inserted = M->getOrInsertFunction(Fname, FnType);
359     auto Fcn = cast<Function>(Inserted.getCallee());
360     if (Policy != "")
361       Fcn->addFnAttr("sample-profile-suffix-elision-policy", Policy);
362   }
363 
364   void setupModuleForElisionTest(Module *M, StringRef Policy) {
365     createFunctionWithSampleProfileElisionPolicy(M, "foo", Policy);
366     createFunctionWithSampleProfileElisionPolicy(M, "foo.bar", Policy);
367     createFunctionWithSampleProfileElisionPolicy(M, "foo.llvm.2465", Policy);
368   }
369 
370   void testSuffixElisionPolicy(SampleProfileFormat Format, StringRef Policy,
371                                const StringMap<uint64_t> &Expected) {
372     TempFile ProfileFile("profile", "", "", /*Unique*/ true);
373 
374     Module M("my_module", Context);
375     setupModuleForElisionTest(&M, Policy);
376     SampleProfileMap ProfMap = setupFcnSamplesForElisionTest(Policy);
377 
378     // write profile
379     createWriter(Format, ProfileFile.path());
380     std::error_code EC;
381     EC = Writer->write(ProfMap);
382     ASSERT_TRUE(NoError(EC));
383     Writer->getOutputStream().flush();
384 
385     // read profile
386     readProfile(M, ProfileFile.path());
387     EC = Reader->read();
388     ASSERT_TRUE(NoError(EC));
389 
390     for (auto I = Expected.begin(); I != Expected.end(); ++I) {
391       uint64_t Esamples = uint64_t(-1);
392       FunctionSamples *Samples = Reader->getSamplesFor(I->getKey());
393       if (Samples != nullptr)
394         Esamples = Samples->getTotalSamples();
395       ASSERT_EQ(I->getValue(), Esamples);
396     }
397   }
398 };
399 
400 TEST_F(SampleProfTest, roundtrip_text_profile) {
401   testRoundTrip(SampleProfileFormat::SPF_Text, false, false);
402 }
403 
404 TEST_F(SampleProfTest, roundtrip_raw_binary_profile) {
405   testRoundTrip(SampleProfileFormat::SPF_Binary, false, false);
406 }
407 
408 TEST_F(SampleProfTest, roundtrip_compact_binary_profile) {
409   testRoundTrip(SampleProfileFormat::SPF_Compact_Binary, false, true);
410 }
411 
412 TEST_F(SampleProfTest, roundtrip_ext_binary_profile) {
413   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, false);
414 }
415 
416 TEST_F(SampleProfTest, roundtrip_md5_ext_binary_profile) {
417   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, true);
418 }
419 
420 TEST_F(SampleProfTest, remap_text_profile) {
421   testRoundTrip(SampleProfileFormat::SPF_Text, true, false);
422 }
423 
424 TEST_F(SampleProfTest, remap_raw_binary_profile) {
425   testRoundTrip(SampleProfileFormat::SPF_Binary, true, false);
426 }
427 
428 TEST_F(SampleProfTest, remap_ext_binary_profile) {
429   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, true, false);
430 }
431 
432 TEST_F(SampleProfTest, sample_overflow_saturation) {
433   const uint64_t Max = std::numeric_limits<uint64_t>::max();
434   sampleprof_error Result;
435 
436   FunctionSamples FooSamples;
437   Result = FooSamples.addTotalSamples(1);
438   ASSERT_EQ(Result, sampleprof_error::success);
439 
440   Result = FooSamples.addHeadSamples(1);
441   ASSERT_EQ(Result, sampleprof_error::success);
442 
443   Result = FooSamples.addBodySamples(10, 0, 1);
444   ASSERT_EQ(Result, sampleprof_error::success);
445 
446   Result = FooSamples.addTotalSamples(Max);
447   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
448   ASSERT_EQ(FooSamples.getTotalSamples(), Max);
449 
450   Result = FooSamples.addHeadSamples(Max);
451   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
452   ASSERT_EQ(FooSamples.getHeadSamples(), Max);
453 
454   Result = FooSamples.addBodySamples(10, 0, Max);
455   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
456   ErrorOr<uint64_t> BodySamples = FooSamples.findSamplesAt(10, 0);
457   ASSERT_FALSE(BodySamples.getError());
458   ASSERT_EQ(BodySamples.get(), Max);
459 }
460 
461 TEST_F(SampleProfTest, default_suffix_elision_text) {
462   // Default suffix elision policy: strip everything after first dot.
463   // This implies that all suffix variants will map to "foo", so
464   // we don't expect to see any entries for them in the sample
465   // profile.
466   StringMap<uint64_t> Expected;
467   Expected["foo"] = uint64_t(20301);
468   Expected["foo.bar"] = uint64_t(-1);
469   Expected["foo.llvm.2465"] = uint64_t(-1);
470   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "", Expected);
471 }
472 
473 TEST_F(SampleProfTest, default_suffix_elision_compact_binary) {
474   // Default suffix elision policy: strip everything after first dot.
475   // This implies that all suffix variants will map to "foo", so
476   // we don't expect to see any entries for them in the sample
477   // profile.
478   StringMap<uint64_t> Expected;
479   Expected["foo"] = uint64_t(20301);
480   Expected["foo.bar"] = uint64_t(-1);
481   Expected["foo.llvm.2465"] = uint64_t(-1);
482   testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "",
483                           Expected);
484 }
485 
486 TEST_F(SampleProfTest, selected_suffix_elision_text) {
487   // Profile is created and searched using the "selected"
488   // suffix elision policy: we only strip a .XXX suffix if
489   // it matches a pattern known to be generated by the compiler
490   // (e.g. ".llvm.<digits>").
491   StringMap<uint64_t> Expected;
492   Expected["foo"] = uint64_t(20301);
493   Expected["foo.bar"] = uint64_t(20303);
494   Expected["foo.llvm.2465"] = uint64_t(-1);
495   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "selected", Expected);
496 }
497 
498 TEST_F(SampleProfTest, selected_suffix_elision_compact_binary) {
499   // Profile is created and searched using the "selected"
500   // suffix elision policy: we only strip a .XXX suffix if
501   // it matches a pattern known to be generated by the compiler
502   // (e.g. ".llvm.<digits>").
503   StringMap<uint64_t> Expected;
504   Expected["foo"] = uint64_t(20301);
505   Expected["foo.bar"] = uint64_t(20303);
506   Expected["foo.llvm.2465"] = uint64_t(-1);
507   testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "selected",
508                           Expected);
509 }
510 
511 TEST_F(SampleProfTest, none_suffix_elision_text) {
512   // Profile is created and searched using the "none"
513   // suffix elision policy: no stripping of suffixes at all.
514   // Here we expect to see all variants in the profile.
515   StringMap<uint64_t> Expected;
516   Expected["foo"] = uint64_t(20301);
517   Expected["foo.bar"] = uint64_t(20303);
518   Expected["foo.llvm.2465"] = uint64_t(20305);
519   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "none", Expected);
520 }
521 
522 TEST_F(SampleProfTest, none_suffix_elision_compact_binary) {
523   // Profile is created and searched using the "none"
524   // suffix elision policy: no stripping of suffixes at all.
525   // Here we expect to see all variants in the profile.
526   StringMap<uint64_t> Expected;
527   Expected["foo"] = uint64_t(20301);
528   Expected["foo.bar"] = uint64_t(20303);
529   Expected["foo.llvm.2465"] = uint64_t(20305);
530   testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "none",
531                           Expected);
532 }
533 
534 } // end anonymous namespace
535