test(readme_parser): improving the readme_parser test suite by adding more tests

dfayd0 · dfayd0 · commit abaca54ff1bb · 2025-06-08T12:09:31.000+02:00
diff --git a/tests/data/1004.md b/tests/data/1004.md
@@ -0,0 +1,28 @@
+# Problem 1004: Max_Consecutive_Ones_III
+
+Given a binary array `nums` and an integer `k`, return *the maximum number of consecutive* `1`*'s in the array if you can flip at most* `k` `0`'s.
+
+**Example 1:**
+
+```
+Input: nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2
+Output: 6
+Explanation: [1,1,1,0,0,1,1,1,1,1,1]
+Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.
+```
+
+**Example 2:**
+
+```
+Input: nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], k = 3
+Output: 10
+Explanation: [0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
+Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.
+
+```
+
+**Constraints:**
+
+* `1 <= nums.length <= 10<sup>5</sup>`
+* `nums[i]` is either `0` or `1`.
+* `0 <= k <= nums.length`
diff --git a/tests/data/1768.md b/tests/data/1768.md
@@ -0,0 +1,46 @@
+# Problem 1768: Merge_Strings_Alternately
+
+You are given two strings `word1` and `word2`. Merge the strings by adding letters in alternating order, starting with `word1`. If a string is longer than the other, append the additional letters onto the end of the merged string.
+
+Return *the merged string.*
+
+**Example 1:**
+
+```
+Input: word1 = "abc", word2 = "pqr"
+Output: "apbqcr"
+Explanation: The merged string will be merged as so:
+word1:  a   b   c
+word2:    p   q   r
+merged: a p b q c r
+
+```
+
+**Example 2:**
+
+```
+Input: word1 = "ab", word2 = "pqrs"
+Output: "apbqrs"
+Explanation: Notice that as word2 is longer, "rs" is appended to the end.
+word1:  a   b
+word2:    p   q   r   s
+merged: a p b q   r   s
+
+```
+
+**Example 3:**
+
+```
+Input: word1 = "abcd", word2 = "pq"
+Output: "apbqcd"
+Explanation: Notice that as word1 is longer, "cd" is appended to the end.
+word1:  a   b   c   d
+word2:    p   q
+merged: a p b q c   d
+
+```
+
+**Constraints:**
+
+* `1 <= word1.length, word2.length <= 100`
+* `word1` and `word2` consist of lowercase English letters.
diff --git a/tests/data/823.md b/tests/data/823.md
@@ -0,0 +1,29 @@
+# Problem 823: Binary_Trees_With_Factors
+
+Given an array of unique integers, `arr`, where each integer `arr[i]` is strictly greater than `1`.
+
+We make a binary tree using these integers, and each number may be used for any number of times. Each non-leaf node's value should be equal to the product of the values of its children.
+
+Return *the number of binary trees we can make*. The answer may be too large so return the answer **modulo** `10<sup>9</sup> + 7`.
+
+**Example 1:**
+
+```
+Input: arr = [2,4]
+Output: 3
+Explanation: We can make these trees: [2], [4], [4, 2, 2]
+```
+
+**Example 2:**
+
+```
+Input: arr = [2,4,5,10]
+Output: 7
+Explanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].
+```
+
+**Constraints:**
+
+* `1 <= arr.length <= 1000`
+* `2 <= arr[i] <= 10<sup>9</sup>`
+* All the values of `arr` are **unique**.
diff --git a/tests/readme_parser_tests.rs b/tests/readme_parser_tests.rs
@@ -114,3 +114,165 @@ fn test_392_outputs_1_parse_readme() {
 
     assert_eq!(output, expected, "second output mismatch");
 }
+
+#[test]
+fn test_823_count_example() {
+    let readme_content = std::fs::read_to_string("tests/data/823.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    assert_eq!(
+        problem_data.example_count, 2,
+        "Expected 2 test cases in the readme"
+    );
+}
+
+#[test]
+fn test_823_inputs_0_parse_readme() {
+    let readme_content = std::fs::read_to_string("tests/data/823.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    let input = &problem_data.inputs[0];
+    let expected = "arr = [2,4]";
+    assert_eq!(input, expected, "first input mismatch");
+}
+
+#[test]
+fn test_823_outputs_1_parse_readme() {
+    let readme_content = std::fs::read_to_string("tests/data/823.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    let output = &problem_data.outputs[1];
+    let expected = "7";
+    assert_eq!(output, expected, "second output mismatch");
+}
+
+#[test]
+fn test_1768_count_example() {
+    let readme_content = std::fs::read_to_string("tests/data/1768.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    assert_eq!(
+        problem_data.example_count, 3,
+        "Expected 3 test cases in the readme"
+    );
+}
+
+#[test]
+fn test_1768_inputs_0_parse_readme() {
+    let readme_content = std::fs::read_to_string("tests/data/1768.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    let input = &problem_data.inputs[0];
+    let expected = "word1 = \"abc\", word2 = \"pqr\"";
+    assert_eq!(input, expected, "first input mismatch");
+}
+
+#[test]
+fn test_1768_outputs_1_parse_readme() {
+    let readme_content = std::fs::read_to_string("tests/data/1768.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    let output = &problem_data.outputs[1];
+    let expected = "\"apbqrs\"";
+    assert_eq!(output, expected, "second output mismatch");
+}
+
+#[test]
+fn test_1768_outputs_2_parse_readme() {
+    let readme_content = std::fs::read_to_string("tests/data/1768.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    let output = &problem_data.outputs[2];
+    let expected = "\"apbqcd\"";
+    assert_eq!(output, expected, "3rd output mismatch");
+}
+
+#[test]
+fn test_1004_count_example() {
+    let readme_content = std::fs::read_to_string("tests/data/1004.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    assert_eq!(
+        problem_data.example_count, 2,
+        "Expected 2 test cases in the readme"
+    );
+}
+
+#[test]
+fn test_1004_inputs_0_parse_readme() {
+    let readme_content = std::fs::read_to_string("tests/data/1004.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    let input = &problem_data.inputs[0];
+    let expected = "nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2";
+    assert_eq!(input, expected, "first input mismatch");
+}
+
+#[test]
+fn test_1004_inputs_1_parse_readme() {
+    let readme_content = std::fs::read_to_string("tests/data/1004.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    let input = &problem_data.inputs[1];
+    let expected = "nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], k = 3";
+    assert_eq!(input, expected, "first input mismatch");
+}
+
+#[test]
+fn test_1004_outputs_0_parse_readme() {
+    let readme_content = std::fs::read_to_string("tests/data/1004.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    let output = &problem_data.outputs[0];
+    let expected = "6";
+    assert_eq!(output, expected, "second output mismatch");
+}
+
+#[test]
+fn test_1004_outputs_1_parse_readme() {
+    let readme_content = std::fs::read_to_string("tests/data/1004.md")
+        .expect("Failed to read test readme file");
+    let lrp = LeetcodeReadmeParser::new(&readme_content);
+    let result = lrp.parse();
+    assert!(result.is_ok(), "Failed to parse readme: {:?}", result.err());
+    let problem_data = result.unwrap();
+    let output = &problem_data.outputs[1];
+    let expected = "10";
+    assert_eq!(output, expected, "second output mismatch");
+}
