yaze 0.2.2
Link to the Past ROM Editor
 
Loading...
Searching...
No Matches
message_test.cc
Go to the documentation of this file.
1#include <gtest/gtest.h>
2
5#include "test/testing.h"
6
7namespace yaze {
8namespace test {
9
10class MessageTest : public ::testing::Test {
11 protected:
12 void SetUp() override {
13#if defined(__linux__)
14 GTEST_SKIP();
15#endif
16 EXPECT_OK(rom_.LoadFromFile("zelda3.sfc"));
18 }
19 void TearDown() override {}
20
23 std::vector<editor::DictionaryEntry> dictionary_;
24};
25
26TEST_F(MessageTest, ParseSingleMessage_CommandParsing) {
27 std::vector<uint8_t> mock_data = {0x6A, 0x7F, 0x00};
28 int pos = 0;
29
30 auto result = editor::ParseSingleMessage(mock_data, &pos);
31 EXPECT_TRUE(result.ok());
32 const auto message_data = result.value();
33
34 // Verify that the command was recognized and parsed
35 EXPECT_EQ(message_data.ContentsParsed, "[L]");
36 EXPECT_EQ(pos, 2);
37}
38
39TEST_F(MessageTest, ParseSingleMessage_BasicAscii) {
40 // A, B, C, terminator
41 std::vector<uint8_t> mock_data = {0x00, 0x01, 0x02, 0x7F, 0x00};
42 int pos = 0;
43
44 auto result = editor::ParseSingleMessage(mock_data, &pos);
45 ASSERT_TRUE(result.ok());
46 const auto message_data = result.value();
47 EXPECT_EQ(pos, 4); // consumed all 4 bytes
48
49 std::vector<editor::MessageData> message_data_vector = {message_data};
50 auto parsed = editor::ParseMessageData(message_data_vector, dictionary_);
51
52 EXPECT_THAT(parsed, ::testing::ElementsAre("ABC"));
53}
54
55TEST_F(MessageTest, FindMatchingCharacter_Success) {
56 EXPECT_EQ(editor::FindMatchingCharacter('A'), 0x00);
57 EXPECT_EQ(editor::FindMatchingCharacter('Z'), 0x19);
58 EXPECT_EQ(editor::FindMatchingCharacter('a'), 0x1A);
59 EXPECT_EQ(editor::FindMatchingCharacter('z'), 0x33);
60}
61
62TEST_F(MessageTest, FindMatchingCharacter_Failure) {
63 EXPECT_EQ(editor::FindMatchingCharacter('@'), 0xFF);
64 EXPECT_EQ(editor::FindMatchingCharacter('#'), 0xFF);
65}
66
67TEST_F(MessageTest, FindDictionaryEntry_Success) {
68 EXPECT_EQ(editor::FindDictionaryEntry(0x88), 0x00);
69 EXPECT_EQ(editor::FindDictionaryEntry(0x90), 0x08);
70}
71
72TEST_F(MessageTest, FindDictionaryEntry_Failure) {
73 EXPECT_EQ(editor::FindDictionaryEntry(0x00), -1);
74 EXPECT_EQ(editor::FindDictionaryEntry(0xFF), -1);
75}
76
77TEST_F(MessageTest, ParseMessageToData_Basic) {
78 std::string input = "[L][C:01]ABC";
79 auto result = editor::ParseMessageToData(input);
80 std::vector<uint8_t> expected = {0x6A, 0x77, 0x01, 0x00, 0x01, 0x02};
81 EXPECT_EQ(result, expected);
82}
83
84TEST_F(MessageTest, ReplaceAllDictionaryWords_Success) {
85 std::vector<editor::DictionaryEntry> mock_dict = {
86 editor::DictionaryEntry(0x00, "test"),
87 editor::DictionaryEntry(0x01, "message")};
88 std::string input = "This is a test message.";
89 auto result = editor::ReplaceAllDictionaryWords(input, mock_dict);
90 EXPECT_EQ(result, "This is a [D:00] [D:01].");
91}
92
93TEST_F(MessageTest, ReplaceAllDictionaryWords_NoMatch) {
94 std::vector<editor::DictionaryEntry> mock_dict = {
95 editor::DictionaryEntry(0x00, "hello")};
96 std::string input = "No matching words.";
97 auto result = editor::ReplaceAllDictionaryWords(input, mock_dict);
98 EXPECT_EQ(result, "No matching words.");
99}
100
101TEST_F(MessageTest, ParseTextDataByte_Success) {
102 EXPECT_EQ(editor::ParseTextDataByte(0x00), "A");
103 EXPECT_EQ(editor::ParseTextDataByte(0x74), "[1]");
104 EXPECT_EQ(editor::ParseTextDataByte(0x88), "[D:00]");
105}
106
107TEST_F(MessageTest, ParseTextDataByte_Failure) {
108 EXPECT_EQ(editor::ParseTextDataByte(0xFF), "");
109}
110
111TEST_F(MessageTest, ParseSingleMessage_SpecialCharacters) {
112 std::vector<uint8_t> mock_data = {0x4D, 0x4E, 0x4F, 0x50, 0x7F};
113 int pos = 0;
114
115 auto result = editor::ParseSingleMessage(mock_data, &pos);
116 ASSERT_TRUE(result.ok());
117 const auto message_data = result.value();
118
119 EXPECT_EQ(message_data.ContentsParsed, "[UP][DOWN][LEFT][RIGHT]");
120 EXPECT_EQ(pos, 5);
121}
122
123TEST_F(MessageTest, ParseSingleMessage_DictionaryReference) {
124 std::vector<uint8_t> mock_data = {0x88, 0x89, 0x7F};
125 int pos = 0;
126
127 auto result = editor::ParseSingleMessage(mock_data, &pos);
128 ASSERT_TRUE(result.ok());
129 const auto message_data = result.value();
130
131 EXPECT_EQ(message_data.ContentsParsed, "[D:00][D:01]");
132 EXPECT_EQ(pos, 3);
133}
134
135TEST_F(MessageTest, ParseSingleMessage_InvalidTerminator) {
136 std::vector<uint8_t> mock_data = {0x00, 0x01, 0x02}; // No terminator
137 int pos = 0;
138
139 auto result = editor::ParseSingleMessage(mock_data, &pos);
140 EXPECT_FALSE(result.ok());
141}
142
143TEST_F(MessageTest, ParseSingleMessage_EmptyData) {
144 std::vector<uint8_t> mock_data = {0x7F};
145 int pos = 0;
146
147 auto result = editor::ParseSingleMessage(mock_data, &pos);
148 ASSERT_TRUE(result.ok());
149 const auto message_data = result.value();
150
151 EXPECT_EQ(message_data.ContentsParsed, "");
152 EXPECT_EQ(pos, 1);
153}
154
155TEST_F(MessageTest, OptimizeMessageForDictionary_Basic) {
156 std::vector<editor::DictionaryEntry> mock_dict = {
157 editor::DictionaryEntry(0x00, "Link"),
158 editor::DictionaryEntry(0x01, "Zelda")};
159 std::string input = "[L] rescued Zelda from danger.";
160
161 editor::MessageData message_data;
162 std::string optimized =
163 message_data.OptimizeMessageForDictionary(input, mock_dict);
164
165 EXPECT_EQ(optimized, "[L] rescued [D:01] from danger.");
166}
167
168TEST_F(MessageTest, SetMessage_Success) {
169 std::vector<editor::DictionaryEntry> mock_dict = {
170 editor::DictionaryEntry(0x00, "item")};
171 editor::MessageData message_data;
172 std::string input = "You got an item!";
173
174 message_data.SetMessage(input, mock_dict);
175
176 EXPECT_EQ(message_data.RawString, "You got an item!");
177 EXPECT_EQ(message_data.ContentsParsed, "You got an [D:00]!");
178}
179
180TEST_F(MessageTest, FindMatchingElement_CommandWithArgument) {
181 std::string input = "[W:02]";
183
184 EXPECT_TRUE(result.Active);
185 EXPECT_EQ(result.Parent.Token, "W");
186 EXPECT_EQ(result.Value, 0x02);
187}
188
189TEST_F(MessageTest, FindMatchingElement_InvalidCommand) {
190 std::string input = "[INVALID]";
192
193 EXPECT_FALSE(result.Active);
194}
195
196TEST_F(MessageTest, BuildDictionaryEntries_CorrectSize) {
197 auto result = editor::BuildDictionaryEntries(&rom_);
198 EXPECT_EQ(result.size(), editor::kNumDictionaryEntries);
199 EXPECT_FALSE(result.empty());
200}
201
202} // namespace test
203} // namespace yaze
The Rom class is used to load, save, and modify Rom data.
Definition rom.h:57
void SetUp() override
void TearDown() override
editor::MessageEditor message_editor_
std::vector< editor::DictionaryEntry > dictionary_
uint8_t FindMatchingCharacter(char value)
std::string ParseTextDataByte(uint8_t value)
std::string ReplaceAllDictionaryWords(std::string str, std::vector< DictionaryEntry > dictionary)
constexpr int kNumDictionaryEntries
absl::StatusOr< MessageData > ParseSingleMessage(const std::vector< uint8_t > &rom_data, int *current_pos)
std::vector< std::string > ParseMessageData(std::vector< MessageData > &message_data, const std::vector< DictionaryEntry > &dictionary_entries)
std::vector< DictionaryEntry > BuildDictionaryEntries(Rom *rom)
std::vector< uint8_t > ParseMessageToData(std::string str)
ParsedElement FindMatchingElement(const std::string &str)
int8_t FindDictionaryEntry(uint8_t value)
TEST_F(CpuTest, AsmParserTokenizerOk)
Definition cpu_test.cc:44
Main namespace for the application.
Definition controller.cc:12
std::string OptimizeMessageForDictionary(std::string_view message_string, const std::vector< DictionaryEntry > &dictionary)
void SetMessage(const std::string &message, const std::vector< DictionaryEntry > &dictionary)
#define EXPECT_OK(expr)
Definition testing.h:10