diff --git a/src/writer/hlsl/generator_impl_unary_op_test.cc b/src/writer/hlsl/generator_impl_unary_op_test.cc
index e6c6441..b7710c3 100644
--- a/src/writer/hlsl/generator_impl_unary_op_test.cc
+++ b/src/writer/hlsl/generator_impl_unary_op_test.cc
@@ -19,37 +19,57 @@
 namespace hlsl {
 namespace {
 
-struct UnaryOpData {
-  const char* name;
-  ast::UnaryOp op;
-};
-inline std::ostream& operator<<(std::ostream& out, UnaryOpData data) {
-  out << data.op;
-  return out;
-}
-using HlslUnaryOpTest = TestParamHelper<UnaryOpData>;
-TEST_P(HlslUnaryOpTest, Emit) {
-  auto params = GetParam();
-  auto name = std::string(params.name);
+using HlslUnaryOpTest = TestHelper;
 
-  Global("expr", ty.i32(), ast::StorageClass::kPrivate);
-
-  auto* op = create<ast::UnaryOpExpression>(params.op, Expr("expr"));
+TEST_F(HlslUnaryOpTest, AddressOf) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("expr"));
   WrapInFunction(op);
 
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitExpression(pre, out, op)) << gen.error();
-  EXPECT_EQ(result(), name.empty() ? "expr" : name + "(expr)");
+  EXPECT_EQ(result(), "expr");
 }
-INSTANTIATE_TEST_SUITE_P(
-    HlslGeneratorImplTest_UnaryOp,
-    HlslUnaryOpTest,
-    testing::Values(UnaryOpData{"", ast::UnaryOp::kAddressOf},
-                    UnaryOpData{"", ast::UnaryOp::kIndirection},
-                    UnaryOpData{"!", ast::UnaryOp::kNot},
-                    UnaryOpData{"-", ast::UnaryOp::kNegation}));
 
+TEST_F(HlslUnaryOpTest, Indirection) {
+  Global("G", ty.f32(), ast::StorageClass::kPrivate);
+  auto* p = Const(
+      "expr", nullptr,
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("G")));
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kIndirection, Expr("expr"));
+  WrapInFunction(p, op);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitExpression(pre, out, op)) << gen.error();
+  EXPECT_EQ(result(), "expr");
+}
+
+TEST_F(HlslUnaryOpTest, Not) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitExpression(pre, out, op)) << gen.error();
+  EXPECT_EQ(result(), "!(expr)");
+}
+
+TEST_F(HlslUnaryOpTest, Negation) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitExpression(pre, out, op)) << gen.error();
+  EXPECT_EQ(result(), "-(expr)");
+}
 }  // namespace
 }  // namespace hlsl
 }  // namespace writer
diff --git a/src/writer/msl/generator_impl_unary_op_test.cc b/src/writer/msl/generator_impl_unary_op_test.cc
index e43f31b..161e492 100644
--- a/src/writer/msl/generator_impl_unary_op_test.cc
+++ b/src/writer/msl/generator_impl_unary_op_test.cc
@@ -19,34 +19,57 @@
 namespace msl {
 namespace {
 
-struct UnaryOpData {
-  const char* name;
-  ast::UnaryOp op;
-};
-inline std::ostream& operator<<(std::ostream& out, UnaryOpData data) {
-  out << data.op;
-  return out;
-}
-using MslUnaryOpTest = TestParamHelper<UnaryOpData>;
-TEST_P(MslUnaryOpTest, Emit) {
-  auto params = GetParam();
-  Global("expr", ty.i32(), ast::StorageClass::kPrivate);
+using MslUnaryOpTest = TestHelper;
 
-  auto* op = create<ast::UnaryOpExpression>(params.op, Expr("expr"));
+TEST_F(MslUnaryOpTest, AddressOf) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("expr"));
   WrapInFunction(op);
 
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
-  EXPECT_EQ(gen.result(), std::string(params.name) + "(expr)");
+  EXPECT_EQ(gen.result(), "&(expr)");
 }
-INSTANTIATE_TEST_SUITE_P(
-    MslGeneratorImplTest,
-    MslUnaryOpTest,
-    testing::Values(UnaryOpData{"&", ast::UnaryOp::kAddressOf},
-                    UnaryOpData{"*", ast::UnaryOp::kIndirection},
-                    UnaryOpData{"!", ast::UnaryOp::kNot},
-                    UnaryOpData{"-", ast::UnaryOp::kNegation}));
+
+TEST_F(MslUnaryOpTest, Indirection) {
+  Global("G", ty.f32(), ast::StorageClass::kPrivate);
+  auto* p = Const(
+      "expr", nullptr,
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("G")));
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kIndirection, Expr("expr"));
+  WrapInFunction(p, op);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
+  EXPECT_EQ(gen.result(), "*(expr)");
+}
+
+TEST_F(MslUnaryOpTest, Not) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
+  EXPECT_EQ(gen.result(), "!(expr)");
+}
+
+TEST_F(MslUnaryOpTest, Negation) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
+  EXPECT_EQ(gen.result(), "-(expr)");
+}
 
 }  // namespace
 }  // namespace msl
diff --git a/src/writer/wgsl/generator_impl_unary_op_test.cc b/src/writer/wgsl/generator_impl_unary_op_test.cc
index 62eb7f5..87d594c 100644
--- a/src/writer/wgsl/generator_impl_unary_op_test.cc
+++ b/src/writer/wgsl/generator_impl_unary_op_test.cc
@@ -19,38 +19,57 @@
 namespace wgsl {
 namespace {
 
-struct UnaryOpData {
-  const char* name;
-  ast::UnaryOp op;
-};
-inline std::ostream& operator<<(std::ostream& out, UnaryOpData data) {
-  out << data.op;
-  return out;
-}
-using WgslUnaryOpTest = TestParamHelper<UnaryOpData>;
-TEST_P(WgslUnaryOpTest, Emit) {
-  auto params = GetParam();
+using WgslUnaryOpTest = TestHelper;
 
-  auto* type = (params.op == ast::UnaryOp::kNot)
-                   ? static_cast<ast::Type*>(ty.bool_())
-                   : static_cast<ast::Type*>(ty.i32());
-  Global("expr", type, ast::StorageClass::kPrivate);
-
-  auto* op = create<ast::UnaryOpExpression>(params.op, Expr("expr"));
+TEST_F(WgslUnaryOpTest, AddressOf) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("expr"));
   WrapInFunction(op);
 
   GeneratorImpl& gen = Build();
 
   ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
-  EXPECT_EQ(gen.result(), std::string(params.name) + "(expr)");
+  EXPECT_EQ(gen.result(), "&(expr)");
 }
-INSTANTIATE_TEST_SUITE_P(
-    WgslGeneratorImplTest,
-    WgslUnaryOpTest,
-    testing::Values(UnaryOpData{"&", ast::UnaryOp::kAddressOf},
-                    UnaryOpData{"*", ast::UnaryOp::kIndirection},
-                    UnaryOpData{"!", ast::UnaryOp::kNot},
-                    UnaryOpData{"-", ast::UnaryOp::kNegation}));
+
+TEST_F(WgslUnaryOpTest, Indirection) {
+  Global("G", ty.f32(), ast::StorageClass::kPrivate);
+  auto* p = Const(
+      "expr", nullptr,
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("G")));
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kIndirection, Expr("expr"));
+  WrapInFunction(p, op);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
+  EXPECT_EQ(gen.result(), "*(expr)");
+}
+
+TEST_F(WgslUnaryOpTest, Not) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
+  EXPECT_EQ(gen.result(), "!(expr)");
+}
+
+TEST_F(WgslUnaryOpTest, Negation) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
+  EXPECT_EQ(gen.result(), "-(expr)");
+}
 
 }  // namespace
 }  // namespace wgsl