|
150
|
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 }
|
