1 //===- FormatTest.cpp - TableGen Format Utility Tests ---------------------===//
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 "mlir/TableGen/Format.h"
10 #include "gmock/gmock.h"
11 
12 using mlir::tblgen::FmtContext;
13 using mlir::tblgen::tgfmt;
14 using ::testing::StrEq;
15 
16 TEST(FormatTest, EmptyFmtStr) {
17   FmtContext ctx;
18   std::string result = std::string(tgfmt("", &ctx));
19   EXPECT_TRUE(result.empty());
20 }
21 
22 /// Allow extra unused positional parameters.
23 TEST(FormatTest, EmptyFmtStrExtraParams) {
24   FmtContext ctx;
25   std::string result = std::string(tgfmt("", &ctx, "a", "b", "c"));
26   EXPECT_TRUE(result.empty());
27 }
28 
29 /// Allow unused placeholder substitution in context.
30 TEST(FormatTest, EmptyFmtStrPopulatedCtx) {
31   FmtContext ctx;
32   ctx.withBuilder("builder");
33   std::string result = std::string(tgfmt("", &ctx));
34   EXPECT_TRUE(result.empty());
35 }
36 
37 TEST(FormatTest, LiteralFmtStr) {
38   FmtContext ctx;
39   std::string result = std::string(tgfmt("void foo {}", &ctx));
40   EXPECT_THAT(result, StrEq("void foo {}"));
41 }
42 
43 /// Print single dollar literally.
44 TEST(FormatTest, AdjacentDollar) {
45   FmtContext ctx;
46   std::string result = std::string(tgfmt("$", &ctx));
47   EXPECT_THAT(result, StrEq("$"));
48 }
49 
50 /// Print dangling dollar literally.
51 TEST(FormatTest, DanglingDollar) {
52   FmtContext ctx;
53   std::string result = std::string(tgfmt("foo bar baz$", &ctx));
54   EXPECT_THAT(result, StrEq("foo bar baz$"));
55 }
56 
57 /// Allow escape dollars with '$$'.
58 TEST(FormatTest, EscapeDollars) {
59   FmtContext ctx;
60   std::string result =
61       std::string(tgfmt("$$ $$$$ $$$0 $$$_self", &ctx.withSelf("self"), "-0"));
62   EXPECT_THAT(result, StrEq("$ $$ $-0 $self"));
63 }
64 
65 TEST(FormatTest, PositionalFmtStr) {
66   FmtContext ctx;
67   std::string b = "b";
68   int c = 42;
69   char d = 'd';
70   std::string result =
71       std::string(tgfmt("$0 $1 $2 $3", &ctx, "a", b, c + 1, d));
72   EXPECT_THAT(result, StrEq("a b 43 d"));
73 }
74 
75 /// Output the placeholder if missing substitution.
76 TEST(FormatTest, PositionalFmtStrMissingParams) {
77   FmtContext ctx;
78   std::string result = std::string(tgfmt("$0 %1 $2", &ctx));
79   EXPECT_THAT(result, StrEq("$0<no-subst-found> %1 $2<no-subst-found>"));
80 }
81 
82 /// Allow flexible reference of positional parameters.
83 TEST(FormatTest, PositionalFmtStrFlexibleRef) {
84   FmtContext ctx;
85   std::string result = std::string(tgfmt("$2 $0 $2", &ctx, "a", "b", "c"));
86   EXPECT_THAT(result, StrEq("c a c"));
87 }
88 
89 TEST(FormatTest, PositionalFmtStrNoWhitespace) {
90   FmtContext ctx;
91   std::string result = std::string(tgfmt("foo$0bar", &ctx, "-"));
92   EXPECT_THAT(result, StrEq("foo-bar"));
93 }
94 
95 TEST(FormatTest, PlaceHolderFmtStrWithSelf) {
96   FmtContext ctx;
97   std::string result = std::string(tgfmt("$_self", &ctx.withSelf("sss")));
98   EXPECT_THAT(result, StrEq("sss"));
99 }
100 
101 TEST(FormatTest, PlaceHolderFmtStrWithBuilder) {
102   FmtContext ctx;
103 
104   std::string result = std::string(tgfmt("$_builder", &ctx.withBuilder("bbb")));
105   EXPECT_THAT(result, StrEq("bbb"));
106 }
107 
108 TEST(FormatTest, PlaceHolderFmtStrWithOp) {
109   FmtContext ctx;
110   std::string result = std::string(tgfmt("$_op", &ctx.withOp("ooo")));
111   EXPECT_THAT(result, StrEq("ooo"));
112 }
113 
114 TEST(FormatTest, PlaceHolderMissingCtx) {
115   std::string result = std::string(tgfmt("$_op", nullptr));
116   EXPECT_THAT(result, StrEq("$_op<no-subst-found>"));
117 }
118 
119 TEST(FormatTest, PlaceHolderMissingSubst) {
120   FmtContext ctx;
121   std::string result = std::string(tgfmt("$_op", &ctx.withBuilder("builder")));
122   EXPECT_THAT(result, StrEq("$_op<no-subst-found>"));
123 }
124 
125 /// Test commonly used delimiters in C++.
126 TEST(FormatTest, PlaceHolderFmtStrDelimiter) {
127   FmtContext ctx;
128   ctx.addSubst("m", "");
129   std::string result = std::string(tgfmt("$m{$m($m[$m]$m)$m}$m|", &ctx));
130   EXPECT_THAT(result, StrEq("{([])}|"));
131 }
132 
133 /// Test allowed characters in placeholder symbol.
134 TEST(FormatTest, CustomPlaceHolderFmtStrPlaceHolderChars) {
135   FmtContext ctx;
136   ctx.addSubst("m", "0 ");
137   ctx.addSubst("m1", "1 ");
138   ctx.addSubst("m2C", "2 ");
139   ctx.addSubst("M_3", "3 ");
140   std::string result = std::string(tgfmt("$m$m1$m2C$M_3", &ctx));
141   EXPECT_THAT(result, StrEq("0 1 2 3 "));
142 }
143 
144 TEST(FormatTest, CustomPlaceHolderFmtStrUnregisteredPlaceHolders) {
145   FmtContext ctx;
146   std::string result = std::string(tgfmt("foo($awesome, $param)", &ctx));
147   EXPECT_THAT(result,
148               StrEq("foo($awesome<no-subst-found>, $param<no-subst-found>)"));
149 }
150 
151 TEST(FormatTest, MixedFmtStr) {
152   FmtContext ctx;
153   ctx.withBuilder("bbb");
154 
155   std::string result = std::string(tgfmt("$_builder.build($_self, {$0, $1})",
156                                          &ctx.withSelf("sss"), "a", "b"));
157   EXPECT_THAT(result, StrEq("bbb.build(sss, {a, b})"));
158 }
159