react-native-tvos 0.78.0-0rc4 → 0.79.0-0

package/ReactCommon/react/renderer/css/tests/CSSSyntaxParserTest.cpp

@@ -14,8 +14,7 @@ TEST(CSSSyntaxParser, simple) {
   CSSSyntaxParser parser{"1px solid black"};
 
   auto pxValue = parser.consumeComponentValue<float>(
-      CSSComponentValueDelimiter::Whitespace,
-      [](const CSSPreservedToken& token) {
+      CSSDelimiter::OptionalWhitespace, [](const CSSPreservedToken& token) {
         EXPECT_EQ(token.type(), CSSTokenType::Dimension);
         EXPECT_EQ(token.numericValue(), 1.0f);
         EXPECT_EQ(token.unit(), "px");
@@ -24,9 +23,7 @@ TEST(CSSSyntaxParser, simple) {
   EXPECT_EQ(pxValue, 1.0f);
 
   auto identValue = parser.consumeComponentValue<std::string_view>(
-      CSSComponentValueDelimiter::Whitespace,
-
-      [](const CSSPreservedToken& token) {
+      CSSDelimiter::OptionalWhitespace, [](const CSSPreservedToken& token) {
         EXPECT_EQ(token.type(), CSSTokenType::Ident);
         EXPECT_EQ(token.stringValue(), "solid");
         return token.stringValue();
@@ -34,8 +31,7 @@ TEST(CSSSyntaxParser, simple) {
   EXPECT_EQ(identValue, "solid");
 
   auto identValue2 = parser.consumeComponentValue<std::string_view>(
-      CSSComponentValueDelimiter::Whitespace,
-      [](const CSSPreservedToken& token) {
+      CSSDelimiter::OptionalWhitespace, [](const CSSPreservedToken& token) {
         EXPECT_EQ(token.type(), CSSTokenType::Ident);
         EXPECT_EQ(token.stringValue(), "black");
         return token.stringValue();
@@ -47,9 +43,14 @@ TEST(CSSSyntaxParser, single_function_no_args) {
   CSSSyntaxParser parser{"foo()"};
 
   auto funcName = parser.consumeComponentValue<std::string_view>(
-      [](const CSSFunctionBlock& function) {
+      [](const CSSFunctionBlock& function, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(function.name, "foo");
         return function.name;
+
+        auto hasMoreTokens = blockParser.consumeComponentValue<bool>(
+            [](const CSSPreservedToken& /*token*/) { return true; });
+
+        EXPECT_FALSE(hasMoreTokens);
       });
   EXPECT_EQ(funcName, "foo");
 }
@@ -58,13 +59,13 @@ TEST(CSSSyntaxParser, single_function_with_whitespace_delimited_args) {
   CSSSyntaxParser parser{"foo( a b c)"};
 
   auto funcArgs = parser.consumeComponentValue<std::vector<std::string>>(
-      [&](const CSSFunctionBlock& function) {
+      [&](const CSSFunctionBlock& function, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(function.name, "foo");
 
         std::vector<std::string> args;
 
-        args.emplace_back(parser.consumeComponentValue<std::string_view>(
-            CSSComponentValueDelimiter::Whitespace,
+        args.emplace_back(blockParser.consumeComponentValue<std::string_view>(
+            CSSDelimiter::OptionalWhitespace,
 
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
@@ -72,8 +73,8 @@ TEST(CSSSyntaxParser, single_function_with_whitespace_delimited_args) {
               return token.stringValue();
             }));
 
-        args.emplace_back(parser.consumeComponentValue<std::string_view>(
-            CSSComponentValueDelimiter::Whitespace,
+        args.emplace_back(blockParser.consumeComponentValue<std::string_view>(
+            CSSDelimiter::Whitespace,
 
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
@@ -81,8 +82,8 @@ TEST(CSSSyntaxParser, single_function_with_whitespace_delimited_args) {
               return token.stringValue();
             }));
 
-        args.emplace_back(parser.consumeComponentValue<std::string_view>(
-            CSSComponentValueDelimiter::Whitespace,
+        args.emplace_back(blockParser.consumeComponentValue<std::string_view>(
+            CSSDelimiter::Whitespace,
 
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
@@ -90,6 +91,12 @@ TEST(CSSSyntaxParser, single_function_with_whitespace_delimited_args) {
               return token.stringValue();
             }));
 
+        auto hasMoreTokens = blockParser.consumeComponentValue<bool>(
+            CSSDelimiter::Whitespace,
+            [](const CSSPreservedToken& /*token*/) { return true; });
+
+        EXPECT_FALSE(hasMoreTokens);
+
         return args;
       });
 
@@ -101,35 +108,84 @@ TEST(CSSSyntaxParser, single_function_with_comma_delimited_args) {
   CSSSyntaxParser parser{"rgb(100, 200, 50 )"};
 
   auto funcArgs = parser.consumeComponentValue<std::array<uint8_t, 3>>(
-      [&](const CSSFunctionBlock& function) {
+      [&](const CSSFunctionBlock& function, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(function.name, "rgb");
 
         std::array<uint8_t, 3> rgb{};
 
-        rgb[0] = parser.consumeComponentValue<uint8_t>(
-            CSSComponentValueDelimiter::Whitespace,
+        rgb[0] = blockParser.consumeComponentValue<uint8_t>(
+            CSSDelimiter::OptionalWhitespace,
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Number);
               EXPECT_EQ(token.numericValue(), 100);
               return static_cast<uint8_t>(token.numericValue());
             });
 
-        rgb[1] = parser.consumeComponentValue<uint8_t>(
-            CSSComponentValueDelimiter::Comma,
+        rgb[1] = blockParser.consumeComponentValue<uint8_t>(
+            CSSDelimiter::Comma, [](const CSSPreservedToken& token) {
+              EXPECT_EQ(token.type(), CSSTokenType::Number);
+              EXPECT_EQ(token.numericValue(), 200);
+              return static_cast<uint8_t>(token.numericValue());
+            });
+
+        rgb[2] = blockParser.consumeComponentValue<uint8_t>(
+            CSSDelimiter::Comma, [](const CSSPreservedToken& token) {
+              EXPECT_EQ(token.type(), CSSTokenType::Number);
+              EXPECT_EQ(token.numericValue(), 50);
+              return static_cast<uint8_t>(token.numericValue());
+            });
+
+        auto hasMoreTokens = blockParser.consumeComponentValue<bool>(
+            CSSDelimiter::Whitespace,
+            [](const CSSPreservedToken& /*token*/) { return true; });
+
+        EXPECT_FALSE(hasMoreTokens);
+
+        return rgb;
+      });
+
+  std::array<uint8_t, 3> expectedArgs{{100, 200, 50}};
+  EXPECT_EQ(funcArgs, expectedArgs);
+}
+
+TEST(CSSSyntaxParser, single_function_with_mixed_delimited_args) {
+  CSSSyntaxParser parser{"rgb(100, 200 50 )"};
+
+  auto funcArgs = parser.consumeComponentValue<std::array<uint8_t, 3>>(
+      [&](const CSSFunctionBlock& function, CSSSyntaxParser& blockParser) {
+        EXPECT_EQ(function.name, "rgb");
+
+        std::array<uint8_t, 3> rgb{};
+
+        rgb[0] = blockParser.consumeComponentValue<uint8_t>(
+            CSSDelimiter::None, [](const CSSPreservedToken& token) {
+              EXPECT_EQ(token.type(), CSSTokenType::Number);
+              EXPECT_EQ(token.numericValue(), 100);
+              return static_cast<uint8_t>(token.numericValue());
+            });
+
+        rgb[1] = blockParser.consumeComponentValue<uint8_t>(
+            CSSDelimiter::CommaOrWhitespace,
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Number);
               EXPECT_EQ(token.numericValue(), 200);
               return static_cast<uint8_t>(token.numericValue());
             });
 
-        rgb[2] = parser.consumeComponentValue<uint8_t>(
-            CSSComponentValueDelimiter::Comma,
+        rgb[2] = blockParser.consumeComponentValue<uint8_t>(
+            CSSDelimiter::CommaOrWhitespace,
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Number);
               EXPECT_EQ(token.numericValue(), 50);
               return static_cast<uint8_t>(token.numericValue());
             });
 
+        auto hasMoreTokens = blockParser.consumeComponentValue<bool>(
+            CSSDelimiter::Whitespace,
+            [](const CSSPreservedToken& /*token*/) { return true; });
+
+        EXPECT_FALSE(hasMoreTokens);
+
         return rgb;
       });
 
@@ -141,10 +197,10 @@ TEST(CSSSyntaxParser, complex) {
   CSSSyntaxParser parser{"foo(a bar())baz() 12px"};
 
   auto fooFunc = parser.consumeComponentValue<std::string_view>(
-      [&](const CSSFunctionBlock& function) {
+      [&](const CSSFunctionBlock& function, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(function.name, "foo");
-        auto identArg = parser.consumeComponentValue<std::string_view>(
-            CSSComponentValueDelimiter::Whitespace,
+        auto identArg = blockParser.consumeComponentValue<std::string_view>(
+            CSSDelimiter::OptionalWhitespace,
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
               EXPECT_EQ(token.stringValue(), "a");
@@ -152,28 +208,39 @@ TEST(CSSSyntaxParser, complex) {
             });
         EXPECT_EQ(identArg, "a");
 
-        auto barFunc = parser.consumeComponentValue<std::string_view>(
-            CSSComponentValueDelimiter::Whitespace,
-            [&](const CSSFunctionBlock& function) {
+        auto barFunc = blockParser.consumeComponentValue<std::string_view>(
+            CSSDelimiter::Whitespace,
+            [&](const CSSFunctionBlock& function,
+                CSSSyntaxParser& nestedBlockParser) {
               EXPECT_EQ(function.name, "bar");
+              auto hasMoreTokens =
+                  nestedBlockParser.consumeComponentValue<bool>(
+                      CSSDelimiter::Whitespace,
+                      [](const CSSPreservedToken& /*token*/) { return true; });
+              EXPECT_FALSE(hasMoreTokens);
+
               return function.name;
             });
         EXPECT_EQ(barFunc, "bar");
 
+        auto hasMoreTokens = blockParser.consumeComponentValue<bool>(
+            CSSDelimiter::Whitespace,
+            [](const CSSPreservedToken& /*token*/) { return true; });
+        EXPECT_FALSE(hasMoreTokens);
+
         return function.name;
       });
   EXPECT_EQ(fooFunc, "foo");
 
   auto bazFunc = parser.consumeComponentValue<std::string_view>(
-      [&](const CSSFunctionBlock& function) {
+      [&](const CSSFunctionBlock& function, CSSSyntaxParser& /*blockParser*/) {
         EXPECT_EQ(function.name, "baz");
         return function.name;
       });
   EXPECT_EQ(bazFunc, "baz");
 
   auto pxValue = parser.consumeComponentValue<float>(
-      CSSComponentValueDelimiter::Whitespace,
-      [](const CSSPreservedToken& token) {
+      CSSDelimiter::Whitespace, [](const CSSPreservedToken& token) {
         EXPECT_EQ(token.type(), CSSTokenType::Dimension);
         EXPECT_EQ(token.numericValue(), 12.0f);
         EXPECT_EQ(token.unit(), "px");
@@ -184,18 +251,22 @@ TEST(CSSSyntaxParser, complex) {
 
 TEST(CSSSyntaxParser, unterminated_functions) {
   EXPECT_FALSE(CSSSyntaxParser{"foo("}.consumeComponentValue<bool>(
-      [](const CSSFunctionBlock&) { return true; }));
+      [](const CSSFunctionBlock&, CSSSyntaxParser& /*blockParser*/) {
+        return true;
+      }));
 
   EXPECT_FALSE(CSSSyntaxParser{"foo(a bar()baz()"}.consumeComponentValue<bool>(
-      [](const CSSFunctionBlock&) { return true; }));
+      [](const CSSFunctionBlock&, CSSSyntaxParser& /*blockParser*/) {
+        return true;
+      }));
 }
 
 TEST(CSSSyntaxParser, simple_blocks) {
   CSSSyntaxParser parser1{"(a)"};
   auto identValue = parser1.consumeComponentValue<std::string_view>(
-      [&](const CSSSimpleBlock& block) {
+      [&](const CSSSimpleBlock& block, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(block.openBracketType, CSSTokenType::OpenParen);
-        return parser1.consumeComponentValue<std::string_view>(
+        return blockParser.consumeComponentValue<std::string_view>(
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
               return token.stringValue();
@@ -205,9 +276,9 @@ TEST(CSSSyntaxParser, simple_blocks) {
 
   CSSSyntaxParser parser2{"[b ]"};
   auto identValue2 = parser2.consumeComponentValue<std::string_view>(
-      [&](const CSSSimpleBlock& block) {
+      [&](const CSSSimpleBlock& block, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(block.openBracketType, CSSTokenType::OpenSquare);
-        return parser2.consumeComponentValue<std::string_view>(
+        return blockParser.consumeComponentValue<std::string_view>(
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
               return token.stringValue();
@@ -217,9 +288,9 @@ TEST(CSSSyntaxParser, simple_blocks) {
 
   CSSSyntaxParser parser3{"{c}"};
   auto identValue3 = parser3.consumeComponentValue<std::string_view>(
-      [&](const CSSSimpleBlock& block) {
+      [&](const CSSSimpleBlock& block, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(block.openBracketType, CSSTokenType::OpenCurly);
-        return parser3.consumeComponentValue<std::string_view>(
+        return blockParser.consumeComponentValue<std::string_view>(
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
               return token.stringValue();
@@ -231,9 +302,9 @@ TEST(CSSSyntaxParser, simple_blocks) {
 TEST(CSSSyntaxParser, unterminated_simple_blocks) {
   CSSSyntaxParser parser1{"(a"};
   auto identValue = parser1.consumeComponentValue<std::string_view>(
-      [&](const CSSSimpleBlock& block) {
+      [&](const CSSSimpleBlock& block, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(block.openBracketType, CSSTokenType::OpenParen);
-        return parser1.consumeComponentValue<std::string_view>(
+        return blockParser.consumeComponentValue<std::string_view>(
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
               return token.stringValue();
@@ -243,9 +314,9 @@ TEST(CSSSyntaxParser, unterminated_simple_blocks) {
 
   CSSSyntaxParser parser2{"[b "};
   auto identValue2 = parser2.consumeComponentValue<std::string_view>(
-      [&](const CSSSimpleBlock& block) {
+      [&](const CSSSimpleBlock& block, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(block.openBracketType, CSSTokenType::OpenSquare);
-        return parser2.consumeComponentValue<std::string_view>(
+        return blockParser.consumeComponentValue<std::string_view>(
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
               return token.stringValue();
@@ -255,9 +326,9 @@ TEST(CSSSyntaxParser, unterminated_simple_blocks) {
 
   CSSSyntaxParser parser3{"{c"};
   auto identValue3 = parser3.consumeComponentValue<std::string_view>(
-      [&](const CSSSimpleBlock& block) {
+      [&](const CSSSimpleBlock& block, CSSSyntaxParser& blockParser) {
         EXPECT_EQ(block.openBracketType, CSSTokenType::OpenCurly);
-        return parser3.consumeComponentValue<std::string_view>(
+        return blockParser.consumeComponentValue<std::string_view>(
             [](const CSSPreservedToken& token) {
               EXPECT_EQ(token.type(), CSSTokenType::Ident);
               return token.stringValue();
@@ -266,4 +337,226 @@ TEST(CSSSyntaxParser, unterminated_simple_blocks) {
   EXPECT_EQ(identValue3, "");
 }
 
+TEST(CSSSyntaxParser, unconsumed_function_args) {
+  CSSSyntaxParser parser{"foo(a)"};
+  auto funcValue =
+      parser.consumeComponentValue<std::optional<std::string_view>>(
+          [&](const CSSFunctionBlock& function,
+              CSSSyntaxParser& /*blockParser*/) {
+            EXPECT_EQ(function.name, "foo");
+            return function.name;
+          });
+
+  EXPECT_EQ(funcValue, std::nullopt);
+}
+
+TEST(CSSSyntaxParser, whitespace_surrounding_function_args) {
+  CSSSyntaxParser parser{"foo( a )"};
+  auto funcValue = parser.consumeComponentValue<std::string_view>(
+      [&](const CSSFunctionBlock& function, CSSSyntaxParser& blockParser) {
+        EXPECT_EQ(function.name, "foo");
+
+        auto identArg = blockParser.consumeComponentValue<std::string_view>(
+            CSSDelimiter::None, [](const CSSPreservedToken& token) {
+              EXPECT_EQ(token.type(), CSSTokenType::Ident);
+              EXPECT_EQ(token.stringValue(), "a");
+              return token.stringValue();
+            });
+
+        EXPECT_EQ(identArg, "a");
+
+        return function.name;
+      });
+
+  EXPECT_EQ(funcValue, "foo");
+}
+
+TEST(CSSSyntaxParser, unconsumed_simple_block_args) {
+  CSSSyntaxParser parser{"{a}"};
+  auto funcValue = parser.consumeComponentValue<std::optional<CSSTokenType>>(
+      [&](const CSSSimpleBlock& block, CSSSyntaxParser& /*blockParser*/) {
+        EXPECT_EQ(block.openBracketType, CSSTokenType::OpenCurly);
+        return block.openBracketType;
+      });
+
+  EXPECT_EQ(funcValue, std::nullopt);
+}
+
+TEST(CSSSyntaxParser, solidus_delimiter) {
+  CSSSyntaxParser parser{"foo / bar"};
+
+  auto identValue = parser.consumeComponentValue<std::string_view>(
+      [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Ident);
+        EXPECT_EQ(token.stringValue(), "foo");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(identValue, "foo");
+
+  auto identValue2 = parser.consumeComponentValue<std::string_view>(
+      CSSDelimiter::Solidus, [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Ident);
+        EXPECT_EQ(token.stringValue(), "bar");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(identValue2, "bar");
+}
+
+TEST(CSSSyntaxParser, solidus_delimiter_not_present) {
+  CSSSyntaxParser parser{"foo bar"};
+
+  auto identValue = parser.consumeComponentValue<std::string_view>(
+      [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Ident);
+        EXPECT_EQ(token.stringValue(), "foo");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(identValue, "foo");
+
+  auto identValue2 = parser.consumeComponentValue<bool>(
+      CSSDelimiter::Solidus,
+      [](const CSSPreservedToken& /*token*/) { return true; });
+
+  EXPECT_FALSE(identValue2);
+}
+
+TEST(CSSSyntaxParser, required_whitespace_not_present) {
+  CSSSyntaxParser parser{"foo/"};
+
+  auto identValue = parser.consumeComponentValue<std::string_view>(
+      [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Ident);
+        EXPECT_EQ(token.stringValue(), "foo");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(identValue, "foo");
+
+  auto delimValue1 = parser.consumeComponentValue<bool>(
+      CSSDelimiter::Whitespace,
+      [](const CSSPreservedToken& /*token*/) { return true; });
+
+  EXPECT_FALSE(delimValue1);
+
+  auto delimValue2 = parser.consumeComponentValue<std::string_view>(
+      CSSDelimiter::OptionalWhitespace, [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Delim);
+        EXPECT_EQ(token.stringValue(), "/");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(delimValue2, "/");
+}
+
+TEST(CSSSyntaxParser, solidus_or_whitespace) {
+  CSSSyntaxParser parser{"foo bar / baz potato, papaya"};
+
+  auto identValue1 = parser.consumeComponentValue<std::string_view>(
+      CSSDelimiter::OptionalWhitespace, [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Ident);
+        EXPECT_EQ(token.stringValue(), "foo");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(identValue1, "foo");
+
+  auto identValue2 = parser.consumeComponentValue<std::string_view>(
+      CSSDelimiter::SolidusOrWhitespace, [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Ident);
+        EXPECT_EQ(token.stringValue(), "bar");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(identValue2, "bar");
+
+  auto identValue3 = parser.consumeComponentValue<std::string_view>(
+      CSSDelimiter::SolidusOrWhitespace, [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Ident);
+        EXPECT_EQ(token.stringValue(), "baz");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(identValue3, "baz");
+
+  auto identValue4 = parser.consumeComponentValue<std::string_view>(
+      CSSDelimiter::SolidusOrWhitespace, [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Ident);
+        EXPECT_EQ(token.stringValue(), "potato");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(identValue4, "potato");
+
+  auto delimValue1 = parser.consumeComponentValue<bool>(
+      CSSDelimiter::SolidusOrWhitespace,
+      [](const CSSPreservedToken& token) { return true; });
+
+  EXPECT_FALSE(delimValue1);
+}
+
+TEST(CSSSyntaxParser, delimeter_not_consumed_when_no_component_value) {
+  CSSSyntaxParser parser{"foo ,"};
+
+  auto identValue = parser.consumeComponentValue<std::string_view>(
+      [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Ident);
+        EXPECT_EQ(token.stringValue(), "foo");
+        return token.stringValue();
+      });
+
+  EXPECT_EQ(identValue, "foo");
+
+  auto identValue2 = parser.consumeComponentValue<bool>(
+      CSSDelimiter::Comma,
+      [](const CSSPreservedToken& /*token*/) { return true; });
+
+  EXPECT_FALSE(identValue2);
+
+  auto hasComma = parser.consumeComponentValue<bool>(
+      CSSDelimiter::Whitespace, [](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.type(), CSSTokenType::Comma);
+        return true;
+      });
+
+  EXPECT_TRUE(hasComma);
+}
+
+TEST(CSSSyntaxParser, component_value_not_consumed_on_visitor_failure) {
+  CSSSyntaxParser parser{"foo"};
+
+  bool visitor1Attempted = false;
+  bool visitor1Ret =
+      parser.consumeComponentValue<bool>([&](const CSSPreservedToken& token) {
+        EXPECT_EQ(token.stringValue(), "foo");
+        visitor1Attempted = true;
+        return false;
+      });
+
+  EXPECT_TRUE(visitor1Attempted);
+  EXPECT_FALSE(visitor1Ret);
+
+  bool visitor2Attempted = false;
+  parser.consumeComponentValue<bool>([&](const CSSPreservedToken& token) {
+    EXPECT_EQ(token.stringValue(), "foo");
+    visitor2Attempted = true;
+    return true;
+  });
+
+  EXPECT_TRUE(visitor2Attempted);
+  EXPECT_TRUE(visitor2Attempted);
+
+  bool visitor3Attempted = false;
+  bool visitor3Ret =
+      parser.consumeComponentValue<bool>([&](const CSSPreservedToken& token) {
+        visitor3Attempted = true;
+        return true;
+      });
+
+  EXPECT_FALSE(visitor3Attempted);
+  EXPECT_FALSE(visitor3Ret);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/css/tests/CSSTokenizerTest.cpp

@@ -95,6 +95,11 @@ TEST(CSSTokenizer, number_values) {
       "+.123e+0",
       CSSToken{CSSTokenType::Number, +.123e+0},
       CSSToken{CSSTokenType::EndOfFile});
+
+  EXPECT_TOKENS(
+      "+.9999999999",
+      CSSToken{CSSTokenType::Number, +.9999999999},
+      CSSToken{CSSTokenType::EndOfFile});
 }
 
 TEST(CSSTokenizer, dimension_values) {
@@ -112,6 +117,11 @@ TEST(CSSTokenizer, dimension_values) {
       ".3xyz",
       CSSToken{CSSTokenType::Dimension, 0.3, "xyz"},
       CSSToken{CSSTokenType::EndOfFile});
+
+  EXPECT_TOKENS(
+      "-0.5em",
+      CSSToken{CSSTokenType::Dimension, -0.5, "em"},
+      CSSToken{CSSTokenType::EndOfFile});
 }
 
 TEST(CSSTokenizer, percent_values) {