Skip to content

Offline, privacy-first grammar checker. Fast, open-source, Rust-powered

feat: play a factor → play a part/role / be a factor (#4310)

Andrew Dunbar23dd225d1cb8
diff --git a/harper-core/default_config.json b/harper-core/default_config.json
index 95db640c6..58572e4a6 100644
--- a/harper-core/default_config.json
+++ b/harper-core/default_config.json
@@ -4057,7 +4057,7 @@
"Bool": {
"name": "AheadAnd",
"state": true,
- "label": "Ahead And"
+ "label": "Ahead and"
}
},
{
@@ -5439,6 +5439,13 @@
"label": "Pique Interest"
}
},
+ {
+ "Bool": {
+ "name": "PlayAFactor",
+ "state": true,
+ "label": "Play a Factor"
+ }
+ },
{
"Bool": {
"name": "PrayingMantis",
diff --git a/harper-core/src/linting/phrase_set_corrections/many_to_many_tests.rs b/harper-core/src/linting/phrase_set_corrections/many_to_many_tests.rs
new file mode 100644
index 000000000..5eadce866
--- /dev/null
+++ b/harper-core/src/linting/phrase_set_corrections/many_to_many_tests.rs
@@ -0,0 +1,1874 @@
+use super::LintGroup;
+use crate::linting::pooled_linter::for_tests::create_test_pool;
+use crate::linting::tests::{
+ assert_good_and_bad_suggestions, assert_lint_count, assert_no_lints, assert_suggestion_result,
+};
+
+use super::lint_group;
+
+// Use a global pool of lint groups to amortize construction costs.
+create_test_pool!(LintGroup, LintGroup, lint_group());
+
+/// Helper function to create a lint group with only a single rule enabled.
+fn single_lint(rule_name: &str) -> crate::linting::LintGroup {
+ let mut group = lint_group();
+ group.set_all_rules_to(None); // Disable all linters
+ group.config.set_rule_enabled(rule_name, true); // Enable only the specified rule
+ group
+}
+
+// AwaitFor
+
+#[test]
+fn correct_awaits_for() {
+ assert_good_and_bad_suggestions(
+ "Headless mode awaits for requested user feedback without showing any text for what that feedback should be",
+ test_linter(),
+ &[
+ "Headless mode awaits requested user feedback without showing any text for what that feedback should be",
+ "Headless mode waits for requested user feedback without showing any text for what that feedback should be",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn correct_awaiting_for() {
+ assert_good_and_bad_suggestions(
+ "gpg import fails awaiting for prompt answer",
+ test_linter(),
+ &[
+ "gpg import fails waiting for prompt answer",
+ "gpg import fails awaiting prompt answer",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn correct_await_for() {
+ assert_good_and_bad_suggestions(
+ "I still await for a college course on \"Followership 101\"",
+ test_linter(),
+ &[
+ "I still wait for a college course on \"Followership 101\"",
+ "I still await a college course on \"Followership 101\"",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn correct_awaited_for() {
+ assert_good_and_bad_suggestions(
+ "I have long awaited for the rise of the Dagoat agenda, and it is glorious.",
+ test_linter(),
+ &[
+ "I have long awaited the rise of the Dagoat agenda, and it is glorious.",
+ "I have long waited for the rise of the Dagoat agenda, and it is glorious.",
+ ],
+ &[],
+ );
+}
+
+// BackhandedCompliment
+
+#[test]
+fn correct_backhand_compliment() {
+ assert_suggestion_result(
+ "What's the Most insulting /backhand compliment you have ever received?",
+ test_linter(),
+ "What's the Most insulting /backhanded compliment you have ever received?",
+ );
+}
+
+#[test]
+fn correct_back_hand_compliment_space() {
+ assert_suggestion_result(
+ "Thankfully, I'm a little young to receive that back hand compliment",
+ test_linter(),
+ "Thankfully, I'm a little young to receive that backhanded compliment",
+ );
+}
+
+#[test]
+fn correct_back_hand_compliment_hyphen() {
+ assert_suggestion_result(
+ "They \"have it all\", but still need to back-hand compliment, condescend, \"politely\" hurl passive-aggressive compliments/insults",
+ test_linter(),
+ "They \"have it all\", but still need to backhanded compliment, condescend, \"politely\" hurl passive-aggressive compliments/insults",
+ );
+}
+
+#[test]
+fn correct_backhand_compliments() {
+ assert_suggestion_result(
+ "If backhand compliments or flattery are frequent and come with ulterior motives, it's a red flag.",
+ test_linter(),
+ "If backhanded compliments or flattery are frequent and come with ulterior motives, it's a red flag.",
+ );
+}
+
+#[test]
+fn correct_back_hand_compliments() {
+ assert_suggestion_result(
+ "I am laughing so hard watching the \"commercial\" with her back hand compliments.",
+ test_linter(),
+ "I am laughing so hard watching the \"commercial\" with her backhanded compliments.",
+ );
+}
+
+#[test]
+fn correct_back_hand_compliments_caps() {
+ assert_suggestion_result(
+ "JUST SAY YOU DON'T LIKE THEM STOP GIVING FAKE BACK HAND COMPLIMENTS.",
+ test_linter(),
+ "JUST SAY YOU DON'T LIKE THEM STOP GIVING FAKE BACKHANDED COMPLIMENTS.",
+ );
+}
+
+// no praises, just tons of unnecessary back-hand compliments and lack of support
+#[test]
+fn correct_back_hand_compliments_hyphen() {
+ assert_suggestion_result(
+ "no praises, just tons of unnecessary back-hand compliments and lack of support",
+ test_linter(),
+ "no praises, just tons of unnecessary backhanded compliments and lack of support",
+ );
+}
+
+// CommitmentTo
+
+#[test]
+fn singular_towards() {
+ assert_suggestion_result(
+ "the platform's focus on multimedia projects and VideoLAN's long history of commitment towards free and open multimedia",
+ test_linter(),
+ "the platform's focus on multimedia projects and VideoLAN's long history of commitment to free and open multimedia",
+ );
+}
+
+#[test]
+fn plural_towards() {
+ assert_suggestion_result(
+ "the signer may express multiple commitments towards the data objects",
+ test_linter(),
+ "the signer may express multiple commitments to the data objects",
+ );
+}
+
+#[test]
+fn singular_toward() {
+ assert_suggestion_result(
+ "This document outlines the current level of commitment toward Linux distributions and packaging formats.",
+ test_linter(),
+ "This document outlines the current level of commitment to Linux distributions and packaging formats.",
+ );
+}
+
+#[test]
+fn plural_toward() {
+ assert_suggestion_result(
+ "... and are expected to inform parties in updating their commitments toward the Paris Agreement",
+ test_linter(),
+ "... and are expected to inform parties in updating their commitments to the Paris Agreement",
+ );
+}
+
+// Copyright
+
+#[test]
+fn copywritten() {
+ assert_suggestion_result(
+ "Including digital copies of copywritten artwork with the project isn't advised.",
+ test_linter(),
+ "Including digital copies of copyrighted artwork with the project isn't advised.",
+ );
+}
+
+#[test]
+fn copywrites() {
+ assert_suggestion_result(
+ "Code is 99% copy/pasted from OpenSSH with an attempt to retain all copywrites",
+ test_linter(),
+ "Code is 99% copy/pasted from OpenSSH with an attempt to retain all copyrights",
+ );
+}
+
+#[test]
+fn copywrited() {
+ assert_suggestion_result(
+ "Proprietary copywrited code",
+ test_linter(),
+ "Proprietary copyrighted code",
+ );
+}
+
+#[test]
+fn copywrited_all_caps() {
+ assert_suggestion_result(
+ "URLS MAY CONTAIN COPYWRITED MATERIAL",
+ test_linter(),
+ "URLS MAY CONTAIN COPYRIGHTED MATERIAL",
+ );
+}
+
+#[test]
+fn copywrote() {
+ assert_suggestion_result(
+ "How do you find out if someone copywrote a movie",
+ test_linter(),
+ "How do you find out if someone copyrighted a movie",
+ );
+}
+
+// DateBackFrom
+
+#[test]
+fn corrects_date_back_from() {
+ assert_good_and_bad_suggestions(
+ "There are too many open issues that date back from 4 years ago.",
+ test_linter(),
+ &[
+ "There are too many open issues that date from 4 years ago.",
+ "There are too many open issues that date back to 4 years ago.",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn corrects_dates_back_from() {
+ assert_good_and_bad_suggestions(
+ "This code dates back from 2014.",
+ test_linter(),
+ &[
+ "This code dates from 2014.",
+ "This code dates back to 2014.",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn allows_date_back_to() {
+ assert_no_lints(
+ "These scripts date back to when Perl was popular.",
+ test_linter(),
+ );
+}
+
+// Note: "the date back from" and "get dates back from" are known false
+// positives where "date" is a noun (retrieving data). Phrase set matching
+// cannot distinguish these from the verb form. See issue #2864.
+
+// DoubleEdgedSword
+
+#[test]
+fn correct_double_edge_hyphen() {
+ assert_suggestion_result(
+ "I thought the global defaultTranslationValues was potentially a double-edge sword as it also obfuscates the full set of values",
+ test_linter(),
+ "I thought the global defaultTranslationValues was potentially a double-edged sword as it also obfuscates the full set of values",
+ );
+}
+
+#[test]
+fn correct_double_edge_space() {
+ assert_suggestion_result(
+ "It becomes a double edge sword when it should not be used in cases like this.",
+ test_linter(),
+ "It becomes a double-edged sword when it should not be used in cases like this.",
+ );
+}
+
+#[test]
+fn correct_double_edge_space_plural() {
+ assert_suggestion_result(
+ "Wake locks are really double edge swords.",
+ test_linter(),
+ "Wake locks are really double-edged swords.",
+ );
+}
+
+#[test]
+fn correct_double_edged_space() {
+ assert_suggestion_result(
+ "Use case. currently OPTIMIZE is a double edged sword and potentially a very dangerous tool to use.",
+ test_linter(),
+ "Use case. currently OPTIMIZE is a double-edged sword and potentially a very dangerous tool to use.",
+ );
+}
+
+#[test]
+fn correct_double_edged_space_plural() {
+ assert_suggestion_result(
+ "Change: Ambushers and Crusaders now protect their targets too, making them double edged swords",
+ test_linter(),
+ "Change: Ambushers and Crusaders now protect their targets too, making them double-edged swords",
+ );
+}
+
+// ExpandAlloc
+
+#[test]
+fn corrects_allocs() {
+ assert_suggestion_result(
+ "cmd/compile: avoid allocs by better tracking of literals for interface conversions and make",
+ test_linter(),
+ "cmd/compile: avoid allocations by better tracking of literals for interface conversions and make",
+ );
+}
+
+#[test]
+fn expand_alloc() {
+ assert_suggestion_result(
+ "Used to find system libraries that alloc RWX regions on load.",
+ test_linter(),
+ "Used to find system libraries that allocate RWX regions on load.",
+ );
+}
+
+// ExpandGovt
+
+#[test]
+fn corrects_govt_no_dot() {
+ assert_suggestion_result(
+ "Separation between privately issued credentials vs govt issued identity credentials",
+ test_linter(),
+ "Separation between privately issued credentials vs government issued identity credentials",
+ );
+}
+
+#[test]
+fn corrects_govt_do() {
+ assert_suggestion_result(
+ "Demystifying public comments on govt. regulations.",
+ test_linter(),
+ "Demystifying public comments on government regulations.",
+ );
+}
+
+#[test]
+fn corrects_govts() {
+ assert_suggestion_result(
+ "Those 'elite' economists have been advising govts for years.",
+ test_linter(),
+ "Those 'elite' economists have been advising governments for years.",
+ );
+}
+
+// Expat
+
+#[test]
+fn correct_ex_pat_hyphen() {
+ assert_suggestion_result(
+ "It seems ex-pat means the person will be in a foreign country temporarily",
+ test_linter(),
+ "It seems expat means the person will be in a foreign country temporarily",
+ );
+}
+
+#[test]
+fn correct_ex_pats_hyphen() {
+ assert_suggestion_result(
+ "So, it might be correct to call most Brits ex-pats.",
+ test_linter(),
+ "So, it might be correct to call most Brits expats.",
+ );
+}
+
+#[test]
+fn correct_ex_pat_space() {
+ assert_suggestion_result(
+ "For me, the term ex pat embodies the exquisite hypocrisy of certain people feeling entitled",
+ test_linter(),
+ "For me, the term expat embodies the exquisite hypocrisy of certain people feeling entitled",
+ );
+}
+
+#[test]
+#[ignore = "replace_with_match_case results in ExPats"]
+fn correct_ex_pats_space() {
+ assert_suggestion_result(
+ "Why are Brits who emigrate \"Ex Pats\" but people who come here \"immigrants\"?",
+ test_linter(),
+ "Why are Brits who emigrate \"Expats\" but people who come here \"immigrants\"?",
+ );
+}
+
+// Expatriate
+
+#[test]
+fn correct_expatriot() {
+ assert_suggestion_result(
+ "Another expatriot of the era, James Joyce, also followed Papa's writing and drinking schedule.",
+ test_linter(),
+ "Another expatriate of the era, James Joyce, also followed Papa's writing and drinking schedule.",
+ );
+}
+
+#[test]
+fn correct_expatriots() {
+ assert_suggestion_result(
+ "Expatriots, upon discovering the delightful nuances of Dutch pronunciation, often find themselves in stitches.",
+ test_linter(),
+ "Expatriates, upon discovering the delightful nuances of Dutch pronunciation, often find themselves in stitches.",
+ );
+}
+
+#[test]
+fn correct_ex_patriot_hyphen() {
+ assert_suggestion_result(
+ "Then I added we should all be using the word 移民 immigrant, not ex-patriot, not 外国人 gaikokujin, and definitely not 外人 gaijin",
+ test_linter(),
+ "Then I added we should all be using the word 移民 immigrant, not expatriate, not 外国人 gaikokujin, and definitely not 外人 gaijin",
+ );
+}
+
+#[test]
+fn correct_ex_patriots_hyphen() {
+ assert_suggestion_result(
+ "Ex-patriots who move to Hong Kong to seek greener pastures and to experience a new culture seem to bring their own cultural baggage with them.",
+ test_linter(),
+ "Expatriates who move to Hong Kong to seek greener pastures and to experience a new culture seem to bring their own cultural baggage with them.",
+ );
+}
+
+// GetRidOf
+
+#[test]
+fn get_rid_off() {
+ assert_suggestion_result(
+ "Please bump axios version to get rid off npm warning #624",
+ test_linter(),
+ "Please bump axios version to get rid of npm warning #624",
+ );
+}
+
+#[test]
+fn gets_rid_off() {
+ assert_suggestion_result(
+ "Adding at as a runtime dependency gets rid off that error",
+ test_linter(),
+ "Adding at as a runtime dependency gets rid of that error",
+ );
+}
+
+#[test]
+fn getting_rid_off() {
+ assert_suggestion_result(
+ "getting rid off of all the complexity of the different accesses method of API service providers",
+ test_linter(),
+ "getting rid of of all the complexity of the different accesses method of API service providers",
+ );
+}
+
+#[test]
+fn got_rid_off() {
+ assert_suggestion_result(
+ "For now we got rid off circular deps in model tree structure and it's API.",
+ test_linter(),
+ "For now we got rid of circular dependencies in model tree structure and it's API.",
+ );
+}
+
+#[test]
+fn gotten_rid_off() {
+ assert_suggestion_result(
+ "The baX variable thingy I have gotten rid off, that was due to a bad character in the encryption key.",
+ test_linter(),
+ "The baX variable thingy I have gotten rid of, that was due to a bad character in the encryption key.",
+ );
+}
+
+#[test]
+fn get_ride_of() {
+ assert_suggestion_result(
+ "Get ride of \"WARNING Deprecated: markdown_github. Use gfm\"",
+ test_linter(),
+ "Get rid of \"WARNING Deprecated: markdown_github. Use gfm\"",
+ );
+}
+
+#[test]
+fn get_ride_off() {
+ assert_suggestion_result(
+ "This exact hack was what I trying to get ride off. ",
+ test_linter(),
+ "This exact hack was what I trying to get rid of. ",
+ );
+}
+
+#[test]
+fn getting_ride_of() {
+ assert_suggestion_result(
+ "If you have any idea how to fix this without getting ride of bootstrap I would be thankfull.",
+ test_linter(),
+ "If you have any idea how to fix this without getting rid of bootstrap I would be thankfull.",
+ );
+}
+
+#[test]
+fn gets_ride_of() {
+ assert_suggestion_result(
+ ".. gets ride of a central back-end/server and eliminates all the risks associated to it.",
+ test_linter(),
+ ".. gets rid of a central back-end/server and eliminates all the risks associated to it.",
+ );
+}
+
+#[test]
+fn gotten_ride_of() {
+ assert_suggestion_result(
+ "I have gotten ride of the react-table and everything works just fine.",
+ test_linter(),
+ "I have gotten rid of the react-table and everything works just fine.",
+ );
+}
+
+#[test]
+fn got_ride_of() {
+ assert_suggestion_result(
+ "I had to adjust the labels on the free version because you guys got ride of ...",
+ test_linter(),
+ "I had to adjust the labels on the free version because you guys got rid of ...",
+ );
+}
+
+// HolyWar
+
+#[test]
+#[ignore = "Known failure due to replace_with_match_case working by character index"]
+fn correct_holy_war() {
+ assert_suggestion_result(
+ "I know it is Holly War about idempotent in HTTP and DELETE",
+ test_linter(),
+ "I know it is Holy War about idempotent in HTTP and DELETE",
+ );
+}
+
+#[test]
+fn correct_holly_wars() {
+ assert_suggestion_result(
+ "Anyway I'm not starting some holly wars about this point.",
+ test_linter(),
+ "Anyway I'm not starting some holy wars about this point.",
+ );
+}
+
+// HowItLooksLike
+
+#[test]
+fn correct_how_it_looks_like_1() {
+ assert_suggestion_result(
+ "And here is how it looks like: As you can see, there is no real difference in the diagram itself.",
+ test_linter(),
+ "And here is how it looks: As you can see, there is no real difference in the diagram itself.",
+ );
+}
+
+#[test]
+fn correct_how_it_looks_like_2() {
+ assert_suggestion_result(
+ "This is how it looks like when run from Windows PowerShell or Cmd: image.",
+ test_linter(),
+ "This is what it looks like when run from Windows PowerShell or Cmd: image.",
+ );
+}
+
+#[test]
+fn correct_how_they_look_like_1() {
+ assert_suggestion_result(
+ "This is a sample project illustrating a demo of how to use the new Material 3 components and how they look like.",
+ test_linter(),
+ "This is a sample project illustrating a demo of how to use the new Material 3 components and how they look.",
+ );
+}
+
+#[test]
+fn correct_how_they_look_like_2() {
+ assert_suggestion_result(
+ "So for now I'll just leave this issue here of how they look like in the XLSX",
+ test_linter(),
+ "So for now I'll just leave this issue here of what they look like in the XLSX",
+ );
+}
+
+#[test]
+fn correct_how_they_looks_like_1() {
+ assert_suggestion_result(
+ "Here I demonstrate how disney works and how they looks like Don't miss to give me a star.",
+ test_linter(),
+ "Here I demonstrate how disney works and how they look Don't miss to give me a star.",
+ );
+}
+
+#[test]
+fn correct_how_they_looks_like_2() {
+ assert_suggestion_result(
+ "You can check how they looks like on Android app by this command:",
+ test_linter(),
+ "You can check what they look like on Android app by this command:",
+ );
+}
+
+#[test]
+fn correct_how_she_looks_like_1() {
+ assert_suggestion_result(
+ "You all know how she looks like.",
+ test_linter(),
+ "You all know how she looks.",
+ );
+}
+
+#[test]
+fn correct_how_he_looks_like_2() {
+ assert_suggestion_result(
+ "Here's how he looks like, when he's supposed to just look like his old fatui design.",
+ test_linter(),
+ "Here's what he looks like, when he's supposed to just look like his old fatui design.",
+ );
+}
+
+#[test]
+fn correct_how_it_look_like_1() {
+ assert_suggestion_result(
+ "And I don't mind how it look like, language code subpath or the last subpath as below.",
+ test_linter(),
+ "And I don't mind how it looks, language code subpath or the last subpath as below.",
+ );
+}
+
+#[test]
+fn correct_how_it_look_like_2() {
+ assert_suggestion_result(
+ "Here is how it look like in your browser:",
+ test_linter(),
+ "Here is what it looks like in your browser:",
+ );
+}
+
+#[test]
+fn correct_how_it_looks_like_with_apostrophe() {
+ assert_suggestion_result(
+ "In the picture we can see how It look's like on worker desktop.",
+ test_linter(),
+ "In the picture we can see how It looks on worker desktop.",
+ );
+}
+
+// InRetaliationTo
+
+#[test]
+fn corrects_in_retaliation_to_to_for() {
+ assert_suggestion_result(
+ "Damage caused in retaliation to another attack by the Thorns enchantment.",
+ test_linter(),
+ "Damage caused in retaliation for another attack by the Thorns enchantment.",
+ );
+}
+
+#[test]
+fn corrects_in_retaliation_to_to_in_response_to() {
+ assert_suggestion_result(
+ "In retaliation to disagreeing with legal naming issues, a crucial (albeit rather small) section of code was removed from the NPM database",
+ test_linter(),
+ "In response to disagreeing with legal naming issues, a crucial (albeit rather small) section of code was removed from the NPM database",
+ );
+}
+
+// LevelOfDetails
+
+#[test]
+fn corrects_level_of_details_singular_contrived() {
+ assert_suggestion_result(
+ "The model has a high level of details.",
+ test_linter(),
+ "The model has a high level of detail.",
+ );
+}
+
+fn corrects_levels_of_details_plural_contrived() {
+ assert_suggestion_result(
+ "The game uses several level of details to save memory.",
+ test_linter(),
+ "The game uses several levels of detail to save memory.",
+ );
+}
+
+#[test]
+fn corrects_level_of_details_singular_real_world() {
+ assert_suggestion_result(
+ "How to implement a level of details visualizer for 3D meshes?",
+ test_linter(),
+ "How to implement a level of detail visualizer for 3D meshes?",
+ );
+}
+
+#[test]
+fn corrects_level_of_details_plural_real_world() {
+ assert_suggestion_result(
+ "LOD's (Level of details) are a set of lower models used for the purpose of optimisation",
+ test_linter(),
+ "LOD's (Levels of detail) are a set of lower models used for the purpose of optimisation",
+ );
+}
+
+#[test]
+fn corrects_levels_of_details_real_world() {
+ assert_suggestion_result(
+ "The file completion uses two levels of details to optimize performance.",
+ test_linter(),
+ "The file completion uses two levels of detail to optimize performance.",
+ );
+}
+
+// Lookalike
+
+#[test]
+fn corrects_look_a_like() {
+ assert_good_and_bad_suggestions(
+ "Define the look-a-like of the cursor/mouse pointer:",
+ test_linter(),
+ &[
+ "Define the lookalike of the cursor/mouse pointer:",
+ "Define the look-alike of the cursor/mouse pointer:",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn corrects_look_a_likes() {
+ assert_good_and_bad_suggestions(
+ "Attempt at using AWS facial recognition to find look-a-likes in the Rijksmuseum's art collection.",
+ test_linter(),
+ &[
+ "Attempt at using AWS facial recognition to find lookalikes in the Rijksmuseum's art collection.",
+ "Attempt at using AWS facial recognition to find look-alikes in the Rijksmuseum's art collection.",
+ ],
+ &[],
+ );
+}
+
+// MakeItSeem
+
+#[test]
+fn corrects_make_it_seems() {
+ assert_suggestion_result(
+ "but put it into unlisted list may make it seems like listed for GitHub",
+ test_linter(),
+ "but put it into unlisted list may make it seem like listed for GitHub",
+ );
+}
+
+#[test]
+fn corrects_made_it_seems() {
+ assert_suggestion_result(
+ "previous explanations made it seems like it would be n",
+ test_linter(),
+ "previous explanations made it seem like it would be n",
+ );
+}
+
+#[test]
+fn corrects_makes_it_seems() {
+ assert_suggestion_result(
+ "bundle gives an error that makes it seems like esbuild is trying to use lib/index.js from main",
+ test_linter(),
+ "bundle gives an error that makes it seem like esbuild is trying to use lib/index.js from main",
+ );
+}
+
+#[test]
+fn corrects_making_it_seems() {
+ assert_suggestion_result(
+ "Is it possible to teach the concept of assignment/reassignment at the very beginner stage instead of making it seems like constants?",
+ test_linter(),
+ "Is it possible to teach the concept of assignment/reassignment at the very beginner stage instead of making it seem like constants?",
+ );
+}
+
+#[test]
+fn corrects_made_it_seemed() {
+ assert_suggestion_result(
+ "The path made it seemed a bit \"internal\".",
+ test_linter(),
+ "The path made it seem a bit \"internal\".",
+ );
+}
+
+// Monumentous
+
+#[test]
+fn corrects_monumentous() {
+ assert_suggestion_result(
+ "I think that would be a monumentous step in the right direction, and would DEFINATLY turn heads in not just the music industry, but every ...",
+ test_linter(),
+ "I think that would be a momentous step in the right direction, and would DEFINATLY turn heads in not just the music industry, but every ...",
+ );
+}
+
+#[test]
+fn corrects_monumentously() {
+ assert_suggestion_result(
+ "the most impressive thing out of all of this is that GitHub created such a monumentously good name",
+ test_linter(),
+ "the most impressive thing out of all of this is that GitHub created such a monumentally good name",
+ );
+}
+
+// NervousWreck
+
+#[test]
+#[ignore = "Harper matches case by letter index as 'How Not to Be a Complete NervoUs wreck in an Interview'"]
+fn correct_nerve_wreck_space_title_case() {
+ assert_suggestion_result(
+ "How Not to Be a Complete Nerve Wreck in an Interview",
+ test_linter(),
+ "How Not to Be a Complete Nervous Wreck in an Interview",
+ );
+}
+
+#[test]
+fn correct_nerve_wreck_space() {
+ assert_suggestion_result(
+ "The nerve wreck you are makes you seem anxious and agitated so your employer will believe the complaints.",
+ test_linter(),
+ "The nervous wreck you are makes you seem anxious and agitated so your employer will believe the complaints.",
+ );
+}
+
+#[test]
+fn correct_nerve_wreck_hyphen() {
+ assert_suggestion_result(
+ "the child receives little education and grows up to be a nerve-wreck",
+ test_linter(),
+ "the child receives little education and grows up to be a nervous wreck",
+ );
+}
+
+#[test]
+fn correct_nerve_wreck_hyphen_plural() {
+ assert_suggestion_result(
+ "This helps us not to become nerve wrecks while looking at the side mirrors",
+ test_linter(),
+ "This helps us not to become nervous wrecks while looking at the side mirrors",
+ );
+}
+
+#[test]
+#[ignore = "We can't detect when the altered form is used for an event rather than a person."]
+fn dont_correct_it_was_a_nerve_wreck() {
+ assert_no_lints(
+ "It was a nerve-wreck, but I was also excited to see what would happen next.",
+ test_linter(),
+ );
+}
+
+#[test]
+#[ignore = "We can't detect when the altered form is used for an event rather than a person."]
+fn dont_correct_so_much_nerve_wreck() {
+ assert_no_lints(
+ "So much nerve wreck for such a simple game ...",
+ test_linter(),
+ );
+}
+
+// NotOnly
+
+// -not only are-
+#[test]
+fn fix_no_only_are() {
+ assert_suggestion_result(
+ "No only are tests run on my pipeline but once successful, my app is deployed differently",
+ test_linter(),
+ "Not only are tests run on my pipeline but once successful, my app is deployed differently",
+ );
+}
+
+// -not only is-
+#[test]
+fn fix_no_only_is() {
+ assert_suggestion_result(
+ "No only is it simple, it's efficient!",
+ test_linter(),
+ "Not only is it simple, it's efficient!",
+ );
+}
+
+// -not only was-
+#[test]
+fn fix_no_only_was() {
+ assert_suggestion_result(
+ "No only was he happily creating shapes, but he was actively using distances and angles to do so.",
+ test_linter(),
+ "Not only was he happily creating shapes, but he was actively using distances and angles to do so.",
+ );
+}
+
+// -not only were-
+#[test]
+fn fix_no_only_were() {
+ assert_suggestion_result(
+ "No only were there UI inconsistencies, but Safari lags behind chrome with things like the Popover API",
+ test_linter(),
+ "Not only were there UI inconsistencies, but Safari lags behind chrome with things like the Popover API",
+ );
+}
+
+// Nowadays
+
+#[test]
+fn fix_now_a_days_spaces() {
+ assert_suggestion_result(
+ "Now a days, movie recommendation systems are well developed and are user focused.",
+ test_linter(),
+ "Nowadays, movie recommendation systems are well developed and are user focused.",
+ );
+}
+
+#[test]
+fn fix_now_a_days_apostrophe() {
+ assert_suggestion_result(
+ "Now a day's recognizing the activity from the surveillance video is a challenging task.",
+ test_linter(),
+ "Nowadays recognizing the activity from the surveillance video is a challenging task.",
+ );
+}
+
+#[test]
+fn fix_now_a_days_hyphen() {
+ assert_suggestion_result(
+ "Recommendation engines are now a one of the most common Machine Learning project that can be seen now-a-days.",
+ test_linter(),
+ "Recommendation engines are now a one of the most common Machine Learning project that can be seen nowadays.",
+ );
+}
+
+#[test]
+fn fix_now_a_day() {
+ assert_suggestion_result(
+ "Now a day a calendar is a daily essential things.",
+ test_linter(),
+ "Nowadays a calendar is a daily essential things.",
+ );
+}
+
+#[test]
+fn fix_now_a_day_hyphen() {
+ assert_suggestion_result(
+ "Now-a-day, lots of people prefer ordering food online to save their time and effort.",
+ test_linter(),
+ "Nowadays, lots of people prefer ordering food online to save their time and effort.",
+ );
+}
+
+#[test]
+fn fix_now_adays_hyphen() {
+ assert_suggestion_result(
+ "@andyp1per knows most about those Python scripts now-adays.",
+ test_linter(),
+ "@andyp1per knows most about those Python scripts nowadays.",
+ );
+}
+
+#[test]
+fn fix_now_adays_space() {
+ assert_suggestion_result(
+ "Coding is one of my fav thing to do now adays.!",
+ test_linter(),
+ "Coding is one of my fav thing to do nowadays.!",
+ );
+}
+
+#[test]
+fn fix_nowaday() {
+ assert_suggestion_result(
+ "nowaday, I have to capitalize the first letter of the name gets from @babel/types.",
+ test_linter(),
+ "nowadays, I have to capitalize the first letter of the name gets from @babel/types.",
+ );
+}
+
+#[test]
+fn fix_now_adays_apostrophe() {
+ assert_suggestion_result(
+ "I believe CSS clamp has great browser support now aday's as well.",
+ test_linter(),
+ "I believe CSS clamp has great browser support nowadays as well.",
+ );
+}
+
+#[test]
+fn fix_nowa_days() {
+ assert_suggestion_result(
+ "But discord would be great cause discord is universally used for all games and companies and schools nowa days.",
+ test_linter(),
+ "But discord would be great cause discord is universally used for all games and companies and schools nowadays.",
+ );
+}
+
+#[test]
+fn fix_now_aday() {
+ assert_suggestion_result(
+ "OF all Occupations that now aday is used,I would not be a butcher",
+ test_linter(),
+ "OF all Occupations that nowadays is used,I would not be a butcher",
+ );
+}
+
+// Payed
+
+#[test]
+fn correct_payed() {
+ assert_suggestion_result(
+ "He payed the bill yesterday.",
+ test_linter(),
+ "He paid the bill yesterday.",
+ );
+}
+
+#[test]
+fn correct_overpayed() {
+ assert_suggestion_result(
+ "He overpayed in part to have the specification met.",
+ test_linter(),
+ "He overpaid in part to have the specification met.",
+ );
+}
+
+// PlayAFactor
+
+#[test]
+fn play_a_factor() {
+ assert_good_and_bad_suggestions(
+ "I thought scaling might play a factor in this so I made sure it was 100% on all three desktops.",
+ test_linter(),
+ &[
+ "I thought scaling might play a part in this so I made sure it was 100% on all three desktops.",
+ "I thought scaling might be a factor in this so I made sure it was 100% on all three desktops.",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn played_a_factor_sg() {
+ assert_good_and_bad_suggestions(
+ "I want you to look past them, because none of them played a factor in composing a dream team.",
+ test_linter(),
+ &[
+ "I want you to look past them, because none of them played a part in composing a dream team.",
+ "I want you to look past them, because none of them was a factor in composing a dream team.",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn played_a_factor_pl() {
+ assert_good_and_bad_suggestions(
+ "we have no idea why they do what they do and what past external influences played factors in those decisions",
+ test_linter(),
+ &[
+ "we have no idea why they do what they do and what past external influences played roles in those decisions",
+ "we have no idea why they do what they do and what past external influences were a factor in those decisions",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn playing_a_factor() {
+ assert_good_and_bad_suggestions(
+ "I think my development 'forceIP' was playing a factor here.",
+ test_linter(),
+ &[
+ "I think my development 'forceIP' was playing a part here.",
+ "I think my development 'forceIP' was a factor here.",
+ ],
+ &[],
+ );
+}
+
+#[test]
+fn plays_a_factor() {
+ assert_good_and_bad_suggestions(
+ "The amount of time since the change certainly plays a factor since we upgraded to eslint v6 3 years ago.",
+ test_linter(),
+ &[
+ "The amount of time since the change certainly plays a part since we upgraded to eslint v6 3 years ago.",
+ "The amount of time since the change certainly is a factor since we upgraded to eslint v6 3 years ago.",
+ ],
+ &[],
+ );
+}
+
+// - -PlayAFactor- known false positives -
+// so more thought might go into bringing into play factors seldom addressed
+// how much team play factors such as team cohesion, and skills coverage can affect the result
+// It appears his role was to explore game playing factors, which are hard to ...
+// Age, literacy, learning disabilities, as well as physical disabilities all play factors here.
+// timing of defaults, salvage value, etc. all play factors
+
+// RaiseTheQuestion
+
+// -raise the question-
+#[test]
+fn detect_rise_the_question() {
+ assert_suggestion_result(
+ "That would rise the question how to deal with syntax errors etc.",
+ test_linter(),
+ "That would raise the question how to deal with syntax errors etc.",
+ );
+}
+
+#[test]
+fn detect_arise_the_question() {
+ assert_suggestion_result(
+ "As e.g. UTC+1, might arise the question whether it includes summer and winter time",
+ test_linter(),
+ "As e.g. UTC+1, might raise the question whether it includes summer and winter time",
+ );
+}
+
+// -raises the question-
+#[test]
+fn detect_rises_the_question() {
+ assert_suggestion_result(
+ "However, this rises the question as to whether this test is conceptually sound.",
+ test_linter(),
+ "However, this raises the question as to whether this test is conceptually sound.",
+ );
+}
+
+#[test]
+fn detect_arises_the_question() {
+ assert_suggestion_result(
+ "And it arises the question, why?",
+ test_linter(),
+ "And it raises the question, why?",
+ );
+}
+
+// -raising the question-
+#[test]
+fn detect_rising_the_question() {
+ assert_suggestion_result(
+ "as soon as a infoHash query is performed, a Torrent file is retried, rising the question of:",
+ test_linter(),
+ "as soon as a infoHash query is performed, a Torrent file is retried, raising the question of:",
+ );
+}
+
+#[test]
+fn detect_arising_the_question() {
+ assert_suggestion_result(
+ "arising the question whether the requirement of wgpu::Features::DEPTH24PLUS_STENCIL8 is precise",
+ test_linter(),
+ "raising the question whether the requirement of wgpu::Features::DEPTH24PLUS_STENCIL8 is precise",
+ );
+}
+
+// -raised the question-
+#[test]
+fn detect_rose_the_question() {
+ assert_suggestion_result(
+ "Here is an example that rose the question at first: What works.",
+ test_linter(),
+ "Here is an example that raised the question at first: What works.",
+ );
+}
+
+#[test]
+fn detect_risen_the_question() {
+ assert_suggestion_result(
+ "That has risen the question in my mind if it is still possible to embed your own Flash player on Facebook today?",
+ test_linter(),
+ "That has raised the question in my mind if it is still possible to embed your own Flash player on Facebook today?",
+ );
+}
+
+#[test]
+fn detect_rised_the_question() {
+ assert_suggestion_result(
+ "I rised the question to Emax Support and they just came back to me inmediately with the below response.",
+ test_linter(),
+ "I raised the question to Emax Support and they just came back to me inmediately with the below response.",
+ );
+}
+
+#[test]
+#[ignore = "Not actually an error after when it's 'there arose'"]
+fn dont_fag_there_arose_the_question() {
+ assert_suggestion_result(
+ "Hello, while I have been using modals manager there arose the question related to customizing of modal header.",
+ test_linter(),
+ "Hello, while I have been using modals manager there arose the question related to customizing of modal header.",
+ );
+}
+
+#[test]
+fn detect_arised_the_question() {
+ assert_suggestion_result(
+ "and that fact arised the question in my mind, what does exactly is happening",
+ test_linter(),
+ "and that fact raised the question in my mind, what does exactly is happening",
+ );
+}
+
+#[test]
+fn detect_arose_the_question() {
+ assert_suggestion_result(
+ "This arose the question, could I store 32 digits on the stack?",
+ test_linter(),
+ "This raised the question, could I store 32 digits on the stack?",
+ );
+}
+
+#[test]
+fn detect_arisen_the_question() {
+ assert_suggestion_result(
+ "Some have arisen the question like how to use this wireless HD mini camera",
+ test_linter(),
+ "Some have raised the question like how to use this wireless HD mini camera",
+ );
+}
+
+// SideTangent
+
+#[test]
+fn fix_side_tangent_start_of_sentence() {
+ assert_suggestion_result(
+ "Side tangent: I personally wouldn't worry about using ; for removing the selection unless you need to.",
+ test_linter(),
+ "Tangent: I personally wouldn't worry about using ; for removing the selection unless you need to.",
+ );
+}
+
+#[test]
+fn fix_side_tangent_aside() {
+ assert_suggestion_result(
+ "As a side tangent, in addition to not solving the gradual code repair problem",
+ test_linter(),
+ "As an aside, in addition to not solving the gradual code repair problem",
+ );
+}
+
+#[test]
+fn fix_side_tangents() {
+ assert_suggestion_result(
+ "so we don't get bogged down by tiny formatting bikeshedding side tangents",
+ test_linter(),
+ "so we don't get bogged down by tiny formatting bikeshedding tangents",
+ );
+}
+
+// ToToo
+
+// -a bridge too far-
+#[test]
+fn fix_a_bridge_too_far() {
+ assert_suggestion_result(
+ "If Winforms can ever be conquered by the Mono developers may be a bridge to far.",
+ test_linter(),
+ "If Winforms can ever be conquered by the Mono developers may be a bridge too far.",
+ );
+}
+
+// -cake and eat it too-
+#[test]
+fn fix_cake_and_eat_it_too() {
+ assert_suggestion_result(
+ "The solution: wouldn't it be great if I could have my cake and eat it to?",
+ test_linter(),
+ "The solution: wouldn't it be great if I could have my cake and eat it too?",
+ );
+}
+
+// -go to far-
+#[test]
+fn fix_go_to_far() {
+ assert_suggestion_result(
+ "It's difficult to be sure when we go to far sometime when you don't exactly how the beast works in the background .",
+ test_linter(),
+ "It's difficult to be sure when we go too far sometime when you don't exactly how the beast works in the background .",
+ );
+}
+
+// -goes to far-
+#[test]
+fn fix_goes_to_far() {
+ assert_suggestion_result(
+ "Memory consumption and cpu consumption goes to far like 900% and more than this",
+ test_linter(),
+ "Memory consumption and cpu consumption goes too far like 900% and more than this",
+ );
+}
+
+// -going to far-
+#[test]
+fn fix_going_to_far() {
+ assert_suggestion_result(
+ "wsrun is going to far on this because debug 's devDependency shouldn't be considered in the cycle detection, should it?",
+ test_linter(),
+ "wsrun is going too far on this because debug 's devDependency shouldn't be considered in the cycle detection, should it?",
+ );
+}
+
+// -gone to far-
+#[test]
+fn fix_gone_to_far() {
+ assert_suggestion_result(
+ "I might have gone to far with opening issues for small things.",
+ test_linter(),
+ "I might have gone too far with opening issues for small things.",
+ );
+}
+
+// -went to far-
+#[test]
+fn fix_went_to_far() {
+ assert_suggestion_result(
+ "But I went to far compared to the initial request that seems talk about ...",
+ test_linter(),
+ "But I went too far compared to the initial request that seems talk about ...",
+ );
+}
+
+// -life's too short-
+#[test]
+fn fix_life_s_too_short() {
+ assert_suggestion_result(
+ "Life's to short for messing around with git add , writing commit message.",
+ test_linter(),
+ "Life's too short for messing around with git add , writing commit message.",
+ );
+}
+
+#[test]
+fn fix_lifes_to_short() {
+ assert_suggestion_result(
+ "I wouldn't go back after the 3rd interview lifes to short.",
+ test_linter(),
+ "I wouldn't go back after the 3rd interview life's too short.",
+ );
+}
+
+// -life is too short-
+#[test]
+fn fix_life_is_too_short() {
+ assert_suggestion_result(
+ "[Life is to short to use dated cli tools that suck]",
+ test_linter(),
+ "[Life is too short to use dated cli tools that suck]",
+ );
+}
+
+// -put too fine a point-
+#[test]
+fn fix_put_too_fine_a_point() {
+ assert_suggestion_result(
+ "Not to put to fine a point on it... that's not the kind of team I think we want to be.",
+ test_linter(),
+ "Not to put too fine a point on it... that's not the kind of team I think we want to be.",
+ );
+}
+
+// -speak too soon-
+#[test]
+fn fix_speak_too_soon() {
+ assert_suggestion_result(
+ "I don't want to speak to soon but I kept everything as I had before but included: http = httplib2.Http()",
+ test_linter(),
+ "I don't want to speak too soon but I kept everything as I had before but included: http = httplib2.Http()",
+ );
+}
+
+// -speaking too soon-
+#[test]
+fn fix_speaking_too_soon() {
+ assert_suggestion_result(
+ "EDIT: Thats what I get for speaking to soon...",
+ test_linter(),
+ "EDIT: Thats what I get for speaking too soon...",
+ );
+}
+
+// -spoke too soon-
+#[test]
+fn fix_spoke_too_soon() {
+ assert_suggestion_result(
+ "I spoke to soon. Ignore the previous post.",
+ test_linter(),
+ "I spoke too soon. Ignore the previous post.",
+ );
+}
+
+// -spoken too soon-
+#[test]
+fn fix_spoken_too_soon() {
+ assert_suggestion_result(
+ "EDIT: I might have spoken to soon...",
+ test_linter(),
+ "EDIT: I might have spoken too soon...",
+ );
+}
+
+// -think to much-
+#[test]
+fn fix_think_too_much() {
+ assert_suggestion_result(
+ "I don't think to much about it, but I don't think it's a big deal.",
+ test_linter(),
+ "I don't think too much about it, but I don't think it's a big deal.",
+ );
+}
+
+// -too big for-
+#[test]
+fn fix_too_big_for() {
+ assert_suggestion_result(
+ "ng-relations form to big for small screens",
+ test_linter(),
+ "ng-relations form too big for small screens",
+ );
+}
+
+// -too big to fail-
+#[test]
+fn fix_too_big_to_fail() {
+ assert_suggestion_result(
+ "The core alone has 50k LOC. Reminds me of \"to big to fail\".",
+ test_linter(),
+ "The core alone has 50k LOC. Reminds me of \"too big to fail\".",
+ );
+}
+
+// -too good to be true-
+#[test]
+fn fix_too_good_to_be_true() {
+ assert_suggestion_result(
+ "This seemed to good to be true, but local to scene resources will not work when they are not contained in a node.",
+ test_linter(),
+ "This seemed too good to be true, but local to scene resources will not work when they are not contained in a node.",
+ );
+}
+
+#[test]
+fn fix_too_good_too_be_true() {
+ assert_suggestion_result(
+ "The normalization of rewards is making the plot in tensorboard look too good too be true, because they are not the actual reward ...",
+ test_linter(),
+ "The normalization of rewards is making the plot in tensorboard look too good to be true, because they are not the actual reward ...",
+ );
+}
+
+// -too much information-
+#[test]
+fn fix_too_much_information() {
+ assert_suggestion_result(
+ "Live test are printing way to much information and is polluting our test output",
+ test_linter(),
+ "Live test are printing way too much information and is polluting our test output",
+ );
+}
+
+// TooTo
+
+// -too big too fail-
+#[test]
+fn fix_too_big_too_fail() {
+ assert_suggestion_result(
+ "In other words, pointer arithmetic is, at this point, too big too fail, regardless of the clever and sophisticated way C++ lawyercats worded it.",
+ test_linter(),
+ "In other words, pointer arithmetic is, at this point, too big to fail, regardless of the clever and sophisticated way C++ lawyercats worded it.",
+ );
+}
+
+// WholeEntire
+
+#[test]
+fn detect_atomic_whole_entire() {
+ assert_suggestion_result("whole entire", test_linter(), "whole");
+}
+
+#[test]
+fn correct_real_world_whole_entire() {
+ assert_suggestion_result(
+ "[FR] support use system dns in whole entire app",
+ test_linter(),
+ "[FR] support use system dns in whole app",
+ );
+}
+
+// -a whole entire-
+#[test]
+fn correct_atomic_a_whole_entire_to_a_whole() {
+ assert_suggestion_result("a whole entire", test_linter(), "a whole");
+}
+
+#[test]
+fn correct_atomic_a_whole_entire_to_an_entire() {
+ assert_suggestion_result("a whole entire", test_linter(), "an entire");
+}
+
+#[test]
+fn correct_real_world_a_whole_entire_to_a_whole() {
+ assert_suggestion_result(
+ "Start mapping a whole entire new planet using NASA’s MOLA.",
+ test_linter(),
+ "Start mapping a whole new planet using NASA’s MOLA.",
+ );
+}
+
+#[test]
+fn correct_real_world_a_whole_entire_to_an_entire() {
+ assert_suggestion_result(
+ "I am not sure I can pass in a whole entire query via the include.",
+ test_linter(),
+ "I am not sure I can pass in an entire query via the include.",
+ );
+}
+
+// WorseOrWorst
+
+// -a lot worst-
+#[test]
+fn detect_a_lot_worse_atomic() {
+ assert_suggestion_result("a lot worst", test_linter(), "a lot worse");
+}
+
+#[test]
+fn detect_a_lot_worse_real_world() {
+ assert_suggestion_result(
+ "On a debug build, it's even a lot worst.",
+ test_linter(),
+ "On a debug build, it's even a lot worse.",
+ );
+}
+
+// -become worst-
+#[test]
+fn fix_became_worst() {
+ assert_suggestion_result(
+ "The problem became worst lately.",
+ test_linter(),
+ "The problem became worse lately.",
+ );
+}
+
+#[test]
+fn fix_become_worst() {
+ assert_suggestion_result(
+ "But results seems stay at one place or become worst.",
+ test_linter(),
+ "But results seems stay at one place or become worse.",
+ );
+}
+
+#[test]
+fn fix_becomes_worst() {
+ assert_suggestion_result(
+ "This becomes worst if you have an x64 dll and an x86 dll that you don't have thier source codes and want to use them in same project!",
+ test_linter(),
+ "This becomes worse if you have an x64 dll and an x86 dll that you don't have thier source codes and want to use them in same project!",
+ );
+}
+
+#[test]
+fn fix_becoming_worst() {
+ assert_suggestion_result(
+ "France is becoming worst than the Five Eyes",
+ test_linter(),
+ "France is becoming worse than the Five Eyes",
+ );
+}
+
+// -far worse-
+#[test]
+fn detect_far_worse_atomic() {
+ assert_suggestion_result("far worst", test_linter(), "far worse");
+}
+
+#[test]
+fn detect_far_worse_real_world() {
+ assert_suggestion_result(
+ "I mainly use Firefox (personal preference) and have noticed it has far worst performance than Chrome",
+ test_linter(),
+ "I mainly use Firefox (personal preference) and have noticed it has far worse performance than Chrome",
+ );
+}
+
+// -get worst-
+#[test]
+fn fix_get_worse() {
+ assert_suggestion_result(
+ "and the problem appears to get worst with 2025.5.1 and 2025.5.2.",
+ test_linter(),
+ "and the problem appears to get worse with 2025.5.1 and 2025.5.2.",
+ );
+}
+
+#[test]
+fn fix_gets_worse() {
+ assert_suggestion_result(
+ "It just starts after about 15 minutes of work and gradually gets worst.",
+ test_linter(),
+ "It just starts after about 15 minutes of work and gradually gets worse.",
+ );
+}
+
+#[test]
+#[ignore = "This kind of false positive is probably too subtle to detect"]
+fn dont_flag_getting_worst() {
+ // Here "getting" probably belongs to "I am getting" rather than "getting worst".
+ // Which would not be an error but "I am getting the worst accuracy" would be better.
+ // TODO: Maybe a noun following "getting" is enough context?
+ assert_lint_count(
+ "I am getting worst accuracy on the same dataste and 3 different models.",
+ test_linter(),
+ 0,
+ );
+}
+
+#[test]
+fn fix_getting_worst() {
+ assert_suggestion_result(
+ "But, as I said, it is getting worst...",
+ test_linter(),
+ "But, as I said, it is getting worse...",
+ );
+}
+
+#[test]
+fn fix_got_worst() {
+ assert_suggestion_result(
+ "typescript support got worst.",
+ test_linter(),
+ "typescript support got worse.",
+ );
+}
+
+#[test]
+fn fix_gotten_worst() {
+ assert_suggestion_result(
+ "Has Claude gotten worst?",
+ test_linter(),
+ "Has Claude gotten worse?",
+ );
+}
+
+// -much worse-
+#[test]
+fn detect_much_worse_atomic() {
+ assert_suggestion_result("much worst", test_linter(), "much worse");
+}
+
+#[test]
+fn detect_much_worse_real_world() {
+ assert_suggestion_result(
+ "the generated image quality is much worst (actually nearly broken)",
+ test_linter(),
+ "the generated image quality is much worse (actually nearly broken)",
+ );
+}
+
+// -turn for the worse-
+#[test]
+fn detect_turn_for_the_worse_atomic() {
+ assert_suggestion_result("turn for the worst", test_linter(), "turn for the worse");
+}
+
+#[test]
+fn detect_turn_for_the_worse_real_world() {
+ assert_suggestion_result(
+ "Very surprised to see this repo take such a turn for the worst.",
+ test_linter(),
+ "Very surprised to see this repo take such a turn for the worse.",
+ );
+}
+
+// -worse than-
+#[test]
+fn detect_worse_than_atomic() {
+ assert_suggestion_result("worst than", test_linter(), "worse than");
+}
+
+#[test]
+fn detect_worse_than_real_world() {
+ assert_suggestion_result(
+ "Project real image - inversion quality is worst than in StyleGAN2",
+ test_linter(),
+ "Project real image - inversion quality is worse than in StyleGAN2",
+ );
+}
+
+// -worst ever-
+#[test]
+fn detect_worst_ever_atomic() {
+ assert_suggestion_result("worse ever", test_linter(), "worst ever");
+}
+
+#[test]
+fn detect_worst_ever_real_world() {
+ assert_suggestion_result(
+ "The Bcl package family is one of the worse ever published by Microsoft.",
+ test_linter(),
+ "The Bcl package family is one of the worst ever published by Microsoft.",
+ );
+}
+
+// -worse and worse-
+#[test]
+fn detect_worst_and_worst_atomic() {
+ assert_suggestion_result("worst and worst", test_linter(), "worse and worse");
+}
+
+#[test]
+fn detect_worst_and_worst_real_world() {
+ assert_suggestion_result(
+ "This control-L trick does not work for me. The padding is getting worst and worst.",
+ test_linter(),
+ "This control-L trick does not work for me. The padding is getting worse and worse.",
+ );
+}
+
+#[test]
+fn detect_worse_and_worst_real_world() {
+ assert_suggestion_result(
+ "This progressively got worse and worst to the point that the machine (LEAD 1010) stopped moving alltogether.",
+ test_linter(),
+ "This progressively got worse and worse to the point that the machine (LEAD 1010) stopped moving alltogether.",
+ );
+}
+
+// -at worst-
+#[test]
+fn detect_at_worst_atomic() {
+ assert_suggestion_result(
+ "Partial moving of core objects to interpreter state is incorrect at best, unsafe at worse.",
+ test_linter(),
+ "Partial moving of core objects to interpreter state is incorrect at best, unsafe at worst.",
+ );
+}
+
+// -worst case scenario-
+#[test]
+fn correct_worse_case_space() {
+ assert_suggestion_result(
+ "In the worse case scenario, remote code execution could be achieved.",
+ test_linter(),
+ "In the worst-case scenario, remote code execution could be achieved.",
+ );
+}
+
+#[test]
+fn correct_worse_case_hyphen() {
+ assert_suggestion_result(
+ "Basically I want my pods to get the original client IP address... or at least have X-Forwarded-For header, in a worse-case scenario.",
+ test_linter(),
+ "Basically I want my pods to get the original client IP address... or at least have X-Forwarded-For header, in a worst-case scenario.",
+ );
+}
+
+#[test]
+fn correct_worse_case_two_hyphens() {
+ assert_suggestion_result(
+ "In a worse-case-scenario, the scenario class code and the results being analysed, become out of sync, and so the wrong labels are applied.",
+ test_linter(),
+ "In a worst-case scenario, the scenario class code and the results being analysed, become out of sync, and so the wrong labels are applied.",
+ );
+}
+
+// -make it worst-
+#[test]
+fn detect_make_it_worst_atomic() {
+ assert_suggestion_result(
+ "And if you try to access before that, CloudFront will cache the error and it'll make it worst.",
+ test_linter(),
+ "And if you try to access before that, CloudFront will cache the error and it'll make it worse.",
+ );
+}
+
+// -made it worst-
+#[test]
+fn detect_made_it_worst_atomic() {
+ assert_suggestion_result(
+ "However in couple of occasions the refresh made it worst and it showed commit differences that were already commited and pushed to origin.",
+ test_linter(),
+ "However in couple of occasions the refresh made it worse and it showed commit differences that were already commited and pushed to origin.",
+ );
+}
+
+// -makes it worst-
+#[test]
+fn detect_makes_it_worst_atomic() {
+ assert_suggestion_result(
+ "What makes it worst, is if I use the returned SHA to try and update the newly created file I get the same error I show below.",
+ test_linter(),
+ "What makes it worse, is if I use the returned SHA to try and update the newly created file I get the same error I show below.",
+ );
+}
+
+// -making it worst-
+#[test]
+fn detect_making_it_worst_atomic() {
+ assert_suggestion_result(
+ "PLease ai realled need help with this I think I'm making it worst.",
+ test_linter(),
+ "PLease ai realled need help with this I think I'm making it worse.",
+ );
+}
+
+// -make them worst-
+#[test]
+fn detect_make_them_worst_atomic() {
+ assert_suggestion_result(
+ "Not sure if this makes things clearer or make them worst.",
+ test_linter(),
+ "Not sure if this makes things clearer or make them worse.",
+ );
+}
+
+// -made them worst-
+#[test]
+fn detect_made_them_worst_atomic() {
+ assert_suggestion_result(
+ "if not outroght caused them / made them worst",
+ test_linter(),
+ "if not outroght caused them / made them worse",
+ );
+}
+
+// -makes them worst-
+#[test]
+fn detect_makes_them_worst_atomic() {
+ assert_suggestion_result(
+ "(tried ~14 different hyperparameter and data format combos), however, always just makes them worst, they go from \"slightly\" wrong to \"complete nonsense\".",
+ test_linter(),
+ "(tried ~14 different hyperparameter and data format combos), however, always just makes them worse, they go from \"slightly\" wrong to \"complete nonsense\".",
+ );
+}
+
+#[test]
+#[ignore = "This false positive is not handled yet"]
+fn dont_flag_makes_them_worst_case() {
+ assert_lint_count(
+ "Note 1: all hash tables has an Achilles heel that makes them worst case O(N)",
+ test_linter(),
+ 0,
+ );
+}
+
+// -making them worst-
+#[test]
+fn detect_making_them_worst_atomic() {
+ assert_suggestion_result(
+ "As for the last part about Apple deliberately making them worst in order for us to buy the 3s",
+ test_linter(),
+ "As for the last part about Apple deliberately making them worse in order for us to buy the 3s",
+ );
+}
diff --git a/harper-core/src/linting/phrase_set_corrections/mod.rs b/harper-core/src/linting/phrase_set_corrections/mod.rs
index 486b149a5..4079275af 100644
--- a/harper-core/src/linting/phrase_set_corrections/mod.rs
+++ b/harper-core/src/linting/phrase_set_corrections/mod.rs
@@ -3,7 +3,9 @@ use crate::linting::LintKind;
use super::{LintGroup, MapPhraseSetLinter};
#[cfg(test)]
-mod tests;
+mod many_to_many_tests;
+#[cfg(test)]
+mod one_to_one_tests;
/// Produce a [`LintGroup`] that looks for errors in sets of common phrases.
pub fn lint_group() -> LintGroup {
@@ -998,6 +1000,20 @@ pub fn lint_group() -> LintGroup {
"Corrects `payed` to `paid` and `overpayed` to `overpaid`.",
LintKind::Spelling
),
+ "PlayAFactor" => (
+ &[
+ // singular
+ (&["play a factor"], &["play a part", "play a role", "be a factor", "are a factor", "am a factor"]),
+ (&["plays a factor"], &["plays a part", "plays a role", "is a factor"]),
+ (&["played a factor"], &["played a part", "played a role", "was a factor", "were a factor", "were factors", "been a factor"]),
+ (&["playing a factor"], &["playing a part", "playing a role", "a factor","being a factor"]),
+ // plural - NOTE some lead to more false positives than true errors
+ (&["played factors"], &["played parts", "played roles", "played a part", "played a role", "were a factor", "were factors"]),
+ ],
+ "Use `play a part` or `be a factor` instead of `play a factor`.",
+ "Corrects `play a factor` to `play a part` or `be a factor`.",
+ LintKind::Usage
+ ),
"RiseTheQuestion" => (
&[
(&["rise the question", "arise the question"], &["raise the question"]),
diff --git a/harper-core/src/linting/phrase_set_corrections/tests.rs b/harper-core/src/linting/phrase_set_corrections/one_to_one_tests.rs
similarity index 56%
rename from harper-core/src/linting/phrase_set_corrections/tests.rs
rename to harper-core/src/linting/phrase_set_corrections/one_to_one_tests.rs
index 44c10ef06..d29ee4c25 100644
--- a/harper-core/src/linting/phrase_set_corrections/tests.rs
+++ b/harper-core/src/linting/phrase_set_corrections/one_to_one_tests.rs
@@ -1,8 +1,6 @@
use super::LintGroup;
use crate::linting::pooled_linter::for_tests::create_test_pool;
-use crate::linting::tests::{
- assert_good_and_bad_suggestions, assert_lint_count, assert_no_lints, assert_suggestion_result,
-};
+use crate::linting::tests::{assert_lint_count, assert_no_lints, assert_suggestion_result};
use super::lint_group;
@@ -17,8 +15,6 @@ fn single_lint(rule_name: &str) -> crate::linting::LintGroup {
group
}
-// 1:1 tests
-
// Ado
#[test]
@@ -2426,1787 +2422,3 @@ fn fix_wrote_memorizing() {
"I have never been good at rote memorizing abbreviations, initialisms, or acronyms.",
);
}
-
-// Many to many tests
-
-// AwaitFor
-
-#[test]
-fn correct_awaits_for() {
- assert_good_and_bad_suggestions(
- "Headless mode awaits for requested user feedback without showing any text for what that feedback should be",
- test_linter(),
- &[
- "Headless mode awaits requested user feedback without showing any text for what that feedback should be",
- "Headless mode waits for requested user feedback without showing any text for what that feedback should be",
- ],
- &[],
- );
-}
-
-#[test]
-fn correct_awaiting_for() {
- assert_good_and_bad_suggestions(
- "gpg import fails awaiting for prompt answer",
- test_linter(),
- &[
- "gpg import fails waiting for prompt answer",
- "gpg import fails awaiting prompt answer",
- ],
- &[],
- );
-}
-
-#[test]
-fn correct_await_for() {
- assert_good_and_bad_suggestions(
- "I still await for a college course on \"Followership 101\"",
- test_linter(),
- &[
- "I still wait for a college course on \"Followership 101\"",
- "I still await a college course on \"Followership 101\"",
- ],
- &[],
- );
-}
-
-#[test]
-fn correct_awaited_for() {
- assert_good_and_bad_suggestions(
- "I have long awaited for the rise of the Dagoat agenda, and it is glorious.",
- test_linter(),
- &[
- "I have long awaited the rise of the Dagoat agenda, and it is glorious.",
- "I have long waited for the rise of the Dagoat agenda, and it is glorious.",
- ],
- &[],
- );
-}
-
-// BackhandedCompliment
-
-#[test]
-fn correct_backhand_compliment() {
- assert_suggestion_result(
- "What's the Most insulting /backhand compliment you have ever received?",
- test_linter(),
- "What's the Most insulting /backhanded compliment you have ever received?",
- );
-}
-
-#[test]
-fn correct_back_hand_compliment_space() {
- assert_suggestion_result(
- "Thankfully, I'm a little young to receive that back hand compliment",
- test_linter(),
- "Thankfully, I'm a little young to receive that backhanded compliment",
- );
-}
-
-#[test]
-fn correct_back_hand_compliment_hyphen() {
- assert_suggestion_result(
- "They \"have it all\", but still need to back-hand compliment, condescend, \"politely\" hurl passive-aggressive compliments/insults",
- test_linter(),
- "They \"have it all\", but still need to backhanded compliment, condescend, \"politely\" hurl passive-aggressive compliments/insults",
- );
-}
-
-#[test]
-fn correct_backhand_compliments() {
- assert_suggestion_result(
- "If backhand compliments or flattery are frequent and come with ulterior motives, it's a red flag.",
- test_linter(),
- "If backhanded compliments or flattery are frequent and come with ulterior motives, it's a red flag.",
- );
-}
-
-#[test]
-fn correct_back_hand_compliments() {
- assert_suggestion_result(
- "I am laughing so hard watching the \"commercial\" with her back hand compliments.",
- test_linter(),
- "I am laughing so hard watching the \"commercial\" with her backhanded compliments.",
- );
-}
-
-#[test]
-fn correct_back_hand_compliments_caps() {
- assert_suggestion_result(
- "JUST SAY YOU DON'T LIKE THEM STOP GIVING FAKE BACK HAND COMPLIMENTS.",
- test_linter(),
- "JUST SAY YOU DON'T LIKE THEM STOP GIVING FAKE BACKHANDED COMPLIMENTS.",
- );
-}
-
-// no praises, just tons of unnecessary back-hand compliments and lack of support
-#[test]
-fn correct_back_hand_compliments_hyphen() {
- assert_suggestion_result(
- "no praises, just tons of unnecessary back-hand compliments and lack of support",
- test_linter(),
- "no praises, just tons of unnecessary backhanded compliments and lack of support",
- );
-}
-
-// CommitmentTo
-
-#[test]
-fn singular_towards() {
- assert_suggestion_result(
- "the platform's focus on multimedia projects and VideoLAN's long history of commitment towards free and open multimedia",
- test_linter(),
- "the platform's focus on multimedia projects and VideoLAN's long history of commitment to free and open multimedia",
- );
-}
-
-#[test]
-fn plural_towards() {
- assert_suggestion_result(
- "the signer may express multiple commitments towards the data objects",
- test_linter(),
- "the signer may express multiple commitments to the data objects",
- );
-}
-
-#[test]
-fn singular_toward() {
- assert_suggestion_result(
- "This document outlines the current level of commitment toward Linux distributions and packaging formats.",
- test_linter(),
- "This document outlines the current level of commitment to Linux distributions and packaging formats.",
- );
-}
-
-#[test]
-fn plural_toward() {
- assert_suggestion_result(
- "... and are expected to inform parties in updating their commitments toward the Paris Agreement",
- test_linter(),
- "... and are expected to inform parties in updating their commitments to the Paris Agreement",
- );
-}
-
-// Copyright
-
-#[test]
-fn copywritten() {
- assert_suggestion_result(
- "Including digital copies of copywritten artwork with the project isn't advised.",
- test_linter(),
- "Including digital copies of copyrighted artwork with the project isn't advised.",
- );
-}
-
-#[test]
-fn copywrites() {
- assert_suggestion_result(
- "Code is 99% copy/pasted from OpenSSH with an attempt to retain all copywrites",
- test_linter(),
- "Code is 99% copy/pasted from OpenSSH with an attempt to retain all copyrights",
- );
-}
-
-#[test]
-fn copywrited() {
- assert_suggestion_result(
- "Proprietary copywrited code",
- test_linter(),
- "Proprietary copyrighted code",
- );
-}
-
-#[test]
-fn copywrited_all_caps() {
- assert_suggestion_result(
- "URLS MAY CONTAIN COPYWRITED MATERIAL",
- test_linter(),
- "URLS MAY CONTAIN COPYRIGHTED MATERIAL",
- );
-}
-
-#[test]
-fn copywrote() {
- assert_suggestion_result(
- "How do you find out if someone copywrote a movie",
- test_linter(),
- "How do you find out if someone copyrighted a movie",
- );
-}
-
-// DateBackFrom
-
-#[test]
-fn corrects_date_back_from() {
- assert_good_and_bad_suggestions(
- "There are too many open issues that date back from 4 years ago.",
- test_linter(),
- &[
- "There are too many open issues that date from 4 years ago.",
- "There are too many open issues that date back to 4 years ago.",
- ],
- &[],
- );
-}
-
-#[test]
-fn corrects_dates_back_from() {
- assert_good_and_bad_suggestions(
- "This code dates back from 2014.",
- test_linter(),
- &[
- "This code dates from 2014.",
- "This code dates back to 2014.",
- ],
- &[],
- );
-}
-
-#[test]
-fn allows_date_back_to() {
- assert_no_lints(
- "These scripts date back to when Perl was popular.",
- test_linter(),
- );
-}
-
-// Note: "the date back from" and "get dates back from" are known false
-// positives where "date" is a noun (retrieving data). Phrase set matching
-// cannot distinguish these from the verb form. See issue #2864.
-
-// DoubleEdgedSword
-
-#[test]
-fn correct_double_edge_hyphen() {
- assert_suggestion_result(
- "I thought the global defaultTranslationValues was potentially a double-edge sword as it also obfuscates the full set of values",
- test_linter(),
- "I thought the global defaultTranslationValues was potentially a double-edged sword as it also obfuscates the full set of values",
- );
-}
-
-#[test]
-fn correct_double_edge_space() {
- assert_suggestion_result(
- "It becomes a double edge sword when it should not be used in cases like this.",
- test_linter(),
- "It becomes a double-edged sword when it should not be used in cases like this.",
- );
-}
-
-#[test]
-fn correct_double_edge_space_plural() {
- assert_suggestion_result(
- "Wake locks are really double edge swords.",
- test_linter(),
- "Wake locks are really double-edged swords.",
- );
-}
-
-#[test]
-fn correct_double_edged_space() {
- assert_suggestion_result(
- "Use case. currently OPTIMIZE is a double edged sword and potentially a very dangerous tool to use.",
- test_linter(),
- "Use case. currently OPTIMIZE is a double-edged sword and potentially a very dangerous tool to use.",
- );
-}
-
-#[test]
-fn correct_double_edged_space_plural() {
- assert_suggestion_result(
- "Change: Ambushers and Crusaders now protect their targets too, making them double edged swords",
- test_linter(),
- "Change: Ambushers and Crusaders now protect their targets too, making them double-edged swords",
- );
-}
-
-// ExpandAlloc
-
-#[test]
-fn corrects_allocs() {
- assert_suggestion_result(
- "cmd/compile: avoid allocs by better tracking of literals for interface conversions and make",
- test_linter(),
- "cmd/compile: avoid allocations by better tracking of literals for interface conversions and make",
- );
-}
-
-#[test]
-fn expand_alloc() {
- assert_suggestion_result(
- "Used to find system libraries that alloc RWX regions on load.",
- test_linter(),
- "Used to find system libraries that allocate RWX regions on load.",
- );
-}
-
-// ExpandGovt
-
-#[test]
-fn corrects_govt_no_dot() {
- assert_suggestion_result(
- "Separation between privately issued credentials vs govt issued identity credentials",
- test_linter(),
- "Separation between privately issued credentials vs government issued identity credentials",
- );
-}
-
-#[test]
-fn corrects_govt_do() {
- assert_suggestion_result(
- "Demystifying public comments on govt. regulations.",
- test_linter(),
- "Demystifying public comments on government regulations.",
- );
-}
-
-#[test]
-fn corrects_govts() {
- assert_suggestion_result(
- "Those 'elite' economists have been advising govts for years.",
- test_linter(),
- "Those 'elite' economists have been advising governments for years.",
- );
-}
-
-// Expat
-
-#[test]
-fn correct_ex_pat_hyphen() {
- assert_suggestion_result(
- "It seems ex-pat means the person will be in a foreign country temporarily",
- test_linter(),
- "It seems expat means the person will be in a foreign country temporarily",
- );
-}
-
-#[test]
-fn correct_ex_pats_hyphen() {
- assert_suggestion_result(
- "So, it might be correct to call most Brits ex-pats.",
- test_linter(),
- "So, it might be correct to call most Brits expats.",
- );
-}
-
-#[test]
-fn correct_ex_pat_space() {
- assert_suggestion_result(
- "For me, the term ex pat embodies the exquisite hypocrisy of certain people feeling entitled",
- test_linter(),
- "For me, the term expat embodies the exquisite hypocrisy of certain people feeling entitled",
- );
-}
-
-#[test]
-#[ignore = "replace_with_match_case results in ExPats"]
-fn correct_ex_pats_space() {
- assert_suggestion_result(
- "Why are Brits who emigrate \"Ex Pats\" but people who come here \"immigrants\"?",
- test_linter(),
- "Why are Brits who emigrate \"Expats\" but people who come here \"immigrants\"?",
- );
-}
-
-// Expatriate
-
-#[test]
-fn correct_expatriot() {
- assert_suggestion_result(
- "Another expatriot of the era, James Joyce, also followed Papa's writing and drinking schedule.",
- test_linter(),
- "Another expatriate of the era, James Joyce, also followed Papa's writing and drinking schedule.",
- );
-}
-
-#[test]
-fn correct_expatriots() {
- assert_suggestion_result(
- "Expatriots, upon discovering the delightful nuances of Dutch pronunciation, often find themselves in stitches.",
- test_linter(),
- "Expatriates, upon discovering the delightful nuances of Dutch pronunciation, often find themselves in stitches.",
- );
-}
-
-#[test]
-fn correct_ex_patriot_hyphen() {
- assert_suggestion_result(
- "Then I added we should all be using the word 移民 immigrant, not ex-patriot, not 外国人 gaikokujin, and definitely not 外人 gaijin",
- test_linter(),
- "Then I added we should all be using the word 移民 immigrant, not expatriate, not 外国人 gaikokujin, and definitely not 外人 gaijin",
- );
-}
-
-#[test]
-fn correct_ex_patriots_hyphen() {
- assert_suggestion_result(
- "Ex-patriots who move to Hong Kong to seek greener pastures and to experience a new culture seem to bring their own cultural baggage with them.",
- test_linter(),
- "Expatriates who move to Hong Kong to seek greener pastures and to experience a new culture seem to bring their own cultural baggage with them.",
- );
-}
-
-// GetRidOf
-
-#[test]
-fn get_rid_off() {
- assert_suggestion_result(
- "Please bump axios version to get rid off npm warning #624",
- test_linter(),
- "Please bump axios version to get rid of npm warning #624",
- );
-}
-
-#[test]
-fn gets_rid_off() {
- assert_suggestion_result(
- "Adding at as a runtime dependency gets rid off that error",
- test_linter(),
- "Adding at as a runtime dependency gets rid of that error",
- );
-}
-
-#[test]
-fn getting_rid_off() {
- assert_suggestion_result(
- "getting rid off of all the complexity of the different accesses method of API service providers",
- test_linter(),
- "getting rid of of all the complexity of the different accesses method of API service providers",
- );
-}
-
-#[test]
-fn got_rid_off() {
- assert_suggestion_result(
- "For now we got rid off circular deps in model tree structure and it's API.",
- test_linter(),
- "For now we got rid of circular dependencies in model tree structure and it's API.",
- );
-}
-
-#[test]
-fn gotten_rid_off() {
- assert_suggestion_result(
- "The baX variable thingy I have gotten rid off, that was due to a bad character in the encryption key.",
- test_linter(),
- "The baX variable thingy I have gotten rid of, that was due to a bad character in the encryption key.",
- );
-}
-
-#[test]
-fn get_ride_of() {
- assert_suggestion_result(
- "Get ride of \"WARNING Deprecated: markdown_github. Use gfm\"",
- test_linter(),
- "Get rid of \"WARNING Deprecated: markdown_github. Use gfm\"",
- );
-}
-
-#[test]
-fn get_ride_off() {
- assert_suggestion_result(
- "This exact hack was what I trying to get ride off. ",
- test_linter(),
- "This exact hack was what I trying to get rid of. ",
- );
-}
-
-#[test]
-fn getting_ride_of() {
- assert_suggestion_result(
- "If you have any idea how to fix this without getting ride of bootstrap I would be thankfull.",
- test_linter(),
- "If you have any idea how to fix this without getting rid of bootstrap I would be thankfull.",
- );
-}
-
-#[test]
-fn gets_ride_of() {
- assert_suggestion_result(
- ".. gets ride of a central back-end/server and eliminates all the risks associated to it.",
- test_linter(),
- ".. gets rid of a central back-end/server and eliminates all the risks associated to it.",
- );
-}
-
-#[test]
-fn gotten_ride_of() {
- assert_suggestion_result(
- "I have gotten ride of the react-table and everything works just fine.",
- test_linter(),
- "I have gotten rid of the react-table and everything works just fine.",
- );
-}
-
-#[test]
-fn got_ride_of() {
- assert_suggestion_result(
- "I had to adjust the labels on the free version because you guys got ride of ...",
- test_linter(),
- "I had to adjust the labels on the free version because you guys got rid of ...",
- );
-}
-
-// HolyWar
-
-#[test]
-#[ignore = "Known failure due to replace_with_match_case working by character index"]
-fn correct_holy_war() {
- assert_suggestion_result(
- "I know it is Holly War about idempotent in HTTP and DELETE",
- test_linter(),
- "I know it is Holy War about idempotent in HTTP and DELETE",
- );
-}
-
-#[test]
-fn correct_holly_wars() {
- assert_suggestion_result(
- "Anyway I'm not starting some holly wars about this point.",
- test_linter(),
- "Anyway I'm not starting some holy wars about this point.",
- );
-}
-
-// HowItLooksLike
-
-#[test]
-fn correct_how_it_looks_like_1() {
- assert_suggestion_result(
- "And here is how it looks like: As you can see, there is no real difference in the diagram itself.",
- test_linter(),
- "And here is how it looks: As you can see, there is no real difference in the diagram itself.",
- );
-}
-
-#[test]
-fn correct_how_it_looks_like_2() {
- assert_suggestion_result(
- "This is how it looks like when run from Windows PowerShell or Cmd: image.",
- test_linter(),
- "This is what it looks like when run from Windows PowerShell or Cmd: image.",
- );
-}
-
-#[test]
-fn correct_how_they_look_like_1() {
- assert_suggestion_result(
- "This is a sample project illustrating a demo of how to use the new Material 3 components and how they look like.",
- test_linter(),
- "This is a sample project illustrating a demo of how to use the new Material 3 components and how they look.",
- );
-}
-
-#[test]
-fn correct_how_they_look_like_2() {
- assert_suggestion_result(
- "So for now I'll just leave this issue here of how they look like in the XLSX",
- test_linter(),
- "So for now I'll just leave this issue here of what they look like in the XLSX",
- );
-}
-
-#[test]
-fn correct_how_they_looks_like_1() {
- assert_suggestion_result(
- "Here I demonstrate how disney works and how they looks like Don't miss to give me a star.",
- test_linter(),
- "Here I demonstrate how disney works and how they look Don't miss to give me a star.",
- );
-}
-
-#[test]
-fn correct_how_they_looks_like_2() {
- assert_suggestion_result(
- "You can check how they looks like on Android app by this command:",
- test_linter(),
- "You can check what they look like on Android app by this command:",
- );
-}
-
-#[test]
-fn correct_how_she_looks_like_1() {
- assert_suggestion_result(
- "You all know how she looks like.",
- test_linter(),
- "You all know how she looks.",
- );
-}
-
-#[test]
-fn correct_how_he_looks_like_2() {
- assert_suggestion_result(
- "Here's how he looks like, when he's supposed to just look like his old fatui design.",
- test_linter(),
- "Here's what he looks like, when he's supposed to just look like his old fatui design.",
- );
-}
-
-#[test]
-fn correct_how_it_look_like_1() {
- assert_suggestion_result(
- "And I don't mind how it look like, language code subpath or the last subpath as below.",
- test_linter(),
- "And I don't mind how it looks, language code subpath or the last subpath as below.",
- );
-}
-
-#[test]
-fn correct_how_it_look_like_2() {
- assert_suggestion_result(
- "Here is how it look like in your browser:",
- test_linter(),
- "Here is what it looks like in your browser:",
- );
-}
-
-#[test]
-fn correct_how_it_looks_like_with_apostrophe() {
- assert_suggestion_result(
- "In the picture we can see how It look's like on worker desktop.",
- test_linter(),
- "In the picture we can see how It looks on worker desktop.",
- );
-}
-
-// InRetaliationTo
-
-#[test]
-fn corrects_in_retaliation_to_to_for() {
- assert_suggestion_result(
- "Damage caused in retaliation to another attack by the Thorns enchantment.",
- test_linter(),
- "Damage caused in retaliation for another attack by the Thorns enchantment.",
- );
-}
-
-#[test]
-fn corrects_in_retaliation_to_to_in_response_to() {
- assert_suggestion_result(
- "In retaliation to disagreeing with legal naming issues, a crucial (albeit rather small) section of code was removed from the NPM database",
- test_linter(),
- "In response to disagreeing with legal naming issues, a crucial (albeit rather small) section of code was removed from the NPM database",
- );
-}
-
-// LevelOfDetails
-
-#[test]
-fn corrects_level_of_details_singular_contrived() {
- assert_suggestion_result(
- "The model has a high level of details.",
- test_linter(),
- "The model has a high level of detail.",
- );
-}
-
-fn corrects_levels_of_details_plural_contrived() {
- assert_suggestion_result(
- "The game uses several level of details to save memory.",
- test_linter(),
- "The game uses several levels of detail to save memory.",
- );
-}
-
-#[test]
-fn corrects_level_of_details_singular_real_world() {
- assert_suggestion_result(
- "How to implement a level of details visualizer for 3D meshes?",
- test_linter(),
- "How to implement a level of detail visualizer for 3D meshes?",
- );
-}
-
-#[test]
-fn corrects_level_of_details_plural_real_world() {
- assert_suggestion_result(
- "LOD's (Level of details) are a set of lower models used for the purpose of optimisation",
- test_linter(),
- "LOD's (Levels of detail) are a set of lower models used for the purpose of optimisation",
- );
-}
-
-#[test]
-fn corrects_levels_of_details_real_world() {
- assert_suggestion_result(
- "The file completion uses two levels of details to optimize performance.",
- test_linter(),
- "The file completion uses two levels of detail to optimize performance.",
- );
-}
-
-// Lookalike
-
-#[test]
-fn corrects_look_a_like() {
- assert_good_and_bad_suggestions(
- "Define the look-a-like of the cursor/mouse pointer:",
- test_linter(),
- &[
- "Define the lookalike of the cursor/mouse pointer:",
- "Define the look-alike of the cursor/mouse pointer:",
- ],
- &[],
- );
-}
-
-#[test]
-fn corrects_look_a_likes() {
- assert_good_and_bad_suggestions(
- "Attempt at using AWS facial recognition to find look-a-likes in the Rijksmuseum's art collection.",
- test_linter(),
- &[
- "Attempt at using AWS facial recognition to find lookalikes in the Rijksmuseum's art collection.",
- "Attempt at using AWS facial recognition to find look-alikes in the Rijksmuseum's art collection.",
- ],
- &[],
- );
-}
-
-// MakeItSeem
-
-#[test]
-fn corrects_make_it_seems() {
- assert_suggestion_result(
- "but put it into unlisted list may make it seems like listed for GitHub",
- test_linter(),
- "but put it into unlisted list may make it seem like listed for GitHub",
- );
-}
-
-#[test]
-fn corrects_made_it_seems() {
- assert_suggestion_result(
- "previous explanations made it seems like it would be n",
- test_linter(),
- "previous explanations made it seem like it would be n",
- );
-}
-
-#[test]
-fn corrects_makes_it_seems() {
- assert_suggestion_result(
- "bundle gives an error that makes it seems like esbuild is trying to use lib/index.js from main",
- test_linter(),
- "bundle gives an error that makes it seem like esbuild is trying to use lib/index.js from main",
- );
-}
-
-#[test]
-fn corrects_making_it_seems() {
- assert_suggestion_result(
- "Is it possible to teach the concept of assignment/reassignment at the very beginner stage instead of making it seems like constants?",
- test_linter(),
- "Is it possible to teach the concept of assignment/reassignment at the very beginner stage instead of making it seem like constants?",
- );
-}
-
-#[test]
-fn corrects_made_it_seemed() {
- assert_suggestion_result(
- "The path made it seemed a bit \"internal\".",
- test_linter(),
- "The path made it seem a bit \"internal\".",
- );
-}
-
-// Monumentous
-
-#[test]
-fn corrects_monumentous() {
- assert_suggestion_result(
- "I think that would be a monumentous step in the right direction, and would DEFINATLY turn heads in not just the music industry, but every ...",
- test_linter(),
- "I think that would be a momentous step in the right direction, and would DEFINATLY turn heads in not just the music industry, but every ...",
- );
-}
-
-#[test]
-fn corrects_monumentously() {
- assert_suggestion_result(
- "the most impressive thing out of all of this is that GitHub created such a monumentously good name",
- test_linter(),
- "the most impressive thing out of all of this is that GitHub created such a monumentally good name",
- );
-}
-
-// NervousWreck
-
-#[test]
-#[ignore = "Harper matches case by letter index as 'How Not to Be a Complete NervoUs wreck in an Interview'"]
-fn correct_nerve_wreck_space_title_case() {
- assert_suggestion_result(
- "How Not to Be a Complete Nerve Wreck in an Interview",
- test_linter(),
- "How Not to Be a Complete Nervous Wreck in an Interview",
- );
-}
-
-#[test]
-fn correct_nerve_wreck_space() {
- assert_suggestion_result(
- "The nerve wreck you are makes you seem anxious and agitated so your employer will believe the complaints.",
- test_linter(),
- "The nervous wreck you are makes you seem anxious and agitated so your employer will believe the complaints.",
- );
-}
-
-#[test]
-fn correct_nerve_wreck_hyphen() {
- assert_suggestion_result(
- "the child receives little education and grows up to be a nerve-wreck",
- test_linter(),
- "the child receives little education and grows up to be a nervous wreck",
- );
-}
-
-#[test]
-fn correct_nerve_wreck_hyphen_plural() {
- assert_suggestion_result(
- "This helps us not to become nerve wrecks while looking at the side mirrors",
- test_linter(),
- "This helps us not to become nervous wrecks while looking at the side mirrors",
- );
-}
-
-#[test]
-#[ignore = "We can't detect when the altered form is used for an event rather than a person."]
-fn dont_correct_it_was_a_nerve_wreck() {
- assert_no_lints(
- "It was a nerve-wreck, but I was also excited to see what would happen next.",
- test_linter(),
- );
-}
-
-#[test]
-#[ignore = "We can't detect when the altered form is used for an event rather than a person."]
-fn dont_correct_so_much_nerve_wreck() {
- assert_no_lints(
- "So much nerve wreck for such a simple game ...",
- test_linter(),
- );
-}
-
-// NotOnly
-
-// -not only are-
-#[test]
-fn fix_no_only_are() {
- assert_suggestion_result(
- "No only are tests run on my pipeline but once successful, my app is deployed differently",
- test_linter(),
- "Not only are tests run on my pipeline but once successful, my app is deployed differently",
- );
-}
-
-// -not only is-
-#[test]
-fn fix_no_only_is() {
- assert_suggestion_result(
- "No only is it simple, it's efficient!",
- test_linter(),
- "Not only is it simple, it's efficient!",
- );
-}
-
-// -not only was-
-#[test]
-fn fix_no_only_was() {
- assert_suggestion_result(
- "No only was he happily creating shapes, but he was actively using distances and angles to do so.",
- test_linter(),
- "Not only was he happily creating shapes, but he was actively using distances and angles to do so.",
- );
-}
-
-// -not only were-
-#[test]
-fn fix_no_only_were() {
- assert_suggestion_result(
- "No only were there UI inconsistencies, but Safari lags behind chrome with things like the Popover API",
- test_linter(),
- "Not only were there UI inconsistencies, but Safari lags behind chrome with things like the Popover API",
- );
-}
-
-// Nowadays
-
-#[test]
-fn fix_now_a_days_spaces() {
- assert_suggestion_result(
- "Now a days, movie recommendation systems are well developed and are user focused.",
- test_linter(),
- "Nowadays, movie recommendation systems are well developed and are user focused.",
- );
-}
-
-#[test]
-fn fix_now_a_days_apostrophe() {
- assert_suggestion_result(
- "Now a day's recognizing the activity from the surveillance video is a challenging task.",
- test_linter(),
- "Nowadays recognizing the activity from the surveillance video is a challenging task.",
- );
-}
-
-#[test]
-fn fix_now_a_days_hyphen() {
- assert_suggestion_result(
- "Recommendation engines are now a one of the most common Machine Learning project that can be seen now-a-days.",
- test_linter(),
- "Recommendation engines are now a one of the most common Machine Learning project that can be seen nowadays.",
- );
-}
-
-#[test]
-fn fix_now_a_day() {
- assert_suggestion_result(
- "Now a day a calendar is a daily essential things.",
- test_linter(),
- "Nowadays a calendar is a daily essential things.",
- );
-}
-
-#[test]
-fn fix_now_a_day_hyphen() {
- assert_suggestion_result(
- "Now-a-day, lots of people prefer ordering food online to save their time and effort.",
- test_linter(),
- "Nowadays, lots of people prefer ordering food online to save their time and effort.",
- );
-}
-
-#[test]
-fn fix_now_adays_hyphen() {
- assert_suggestion_result(
- "@andyp1per knows most about those Python scripts now-adays.",
- test_linter(),
- "@andyp1per knows most about those Python scripts nowadays.",
- );
-}
-
-#[test]
-fn fix_now_adays_space() {
- assert_suggestion_result(
- "Coding is one of my fav thing to do now adays.!",
- test_linter(),
- "Coding is one of my fav thing to do nowadays.!",
- );
-}
-
-#[test]
-fn fix_nowaday() {
- assert_suggestion_result(
- "nowaday, I have to capitalize the first letter of the name gets from @babel/types.",
- test_linter(),
- "nowadays, I have to capitalize the first letter of the name gets from @babel/types.",
- );
-}
-
-#[test]
-fn fix_now_adays_apostrophe() {
- assert_suggestion_result(
- "I believe CSS clamp has great browser support now aday's as well.",
- test_linter(),
- "I believe CSS clamp has great browser support nowadays as well.",
- );
-}
-
-#[test]
-fn fix_nowa_days() {
- assert_suggestion_result(
- "But discord would be great cause discord is universally used for all games and companies and schools nowa days.",
- test_linter(),
- "But discord would be great cause discord is universally used for all games and companies and schools nowadays.",
- );
-}
-
-#[test]
-fn fix_now_aday() {
- assert_suggestion_result(
- "OF all Occupations that now aday is used,I would not be a butcher",
- test_linter(),
- "OF all Occupations that nowadays is used,I would not be a butcher",
- );
-}
-
-// Payed
-
-#[test]
-fn correct_payed() {
- assert_suggestion_result(
- "He payed the bill yesterday.",
- test_linter(),
- "He paid the bill yesterday.",
- );
-}
-
-#[test]
-fn correct_overpayed() {
- assert_suggestion_result(
- "He overpayed in part to have the specification met.",
- test_linter(),
- "He overpaid in part to have the specification met.",
- );
-}
-
-// RaiseTheQuestion
-
-// -raise the question-
-#[test]
-fn detect_rise_the_question() {
- assert_suggestion_result(
- "That would rise the question how to deal with syntax errors etc.",
- test_linter(),
- "That would raise the question how to deal with syntax errors etc.",
- );
-}
-
-#[test]
-fn detect_arise_the_question() {
- assert_suggestion_result(
- "As e.g. UTC+1, might arise the question whether it includes summer and winter time",
- test_linter(),
- "As e.g. UTC+1, might raise the question whether it includes summer and winter time",
- );
-}
-
-// -raises the question-
-#[test]
-fn detect_rises_the_question() {
- assert_suggestion_result(
- "However, this rises the question as to whether this test is conceptually sound.",
- test_linter(),
- "However, this raises the question as to whether this test is conceptually sound.",
- );
-}
-
-#[test]
-fn detect_arises_the_question() {
- assert_suggestion_result(
- "And it arises the question, why?",
- test_linter(),
- "And it raises the question, why?",
- );
-}
-
-// -raising the question-
-#[test]
-fn detect_rising_the_question() {
- assert_suggestion_result(
- "as soon as a infoHash query is performed, a Torrent file is retried, rising the question of:",
- test_linter(),
- "as soon as a infoHash query is performed, a Torrent file is retried, raising the question of:",
- );
-}
-
-#[test]
-fn detect_arising_the_question() {
- assert_suggestion_result(
- "arising the question whether the requirement of wgpu::Features::DEPTH24PLUS_STENCIL8 is precise",
- test_linter(),
- "raising the question whether the requirement of wgpu::Features::DEPTH24PLUS_STENCIL8 is precise",
- );
-}
-
-// -raised the question-
-#[test]
-fn detect_rose_the_question() {
- assert_suggestion_result(
- "Here is an example that rose the question at first: What works.",
- test_linter(),
- "Here is an example that raised the question at first: What works.",
- );
-}
-
-#[test]
-fn detect_risen_the_question() {
- assert_suggestion_result(
- "That has risen the question in my mind if it is still possible to embed your own Flash player on Facebook today?",
- test_linter(),
- "That has raised the question in my mind if it is still possible to embed your own Flash player on Facebook today?",
- );
-}
-
-#[test]
-fn detect_rised_the_question() {
- assert_suggestion_result(
- "I rised the question to Emax Support and they just came back to me inmediately with the below response.",
- test_linter(),
- "I raised the question to Emax Support and they just came back to me inmediately with the below response.",
- );
-}
-
-#[test]
-#[ignore = "Not actually an error after when it's 'there arose'"]
-fn dont_fag_there_arose_the_question() {
- assert_suggestion_result(
- "Hello, while I have been using modals manager there arose the question related to customizing of modal header.",
- test_linter(),
- "Hello, while I have been using modals manager there arose the question related to customizing of modal header.",
- );
-}
-
-#[test]
-fn detect_arised_the_question() {
- assert_suggestion_result(
- "and that fact arised the question in my mind, what does exactly is happening",
- test_linter(),
- "and that fact raised the question in my mind, what does exactly is happening",
- );
-}
-
-#[test]
-fn detect_arose_the_question() {
- assert_suggestion_result(
- "This arose the question, could I store 32 digits on the stack?",
- test_linter(),
- "This raised the question, could I store 32 digits on the stack?",
- );
-}
-
-#[test]
-fn detect_arisen_the_question() {
- assert_suggestion_result(
- "Some have arisen the question like how to use this wireless HD mini camera",
- test_linter(),
- "Some have raised the question like how to use this wireless HD mini camera",
- );
-}
-
-// SideTangent
-
-#[test]
-fn fix_side_tangent_start_of_sentence() {
- assert_suggestion_result(
- "Side tangent: I personally wouldn't worry about using ; for removing the selection unless you need to.",
- test_linter(),
- "Tangent: I personally wouldn't worry about using ; for removing the selection unless you need to.",
- );
-}
-
-#[test]
-fn fix_side_tangent_aside() {
- assert_suggestion_result(
- "As a side tangent, in addition to not solving the gradual code repair problem",
- test_linter(),
- "As an aside, in addition to not solving the gradual code repair problem",
- );
-}
-
-#[test]
-fn fix_side_tangents() {
- assert_suggestion_result(
- "so we don't get bogged down by tiny formatting bikeshedding side tangents",
- test_linter(),
- "so we don't get bogged down by tiny formatting bikeshedding tangents",
- );
-}
-
-// ToToo
-
-// -a bridge too far-
-#[test]
-fn fix_a_bridge_too_far() {
- assert_suggestion_result(
- "If Winforms can ever be conquered by the Mono developers may be a bridge to far.",
- test_linter(),
- "If Winforms can ever be conquered by the Mono developers may be a bridge too far.",
- );
-}
-
-// -cake and eat it too-
-#[test]
-fn fix_cake_and_eat_it_too() {
- assert_suggestion_result(
- "The solution: wouldn't it be great if I could have my cake and eat it to?",
- test_linter(),
- "The solution: wouldn't it be great if I could have my cake and eat it too?",
- );
-}
-
-// -go to far-
-#[test]
-fn fix_go_to_far() {
- assert_suggestion_result(
- "It's difficult to be sure when we go to far sometime when you don't exactly how the beast works in the background .",
- test_linter(),
- "It's difficult to be sure when we go too far sometime when you don't exactly how the beast works in the background .",
- );
-}
-
-// -goes to far-
-#[test]
-fn fix_goes_to_far() {
- assert_suggestion_result(
- "Memory consumption and cpu consumption goes to far like 900% and more than this",
- test_linter(),
- "Memory consumption and cpu consumption goes too far like 900% and more than this",
- );
-}
-
-// -going to far-
-#[test]
-fn fix_going_to_far() {
- assert_suggestion_result(
- "wsrun is going to far on this because debug 's devDependency shouldn't be considered in the cycle detection, should it?",
- test_linter(),
- "wsrun is going too far on this because debug 's devDependency shouldn't be considered in the cycle detection, should it?",
- );
-}
-
-// -gone to far-
-#[test]
-fn fix_gone_to_far() {
- assert_suggestion_result(
- "I might have gone to far with opening issues for small things.",
- test_linter(),
- "I might have gone too far with opening issues for small things.",
- );
-}
-
-// -went to far-
-#[test]
-fn fix_went_to_far() {
- assert_suggestion_result(
- "But I went to far compared to the initial request that seems talk about ...",
- test_linter(),
- "But I went too far compared to the initial request that seems talk about ...",
- );
-}
-
-// -life's too short-
-#[test]
-fn fix_life_s_too_short() {
- assert_suggestion_result(
- "Life's to short for messing around with git add , writing commit message.",
- test_linter(),
- "Life's too short for messing around with git add , writing commit message.",
- );
-}
-
-#[test]
-fn fix_lifes_to_short() {
- assert_suggestion_result(
- "I wouldn't go back after the 3rd interview lifes to short.",
- test_linter(),
- "I wouldn't go back after the 3rd interview life's too short.",
- );
-}
-
-// -life is too short-
-#[test]
-fn fix_life_is_too_short() {
- assert_suggestion_result(
- "[Life is to short to use dated cli tools that suck]",
- test_linter(),
- "[Life is too short to use dated cli tools that suck]",
- );
-}
-
-// -put too fine a point-
-#[test]
-fn fix_put_too_fine_a_point() {
- assert_suggestion_result(
- "Not to put to fine a point on it... that's not the kind of team I think we want to be.",
- test_linter(),
- "Not to put too fine a point on it... that's not the kind of team I think we want to be.",
- );
-}
-
-// -speak too soon-
-#[test]
-fn fix_speak_too_soon() {
- assert_suggestion_result(
- "I don't want to speak to soon but I kept everything as I had before but included: http = httplib2.Http()",
- test_linter(),
- "I don't want to speak too soon but I kept everything as I had before but included: http = httplib2.Http()",
- );
-}
-
-// -speaking too soon-
-#[test]
-fn fix_speaking_too_soon() {
- assert_suggestion_result(
- "EDIT: Thats what I get for speaking to soon...",
- test_linter(),
- "EDIT: Thats what I get for speaking too soon...",
- );
-}
-
-// -spoke too soon-
-#[test]
-fn fix_spoke_too_soon() {
- assert_suggestion_result(
- "I spoke to soon. Ignore the previous post.",
- test_linter(),
- "I spoke too soon. Ignore the previous post.",
- );
-}
-
-// -spoken too soon-
-#[test]
-fn fix_spoken_too_soon() {
- assert_suggestion_result(
- "EDIT: I might have spoken to soon...",
- test_linter(),
- "EDIT: I might have spoken too soon...",
- );
-}
-
-// -think to much-
-#[test]
-fn fix_think_too_much() {
- assert_suggestion_result(
- "I don't think to much about it, but I don't think it's a big deal.",
- test_linter(),
- "I don't think too much about it, but I don't think it's a big deal.",
- );
-}
-
-// -too big for-
-#[test]
-fn fix_too_big_for() {
- assert_suggestion_result(
- "ng-relations form to big for small screens",
- test_linter(),
- "ng-relations form too big for small screens",
- );
-}
-
-// -too big to fail-
-#[test]
-fn fix_too_big_to_fail() {
- assert_suggestion_result(
- "The core alone has 50k LOC. Reminds me of \"to big to fail\".",
- test_linter(),
- "The core alone has 50k LOC. Reminds me of \"too big to fail\".",
- );
-}
-
-// -too good to be true-
-#[test]
-fn fix_too_good_to_be_true() {
- assert_suggestion_result(
- "This seemed to good to be true, but local to scene resources will not work when they are not contained in a node.",
- test_linter(),
- "This seemed too good to be true, but local to scene resources will not work when they are not contained in a node.",
- );
-}
-
-#[test]
-fn fix_too_good_too_be_true() {
- assert_suggestion_result(
- "The normalization of rewards is making the plot in tensorboard look too good too be true, because they are not the actual reward ...",
- test_linter(),
- "The normalization of rewards is making the plot in tensorboard look too good to be true, because they are not the actual reward ...",
- );
-}
-
-// -too much information-
-#[test]
-fn fix_too_much_information() {
- assert_suggestion_result(
- "Live test are printing way to much information and is polluting our test output",
- test_linter(),
- "Live test are printing way too much information and is polluting our test output",
- );
-}
-
-// TooTo
-
-// -too big too fail-
-#[test]
-fn fix_too_big_too_fail() {
- assert_suggestion_result(
- "In other words, pointer arithmetic is, at this point, too big too fail, regardless of the clever and sophisticated way C++ lawyercats worded it.",
- test_linter(),
- "In other words, pointer arithmetic is, at this point, too big to fail, regardless of the clever and sophisticated way C++ lawyercats worded it.",
- );
-}
-
-// WholeEntire
-
-#[test]
-fn detect_atomic_whole_entire() {
- assert_suggestion_result("whole entire", test_linter(), "whole");
-}
-
-#[test]
-fn correct_real_world_whole_entire() {
- assert_suggestion_result(
- "[FR] support use system dns in whole entire app",
- test_linter(),
- "[FR] support use system dns in whole app",
- );
-}
-
-// -a whole entire-
-#[test]
-fn correct_atomic_a_whole_entire_to_a_whole() {
- assert_suggestion_result("a whole entire", test_linter(), "a whole");
-}
-
-#[test]
-fn correct_atomic_a_whole_entire_to_an_entire() {
- assert_suggestion_result("a whole entire", test_linter(), "an entire");
-}
-
-#[test]
-fn correct_real_world_a_whole_entire_to_a_whole() {
- assert_suggestion_result(
- "Start mapping a whole entire new planet using NASA’s MOLA.",
- test_linter(),
- "Start mapping a whole new planet using NASA’s MOLA.",
- );
-}
-
-#[test]
-fn correct_real_world_a_whole_entire_to_an_entire() {
- assert_suggestion_result(
- "I am not sure I can pass in a whole entire query via the include.",
- test_linter(),
- "I am not sure I can pass in an entire query via the include.",
- );
-}
-
-// WorseOrWorst
-
-// -a lot worst-
-#[test]
-fn detect_a_lot_worse_atomic() {
- assert_suggestion_result("a lot worst", test_linter(), "a lot worse");
-}
-
-#[test]
-fn detect_a_lot_worse_real_world() {
- assert_suggestion_result(
- "On a debug build, it's even a lot worst.",
- test_linter(),
- "On a debug build, it's even a lot worse.",
- );
-}
-
-// -become worst-
-#[test]
-fn fix_became_worst() {
- assert_suggestion_result(
- "The problem became worst lately.",
- test_linter(),
- "The problem became worse lately.",
- );
-}
-
-#[test]
-fn fix_become_worst() {
- assert_suggestion_result(
- "But results seems stay at one place or become worst.",
- test_linter(),
- "But results seems stay at one place or become worse.",
- );
-}
-
-#[test]
-fn fix_becomes_worst() {
- assert_suggestion_result(
- "This becomes worst if you have an x64 dll and an x86 dll that you don't have thier source codes and want to use them in same project!",
- test_linter(),
- "This becomes worse if you have an x64 dll and an x86 dll that you don't have thier source codes and want to use them in same project!",
- );
-}
-
-#[test]
-fn fix_becoming_worst() {
- assert_suggestion_result(
- "France is becoming worst than the Five Eyes",
- test_linter(),
- "France is becoming worse than the Five Eyes",
- );
-}
-
-// -far worse-
-#[test]
-fn detect_far_worse_atomic() {
- assert_suggestion_result("far worst", test_linter(), "far worse");
-}
-
-#[test]
-fn detect_far_worse_real_world() {
- assert_suggestion_result(
- "I mainly use Firefox (personal preference) and have noticed it has far worst performance than Chrome",
- test_linter(),
- "I mainly use Firefox (personal preference) and have noticed it has far worse performance than Chrome",
- );
-}
-
-// -get worst-
-#[test]
-fn fix_get_worse() {
- assert_suggestion_result(
- "and the problem appears to get worst with 2025.5.1 and 2025.5.2.",
- test_linter(),
- "and the problem appears to get worse with 2025.5.1 and 2025.5.2.",
- );
-}
-
-#[test]
-fn fix_gets_worse() {
- assert_suggestion_result(
- "It just starts after about 15 minutes of work and gradually gets worst.",
- test_linter(),
- "It just starts after about 15 minutes of work and gradually gets worse.",
- );
-}
-
-#[test]
-#[ignore = "This kind of false positive is probably too subtle to detect"]
-fn dont_flag_getting_worst() {
- // Here "getting" probably belongs to "I am getting" rather than "getting worst".
- // Which would not be an error but "I am getting the worst accuracy" would be better.
- // TODO: Maybe a noun following "getting" is enough context?
- assert_lint_count(
- "I am getting worst accuracy on the same dataste and 3 different models.",
- test_linter(),
- 0,
- );
-}
-
-#[test]
-fn fix_getting_worst() {
- assert_suggestion_result(
- "But, as I said, it is getting worst...",
- test_linter(),
- "But, as I said, it is getting worse...",
- );
-}
-
-#[test]
-fn fix_got_worst() {
- assert_suggestion_result(
- "typescript support got worst.",
- test_linter(),
- "typescript support got worse.",
- );
-}
-
-#[test]
-fn fix_gotten_worst() {
- assert_suggestion_result(
- "Has Claude gotten worst?",
- test_linter(),
- "Has Claude gotten worse?",
- );
-}
-
-// -much worse-
-#[test]
-fn detect_much_worse_atomic() {
- assert_suggestion_result("much worst", test_linter(), "much worse");
-}
-
-#[test]
-fn detect_much_worse_real_world() {
- assert_suggestion_result(
- "the generated image quality is much worst (actually nearly broken)",
- test_linter(),
- "the generated image quality is much worse (actually nearly broken)",
- );
-}
-
-// -turn for the worse-
-#[test]
-fn detect_turn_for_the_worse_atomic() {
- assert_suggestion_result("turn for the worst", test_linter(), "turn for the worse");
-}
-
-#[test]
-fn detect_turn_for_the_worse_real_world() {
- assert_suggestion_result(
- "Very surprised to see this repo take such a turn for the worst.",
- test_linter(),
- "Very surprised to see this repo take such a turn for the worse.",
- );
-}
-
-// -worse than-
-#[test]
-fn detect_worse_than_atomic() {
- assert_suggestion_result("worst than", test_linter(), "worse than");
-}
-
-#[test]
-fn detect_worse_than_real_world() {
- assert_suggestion_result(
- "Project real image - inversion quality is worst than in StyleGAN2",
- test_linter(),
- "Project real image - inversion quality is worse than in StyleGAN2",
- );
-}
-
-// -worst ever-
-#[test]
-fn detect_worst_ever_atomic() {
- assert_suggestion_result("worse ever", test_linter(), "worst ever");
-}
-
-#[test]
-fn detect_worst_ever_real_world() {
- assert_suggestion_result(
- "The Bcl package family is one of the worse ever published by Microsoft.",
- test_linter(),
- "The Bcl package family is one of the worst ever published by Microsoft.",
- );
-}
-
-// -worse and worse-
-#[test]
-fn detect_worst_and_worst_atomic() {
- assert_suggestion_result("worst and worst", test_linter(), "worse and worse");
-}
-
-#[test]
-fn detect_worst_and_worst_real_world() {
- assert_suggestion_result(
- "This control-L trick does not work for me. The padding is getting worst and worst.",
- test_linter(),
- "This control-L trick does not work for me. The padding is getting worse and worse.",
- );
-}
-
-#[test]
-fn detect_worse_and_worst_real_world() {
- assert_suggestion_result(
- "This progressively got worse and worst to the point that the machine (LEAD 1010) stopped moving alltogether.",
- test_linter(),
- "This progressively got worse and worse to the point that the machine (LEAD 1010) stopped moving alltogether.",
- );
-}
-
-// -at worst-
-#[test]
-fn detect_at_worst_atomic() {
- assert_suggestion_result(
- "Partial moving of core objects to interpreter state is incorrect at best, unsafe at worse.",
- test_linter(),
- "Partial moving of core objects to interpreter state is incorrect at best, unsafe at worst.",
- );
-}
-
-// -worst case scenario-
-#[test]
-fn correct_worse_case_space() {
- assert_suggestion_result(
- "In the worse case scenario, remote code execution could be achieved.",
- test_linter(),
- "In the worst-case scenario, remote code execution could be achieved.",
- );
-}
-
-#[test]
-fn correct_worse_case_hyphen() {
- assert_suggestion_result(
- "Basically I want my pods to get the original client IP address... or at least have X-Forwarded-For header, in a worse-case scenario.",
- test_linter(),
- "Basically I want my pods to get the original client IP address... or at least have X-Forwarded-For header, in a worst-case scenario.",
- );
-}
-
-#[test]
-fn correct_worse_case_two_hyphens() {
- assert_suggestion_result(
- "In a worse-case-scenario, the scenario class code and the results being analysed, become out of sync, and so the wrong labels are applied.",
- test_linter(),
- "In a worst-case scenario, the scenario class code and the results being analysed, become out of sync, and so the wrong labels are applied.",
- );
-}
-
-// -make it worst-
-#[test]
-fn detect_make_it_worst_atomic() {
- assert_suggestion_result(
- "And if you try to access before that, CloudFront will cache the error and it'll make it worst.",
- test_linter(),
- "And if you try to access before that, CloudFront will cache the error and it'll make it worse.",
- );
-}
-
-// -made it worst-
-#[test]
-fn detect_made_it_worst_atomic() {
- assert_suggestion_result(
- "However in couple of occasions the refresh made it worst and it showed commit differences that were already commited and pushed to origin.",
- test_linter(),
- "However in couple of occasions the refresh made it worse and it showed commit differences that were already commited and pushed to origin.",
- );
-}
-
-// -makes it worst-
-#[test]
-fn detect_makes_it_worst_atomic() {
- assert_suggestion_result(
- "What makes it worst, is if I use the returned SHA to try and update the newly created file I get the same error I show below.",
- test_linter(),
- "What makes it worse, is if I use the returned SHA to try and update the newly created file I get the same error I show below.",
- );
-}
-
-// -making it worst-
-#[test]
-fn detect_making_it_worst_atomic() {
- assert_suggestion_result(
- "PLease ai realled need help with this I think I'm making it worst.",
- test_linter(),
- "PLease ai realled need help with this I think I'm making it worse.",
- );
-}
-
-// -make them worst-
-#[test]
-fn detect_make_them_worst_atomic() {
- assert_suggestion_result(
- "Not sure if this makes things clearer or make them worst.",
- test_linter(),
- "Not sure if this makes things clearer or make them worse.",
- );
-}
-
-// -made them worst-
-#[test]
-fn detect_made_them_worst_atomic() {
- assert_suggestion_result(
- "if not outroght caused them / made them worst",
- test_linter(),
- "if not outroght caused them / made them worse",
- );
-}
-
-// -makes them worst-
-#[test]
-fn detect_makes_them_worst_atomic() {
- assert_suggestion_result(
- "(tried ~14 different hyperparameter and data format combos), however, always just makes them worst, they go from \"slightly\" wrong to \"complete nonsense\".",
- test_linter(),
- "(tried ~14 different hyperparameter and data format combos), however, always just makes them worse, they go from \"slightly\" wrong to \"complete nonsense\".",
- );
-}
-
-#[test]
-#[ignore = "This false positive is not handled yet"]
-fn dont_flag_makes_them_worst_case() {
- assert_lint_count(
- "Note 1: all hash tables has an Achilles heel that makes them worst case O(N)",
- test_linter(),
- 0,
- );
-}
-
-// -making them worst-
-#[test]
-fn detect_making_them_worst_atomic() {
- assert_suggestion_result(
- "As for the last part about Apple deliberately making them worst in order for us to buy the 3s",
- test_linter(),
- "As for the last part about Apple deliberately making them worse in order for us to buy the 3s",
- );
-}