| // Copyright 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/tools/profile_reset/jtl_compiler.h" |
| |
| #include <string> |
| |
| #include "base/values.h" |
| #include "chrome/browser/profile_resetter/jtl_foundation.h" |
| #include "chrome/browser/profile_resetter/jtl_instructions.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace { |
| |
| const char kTestHashSeed[] = "test-hash-seed"; |
| |
| // Helpers ------------------------------------------------------------------- |
| |
| std::string GetHash(const std::string& input) { |
| return jtl_foundation::Hasher(kTestHashSeed).GetHash(input); |
| } |
| |
| // Tests --------------------------------------------------------------------- |
| |
| // Note: Parsing and parsing-related errors are unit-tested separately in more |
| // detail in "jtl_parser_unittest.cc". Here, most of the time, we assume that |
| // creating the parse tree works. |
| |
| TEST(JtlCompiler, CompileSingleInstructions) { |
| struct TestCase { |
| std::string source_code; |
| std::string expected_bytecode; |
| } cases[] = { |
| {"go(\"foo\").", OP_NAVIGATE(GetHash("foo"))}, |
| {"go(\"has whitespace\t\").", |
| OP_NAVIGATE(GetHash("has whitespace\t"))}, |
| {"any.", OP_NAVIGATE_ANY}, |
| {"back.", OP_NAVIGATE_BACK}, |
| {"store_bool(\"name\", true).", |
| OP_STORE_BOOL(GetHash("name"), VALUE_TRUE)}, |
| {"compare_stored_bool(\"name\", true, false).", |
| OP_COMPARE_STORED_BOOL(GetHash("name"), VALUE_TRUE, VALUE_FALSE)}, |
| {"store_hash(\"name\", \"" + GetHash("value") + "\").", |
| OP_STORE_HASH(GetHash("name"), GetHash("value"))}, |
| {"store_hashed(\"name\", \"value\").", |
| OP_STORE_HASH(GetHash("name"), GetHash("value"))}, |
| {"store_node_bool(\"name\").", |
| OP_STORE_NODE_BOOL(GetHash("name"))}, |
| {"store_node_hash(\"name\").", |
| OP_STORE_NODE_HASH(GetHash("name"))}, |
| {"compare_stored_hashed(\"name\", \"value\", \"default\").", |
| OP_COMPARE_STORED_HASH( |
| GetHash("name"), GetHash("value"), GetHash("default"))}, |
| {"compare_bool(false).", OP_COMPARE_NODE_BOOL(VALUE_FALSE)}, |
| {"compare_bool(true).", OP_COMPARE_NODE_BOOL(VALUE_TRUE)}, |
| {"compare_hashed(\"foo\").", OP_COMPARE_NODE_HASH(GetHash("foo"))}, |
| {"compare_hashed_not(\"foo\").", |
| OP_COMPARE_NODE_HASH_NOT(GetHash("foo"))}, |
| {"compare_to_stored_bool(\"name\").", |
| OP_COMPARE_NODE_TO_STORED_BOOL(GetHash("name"))}, |
| {"compare_to_stored_hash(\"name\").", |
| OP_COMPARE_NODE_TO_STORED_HASH(GetHash("name"))}, |
| {"break.", OP_STOP_EXECUTING_SENTENCE}, |
| {"break;", OP_STOP_EXECUTING_SENTENCE + OP_END_OF_SENTENCE}}; |
| |
| for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) { |
| SCOPED_TRACE(cases[i].source_code); |
| std::string bytecode; |
| EXPECT_TRUE(JtlCompiler::Compile( |
| cases[i].source_code, kTestHashSeed, &bytecode, NULL)); |
| EXPECT_EQ(cases[i].expected_bytecode, bytecode); |
| } |
| } |
| |
| TEST(JtlCompiler, CompileEntireProgram) { |
| const char kSourceCode[] = |
| "// Store \"x\"=true if path is found.\n" |
| "go(\"foo\").go(\"bar\").store_bool(\"x\", true);\n" |
| "// ...\n" |
| "// Store \"y\"=\"1\" if above value is set.\n" |
| "compare_stored_bool(\"x\", true, false).store_hashed(\"y\", \"1\");\n"; |
| |
| std::string expected_bytecode = |
| OP_NAVIGATE(GetHash("foo")) + |
| OP_NAVIGATE(GetHash("bar")) + |
| OP_STORE_BOOL(GetHash("x"), VALUE_TRUE) + OP_END_OF_SENTENCE + |
| OP_COMPARE_STORED_BOOL(GetHash("x"), VALUE_TRUE, VALUE_FALSE) + |
| OP_STORE_HASH(GetHash("y"), GetHash("1")) + OP_END_OF_SENTENCE; |
| |
| std::string bytecode; |
| EXPECT_TRUE( |
| JtlCompiler::Compile(kSourceCode, kTestHashSeed, &bytecode, NULL)); |
| EXPECT_EQ(expected_bytecode, bytecode); |
| } |
| |
| TEST(JtlCompiler, InvalidOperationName) { |
| const char kSourceCode[] = "any()\n.\nnon_existent_instruction\n(\n)\n;\n"; |
| |
| std::string bytecode; |
| JtlCompiler::CompileError error; |
| EXPECT_FALSE( |
| JtlCompiler::Compile(kSourceCode, kTestHashSeed, &bytecode, &error)); |
| EXPECT_THAT(error.context, testing::StartsWith("non_existent_instruction")); |
| EXPECT_EQ(2u, error.line_number); |
| EXPECT_EQ(JtlCompiler::CompileError::INVALID_OPERATION_NAME, |
| error.error_code); |
| } |
| |
| TEST(JtlCompiler, InvalidArgumentsCount) { |
| const char* kSourceCodes[] = { |
| "any().\nstore_bool(\"name\", true, \"superfluous argument\");\n", |
| "any().\nstore_bool(\"name\");"}; // missing argument |
| |
| for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kSourceCodes); ++i) { |
| SCOPED_TRACE(kSourceCodes[i]); |
| std::string bytecode; |
| JtlCompiler::CompileError error; |
| EXPECT_FALSE(JtlCompiler::Compile( |
| kSourceCodes[i], kTestHashSeed, &bytecode, &error)); |
| EXPECT_THAT(error.context, testing::StartsWith("store_bool")); |
| EXPECT_EQ(1u, error.line_number); |
| EXPECT_EQ(JtlCompiler::CompileError::INVALID_ARGUMENT_COUNT, |
| error.error_code); |
| } |
| } |
| |
| TEST(JtlCompiler, InvalidArgumentType) { |
| struct TestCase { |
| std::string expected_context_prefix; |
| std::string source_code; |
| } cases[] = { |
| {"compare_bool", "any()\n.\ncompare_bool(\"foo\");"}, |
| {"compare_bool", |
| "any()\n.\ncompare_bool(\"01234567890123456789012345678901\");"}, |
| {"compare_hashed", "any()\n.\ncompare_hashed(false);"}, |
| {"store_hash", "any()\n.\nstore_hash(\"name\", false);"}, |
| {"store_hash", "any()\n.\nstore_hash(\"name\", \"foo\");"}, |
| {"compare_stored_bool", |
| "any()\n.\ncompare_stored_bool(\"name\", \"need a bool\", false);"}, |
| {"compare_stored_bool", |
| "any()\n.\ncompare_stored_bool(\"name\", false, \"need a bool\");"}}; |
| |
| for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) { |
| SCOPED_TRACE(cases[i].source_code); |
| std::string bytecode; |
| JtlCompiler::CompileError error; |
| EXPECT_FALSE(JtlCompiler::Compile( |
| cases[i].source_code, kTestHashSeed, &bytecode, &error)); |
| EXPECT_THAT(error.context, |
| testing::StartsWith(cases[i].expected_context_prefix)); |
| EXPECT_EQ(2u, error.line_number); |
| EXPECT_EQ(JtlCompiler::CompileError::INVALID_ARGUMENT_TYPE, |
| error.error_code); |
| } |
| } |
| |
| TEST(JtlCompiler, MistmatchedDoubleQuotes) { |
| const char kSourceCode[] = "any().\ngo(\"ok\", \"stray quote).break();"; |
| |
| std::string bytecode; |
| JtlCompiler::CompileError error; |
| EXPECT_FALSE( |
| JtlCompiler::Compile(kSourceCode, kTestHashSeed, &bytecode, &error)); |
| EXPECT_EQ(1u, error.line_number); |
| EXPECT_EQ(JtlCompiler::CompileError::MISMATCHED_DOUBLE_QUOTES, |
| error.error_code); |
| } |
| |
| TEST(JtlCompiler, ParsingError) { |
| const char kSourceCode[] = "any().\ngo()missing_separator();"; |
| |
| std::string bytecode; |
| JtlCompiler::CompileError error; |
| EXPECT_FALSE( |
| JtlCompiler::Compile(kSourceCode, kTestHashSeed, &bytecode, &error)); |
| EXPECT_THAT(error.context, testing::StartsWith("go")); |
| EXPECT_EQ(1u, error.line_number); |
| EXPECT_EQ(JtlCompiler::CompileError::PARSING_ERROR, error.error_code); |
| } |
| |
| } // namespace |