From 46152616163e58ed4fab2a4ee1d9d155cc14cd42 Mon Sep 17 00:00:00 2001
From: Steve Ramage <gitcommits@sjrx.net>
Date: Fri, 27 Dec 2024 11:52:24 -0700
Subject: [PATCH] feat: Add support LimitCPU=,LimitData,.... (Resolves #312)

---
 .../semanticdata/SemanticDataRepository.kt    |   2 +
 .../optionvalues/RlimitOptionValue.kt         |  82 ++
 .../grammar/AlternativeCombinator.kt          |   4 +-
 .../grammar/GrammarOptionValue.kt             |   6 +-
 .../grammar/OptionalWhitespacePrefix.kt       |  34 +
 .../grammar/SequenceCombinator.kt             |   2 +-
 .../grammar/WhitespaceTerminal.kt             |  29 +
 .../inspections/InvalidValueForRLimitTest.kt  | 780 ++++++++++++++++++
 ...pectionForAllowedCpuSetOptionValueTest.kt} |  12 +-
 ... => InvalidValueInspectionForCPUShares.kt} |   8 +-
 ... => InvalidValueInspectionForCPUWeight.kt} |   8 +-
 ...ectionForConfigParseSecOptionValueTest.kt} |   8 +-
 ...InspectionForExecDirectoriesOptionsTest.kt |   8 +-
 ...nvalidValueInspectionForExecOptionsTest.kt |  18 +-
 ...ValueInspectionForExecOutputOptionsTest.kt |   6 +-
 ...idValueInspectionForIOReadBandwidthMax.kt} |   8 +-
 ...> InvalidValueInspectionForImagePolicy.kt} |  12 +-
 ...dValueInspectionForPathOptionValueTest.kt} |   4 +-
 ...alidValueInspectionForSignalOptionsTest.kt |   6 +-
 ...kt => InvalidValueInspectionForTTYSize.kt} |   6 +-
 ...validValueInspectionForUnsignedInteger.kt} |   6 +-
 .../inspections/InvalidValueInspectionTest.kt |  44 +-
 .../optionvalues/OptionValueTest.kt           |   2 +-
 .../optionvalues/grammar/Grammar.kt           |  72 ++
 24 files changed, 1081 insertions(+), 86 deletions(-)
 create mode 100644 src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/RlimitOptionValue.kt
 create mode 100644 src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/OptionalWhitespacePrefix.kt
 create mode 100644 src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/WhitespaceTerminal.kt
 create mode 100644 src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueForRLimitTest.kt
 rename src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/{InvalidValidInspectionForAllowedCpuSetOptionValueTest.kt => InvalidValueInspectionForAllowedCpuSetOptionValueTest.kt} (88%)
 rename src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/{InvalidValidInspectionForCPUShares.kt => InvalidValueInspectionForCPUShares.kt} (84%)
 rename src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/{InvalidValidInspectionForCPUWeight.kt => InvalidValueInspectionForCPUWeight.kt} (86%)
 rename src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/{InvalidValidInspectionForConfigParseSecOptionValueTest.kt => InvalidValueInspectionForConfigParseSecOptionValueTest.kt} (85%)
 rename src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/{InvalidValidInspectionForIOReadBandwidthMax.kt => InvalidValueInspectionForIOReadBandwidthMax.kt} (78%)
 rename src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/{InvalidValidInspectionForImagePolicy.kt => InvalidValueInspectionForImagePolicy.kt} (80%)
 rename src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/{InvalidValidInspectionForPathOptionValueTest.kt => InvalidValueInspectionForPathOptionValueTest.kt} (87%)
 rename src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/{InvalidValidInspectionForTTYSize.kt => InvalidValueInspectionForTTYSize.kt} (85%)
 rename src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/{InvalidValidInspectionForUnsignedInteger.kt => InvalidValueInspectionForUnsignedInteger.kt} (85%)

diff --git a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/SemanticDataRepository.kt b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/SemanticDataRepository.kt
index 7796b386..b6252529 100644
--- a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/SemanticDataRepository.kt
+++ b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/SemanticDataRepository.kt
@@ -120,6 +120,8 @@ class SemanticDataRepository private constructor() {
     validatorMap.putAll(ImagePolicyOptionValue.validators)
     validatorMap.putAll(CPUWeightOptionValue.validators)
     validatorMap.putAll(CPUSharesOptionValue.validators)
+
+    validatorMap.putAll(RlimitOptionValue.validators)
     // Scopes are not supported since they aren't standard unit files.
     fileClassToSectionNameToKeyValuesFromDoc["unit"]?.remove(SCOPE_KEYWORD)
     fileClassToSectionToKeyAndValidatorMap["unit"]?.remove(SCOPE_KEYWORD)
diff --git a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/RlimitOptionValue.kt b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/RlimitOptionValue.kt
new file mode 100644
index 00000000..269f885e
--- /dev/null
+++ b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/RlimitOptionValue.kt
@@ -0,0 +1,82 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues
+
+import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.Validator
+import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar.*
+import java.util.Optional
+
+class RlimitOptionValue(grammar : Combinator) : GrammarOptionValue("config_parse_rlimit", grammar) {
+  companion object {
+
+    val GENERIC_SEQ =
+      AlternativeCombinator(
+        OptionalWhitespacePrefix(FlexibleLiteralChoiceTerminal("infinity")),
+        OptionalWhitespacePrefix(IntegerTerminal(0, Int.MAX_VALUE)))
+
+    val BYTE_SEQ = AlternativeCombinator(
+      FlexibleLiteralChoiceTerminal("infinity"),
+      SequenceCombinator(
+        OptionalWhitespacePrefix(IntegerTerminal(0, Int.MAX_VALUE)),
+        OptionalWhitespacePrefix(LiteralChoiceTerminal("K", "M", "G", "T", "P", "E"))
+      ),
+      OptionalWhitespacePrefix(IntegerTerminal(0, Int.MAX_VALUE)))
+
+    val TIME_SEQ = AlternativeCombinator(
+      FlexibleLiteralChoiceTerminal("infinity"),
+      OneOrMore(
+        SequenceCombinator(
+          OptionalWhitespacePrefix(IntegerTerminal(0, Int.MAX_VALUE)),
+          OptionalWhitespacePrefix(FlexibleLiteralChoiceTerminal("usec", "us", "μs", "msec", "ms", "seconds", "second", "sec", "s", "minutes", "minute", "min", "m", "hours", "hour", "hr", "h", "days", "day", "d", "weeks", "week", "w", "months", "month", "M", "years", "year", "y"))
+        )
+      ),
+      OptionalWhitespacePrefix(IntegerTerminal(0, Int.MAX_VALUE))
+    )
+
+    val NICE_SEQ = AlternativeCombinator(
+      SequenceCombinator(LiteralChoiceTerminal("+", "-"), IntegerTerminal(0, 21)),
+      OptionalWhitespacePrefix(SequenceCombinator(IntegerTerminal(0, 41))),
+    )
+
+    val COLON = LiteralChoiceTerminal(":")
+
+    val BYTE_RLIMIT = SequenceCombinator(AlternativeCombinator(SequenceCombinator(BYTE_SEQ, COLON, BYTE_SEQ), BYTE_SEQ), EOF())
+    val TIME_RLIMIT = SequenceCombinator(AlternativeCombinator(SequenceCombinator(TIME_SEQ, COLON, TIME_SEQ), TIME_SEQ), EOF())
+    val GENERIC_RLIMIT = SequenceCombinator(AlternativeCombinator(SequenceCombinator(GENERIC_SEQ, COLON, GENERIC_SEQ), GENERIC_SEQ), EOF())
+    val NICE_RLIMIT = SequenceCombinator(AlternativeCombinator(SequenceCombinator(NICE_SEQ, COLON, NICE_SEQ), NICE_SEQ), EOF())
+
+
+    val validators = mapOf(
+      //        Exec.LimitCPU,                config_parse_rlimit,         RLIMIT_CPU,               offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_CPU") to RlimitOptionValue(TIME_RLIMIT),
+      //        Exec.LimitFSIZE,              config_parse_rlimit,         RLIMIT_FSIZE,             offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_FSIZE") to RlimitOptionValue(BYTE_RLIMIT),
+      //        Exec.LimitDATA,               config_parse_rlimit,         RLIMIT_DATA,              offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_DATA") to RlimitOptionValue(BYTE_RLIMIT),
+      //        Exec.LimitSTACK,              config_parse_rlimit,         RLIMIT_STACK,             offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_STACK") to RlimitOptionValue(BYTE_RLIMIT),
+      //        Exec.LimitCORE,               config_parse_rlimit,         RLIMIT_CORE,              offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_CORE") to RlimitOptionValue(BYTE_RLIMIT),
+      //        Exec.LimitRSS,                config_parse_rlimit,         RLIMIT_RSS,               offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_RSS") to RlimitOptionValue(BYTE_RLIMIT),
+      //        Exec.LimitNOFILE,             config_parse_rlimit,         RLIMIT_NOFILE,            offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_NOFILE") to RlimitOptionValue(GENERIC_RLIMIT),
+      //        Exec.LimitAS,                 config_parse_rlimit,         RLIMIT_AS,                offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_AS") to RlimitOptionValue(BYTE_RLIMIT),
+      //        Exec.LimitNPROC,              config_parse_rlimit,         RLIMIT_NPROC,             offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_NPROC") to RlimitOptionValue(GENERIC_RLIMIT),
+      //        Exec.LimitMEMLOCK,            config_parse_rlimit,         RLIMIT_MEMLOCK,           offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_MEMLOCK") to RlimitOptionValue(BYTE_RLIMIT),
+      //        Exec.LimitLOCKS,              config_parse_rlimit,         RLIMIT_LOCKS,             offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_LOCKS") to RlimitOptionValue(GENERIC_RLIMIT),
+      //        Exec.LimitSIGPENDING,         config_parse_rlimit,         RLIMIT_SIGPENDING,        offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_SIGPENDING") to RlimitOptionValue(GENERIC_RLIMIT),
+      //        Exec.LimitMSGQUEUE,           config_parse_rlimit,         RLIMIT_MSGQUEUE,          offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_MSGQUEUE") to RlimitOptionValue(BYTE_RLIMIT),
+      //        Exec.LimitNICE,               config_parse_rlimit,         RLIMIT_NICE,              offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_NICE") to RlimitOptionValue(NICE_RLIMIT),
+      //        Exec.LimitRTPRIO,             config_parse_rlimit,         RLIMIT_RTPRIO,            offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_RTPRIO") to RlimitOptionValue(GENERIC_RLIMIT),
+      //        Exec.LimitRTTIME,             config_parse_rlimit,         RLIMIT_RTTIME,            offsetof(Settings, rlimit)
+      Validator("config_parse_rlimit", "RLIMIT_RTTIME") to RlimitOptionValue(TIME_RLIMIT),
+    )
+  }
+}
diff --git a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/AlternativeCombinator.kt b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/AlternativeCombinator.kt
index 444a3010..69d68a58 100644
--- a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/AlternativeCombinator.kt
+++ b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/AlternativeCombinator.kt
@@ -5,7 +5,7 @@ import kotlin.math.max
 /**
  * This is a sequence of tokens that must match any of them.
  */
-class AlternativeCombinator(vararg val tokens: Combinator) : Combinator {
+open class AlternativeCombinator(vararg val tokens: Combinator) : Combinator {
 
   fun match(value: String, offset: Int, f: (Combinator, String, Int) -> MatchResult): MatchResult {
 
@@ -20,8 +20,6 @@ class AlternativeCombinator(vararg val tokens: Combinator) : Combinator {
         return match
       }
 
-
-
       if (match.tokens.size > longestTerminalMatch.size) {
         longestTerminalMatch = match.terminals
         longestTokenMatch = match.tokens
diff --git a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/GrammarOptionValue.kt b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/GrammarOptionValue.kt
index a3874f30..68bb0aba 100644
--- a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/GrammarOptionValue.kt
+++ b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/GrammarOptionValue.kt
@@ -50,8 +50,6 @@ open class GrammarOptionValue(
         }
 
         holder.registerProblem(property.valueNode.psi, "${property.key}'s value does not match the expected format. Possible reasons include unrecognized characters or premature end of input.", ProblemHighlightType.GENERIC_ERROR_OR_WARNING, tr)
-
-
         return
       }
 
@@ -96,9 +94,9 @@ open class GrammarOptionValue(
             }
           }
 
-          holder.registerProblem(property.valueNode.psi, "${property.key}'s value is correctly format but seems invalid.", ProblemHighlightType.GENERIC_ERROR_OR_WARNING, tr, *quickFixes.toTypedArray())
+          holder.registerProblem(property.valueNode.psi, "${property.key}'s value is correctly formatted but seems invalid.", ProblemHighlightType.GENERIC_ERROR_OR_WARNING, tr, *quickFixes.toTypedArray())
         } else {
-          holder.registerProblem(property.valueNode.psi, "${property.key}'s value is correctly format but seems invalid.", ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
+          holder.registerProblem(property.valueNode.psi, "${property.key}'s value is correctly formatted but seems invalid.", ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
         }
 
 
diff --git a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/OptionalWhitespacePrefix.kt b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/OptionalWhitespacePrefix.kt
new file mode 100644
index 00000000..53fab5ec
--- /dev/null
+++ b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/OptionalWhitespacePrefix.kt
@@ -0,0 +1,34 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar
+
+class OptionalWhitespacePrefix(val combinator: Combinator):
+  AlternativeCombinator(
+    SequenceCombinator(WhitespaceTerminal(), combinator),
+    combinator
+  ) {
+//
+//  override fun SyntacticMatch(value: String,  offset: Int): MatchResult {
+//    var newOffset = offset
+//    for(o in offset..<value.length) {
+//      if (value[o].isWhitespace()) {
+//        newOffset = o + 1
+//      } else {
+//        break
+//      }
+//    }
+//
+//    return combinator.SyntacticMatch(value, newOffset)
+//  }
+//
+//  override fun SemanticMatch(value: String, offset: Int): MatchResult {
+//    var newOffset = offset
+//    for(o in offset..<value.length) {
+//      if (value[o].isWhitespace()) {
+//        newOffset = o + 1
+//      } else {
+//        break
+//      }
+//    }
+//
+//    return combinator.SemanticMatch(value, newOffset)
+//  }
+}
diff --git a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/SequenceCombinator.kt b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/SequenceCombinator.kt
index 7e0e40a6..8d674d75 100644
--- a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/SequenceCombinator.kt
+++ b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/SequenceCombinator.kt
@@ -5,7 +5,7 @@ import kotlin.math.max
 /**
  * This is a sequence of tokens that must match all of them.
  */
-class SequenceCombinator(vararg val tokens: Combinator) : Combinator {
+open class SequenceCombinator(vararg val tokens: Combinator) : Combinator {
 
   override fun SyntacticMatch(value: String, offset: Int): MatchResult {
     var index = offset
diff --git a/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/WhitespaceTerminal.kt b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/WhitespaceTerminal.kt
new file mode 100644
index 00000000..aa932e22
--- /dev/null
+++ b/src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/WhitespaceTerminal.kt
@@ -0,0 +1,29 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar
+
+class WhitespaceTerminal : TerminalCombinator {
+
+  private fun match(value: String, offset: Int): MatchResult {
+    var newOffset = offset
+    for (o in offset until value.length) {
+      if (value[o].isWhitespace()) {
+        newOffset = o + 1
+      } else {
+        break
+      }
+    }
+
+    if (newOffset == offset) {
+      return NoMatch.copy(longestMatch = offset)
+    }
+
+    return MatchResult(listOf(value.substring(offset, newOffset)), newOffset, listOf(this), newOffset)
+  }
+
+  override fun SyntacticMatch(value: String, offset: Int): MatchResult {
+    return match(value, offset)
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): MatchResult {
+    return match(value, offset)
+  }
+}
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueForRLimitTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueForRLimitTest.kt
new file mode 100644
index 00000000..2d02d438
--- /dev/null
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueForRLimitTest.kt
@@ -0,0 +1,780 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.inspections
+
+import junit.framework.TestCase
+import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
+
+class InvalidValueForRLimitTest : AbstractUnitFileTest() {
+
+  fun testNoWarningWhenCPULimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitCPU=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testNoWarningWhenCPULimitIsInfinityIsSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitCPU=infinity
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+
+
+  fun testWarningWhenInvalidCPULimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitCPU=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitCPU's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenCPULimitSpecifiedInNSpawnFile() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Exec]
+            LimitCPU=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.nspawn", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+
+  fun testWarningWhenInvalidCPULimitSpecifiedInNSpawnFile() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Exec]
+            LimitCPU=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.nspawn", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitCPU's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenCPULimitSpecifiedInComplexFormat() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitCPU=6m
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testNoWarningWhenCPULimitSpecifiedInComplexFormatAndAdditionalWhitespace() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Exec]
+            LimitCPU= 1 day 6 m 10 s
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.nspawn", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testNoWarningWhenCPUSoftAndHardLimitSpecifiedInComplexFormatAndAdditionalWhitespace() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Exec]
+            LimitCPU= 1 day 6 m 10 s: 2 years
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.nspawn", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenCPULimitSpecifiedInComplexFormatAndMiscGarbageIsPresent() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Exec]
+            LimitCPU= 1 day 12 ns 2 years
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.nspawn", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitCPU's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals(" n", info.text)
+  }
+
+
+  fun testWarningWhenInvalidCPULimitSpecifiedInComplexFormat() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitCPU=-11m
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitCPU's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenFSIZELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitFSIZE=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testNoWarningWhenFSIZELimitIsInfinityIsSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitFSIZE=infinity
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testNoWarningWhenFSIZELimitSpecifiedWithWhiteSpaceUnitsAndSoftAndHardLimits() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitFSIZE=1 K: 2 G
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidFSIZELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitFSIZE=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitFSIZE's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenDATALimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitDATA=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidDATALimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitDATA=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitDATA's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenSTACKLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitSTACK=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidSTACKLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitSTACK=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitSTACK's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenCORELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitCORE=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidCORELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitCORE=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitCORE's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenRSSLIMITSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitRSS=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidRSSLIMITSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitRSS=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitRSS's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenNOFILELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitNOFILE=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testNoWarningWhenNOFILELimitWithWhitespaceSoftAndHardAndInfinityIsSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitNOFILE=1: infinity
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testNoWarningWhenASLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitAS=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidNOFILELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitNOFILE=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitNOFILE's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenNPROCLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitNPROC=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidNPROCLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitNPROC=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitNPROC's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenMEMLOCKLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitMEMLOCK=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidMEMLOCKLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitMEMLOCK=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitMEMLOCK's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenLOCKSLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitLOCKS=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidLOCKSLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitLOCKS=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitLOCKS's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenSIGPENDINGLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitSIGPENDING=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidSIGPENDINGLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitSIGPENDING=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitSIGPENDING's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+
+  fun testNoWarningWhenMSGQUEUELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitMSGQUEUE=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidMSGQUEUELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitMSGQUEUE=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitMSGQUEUE's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenNICELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitNICE=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidNICELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitNICE=-21
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitNICE's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("21", info.text)
+  }
+
+  fun testNoWarningWhenRTPRIOLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitRTPRIO=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidRTPRIOLimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitRTPRIO=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitRTPRIO's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+
+  fun testNoWarningWhenRTTIMELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitRTTIME=1
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+  }
+
+  fun testWarningWhenInvalidRTTIMELimitSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+            [Service]
+            LimitRTTIME=-11
+            """.trimIndent()
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    assertStringContains("LimitRTTIME's value is correctly formatted but seems invalid.", info!!.description)
+    TestCase.assertEquals("-11", info.text)
+  }
+}
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForAllowedCpuSetOptionValueTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForAllowedCpuSetOptionValueTest.kt
similarity index 88%
rename from src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForAllowedCpuSetOptionValueTest.kt
rename to src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForAllowedCpuSetOptionValueTest.kt
index 3c4c083c..14744c5b 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForAllowedCpuSetOptionValueTest.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForAllowedCpuSetOptionValueTest.kt
@@ -3,7 +3,7 @@ package net.sjrx.intellij.plugins.systemdunitfiles.inspections
 import junit.framework.TestCase
 import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
 
-class InvalidValidInspectionForAllowedCpuSetOptionValueTest : AbstractUnitFileTest() {
+class InvalidValueInspectionForAllowedCpuSetOptionValueTest : AbstractUnitFileTest() {
 
   fun testNoWeakWarningWhenSingleIntegerSpecified() {
     // Fixture Setup
@@ -114,7 +114,7 @@ class InvalidValidInspectionForAllowedCpuSetOptionValueTest : AbstractUnitFileTe
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Invalid syntax for CPU Range", info!!.description)
+    assertStringContains("Invalid syntax for CPU Range", info!!.description)
     TestCase.assertEquals("-1", info.text)
   }
 
@@ -135,7 +135,7 @@ class InvalidValidInspectionForAllowedCpuSetOptionValueTest : AbstractUnitFileTe
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Invalid syntax for CPU Range", info!!.description)
+    assertStringContains("Invalid syntax for CPU Range", info!!.description)
     TestCase.assertEquals("1--10", info.text)
   }
 
@@ -156,7 +156,7 @@ class InvalidValidInspectionForAllowedCpuSetOptionValueTest : AbstractUnitFileTe
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("The start 8 of the range must be less than the end 5 of the range", info!!.description)
+    assertStringContains("The start 8 of the range must be less than the end 5 of the range", info!!.description)
     TestCase.assertEquals("8-5", info.text)
   }
 
@@ -177,7 +177,7 @@ class InvalidValidInspectionForAllowedCpuSetOptionValueTest : AbstractUnitFileTe
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Invalid syntax for CPU Range", info!!.description)
+    assertStringContains("Invalid syntax for CPU Range", info!!.description)
     TestCase.assertEquals("1-2-3", info.text)
   }
 
@@ -198,7 +198,7 @@ class InvalidValidInspectionForAllowedCpuSetOptionValueTest : AbstractUnitFileTe
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Invalid syntax for CPU Range", info!!.description)
+    assertStringContains("Invalid syntax for CPU Range", info!!.description)
     TestCase.assertEquals("1-yo", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForCPUShares.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForCPUShares.kt
similarity index 84%
rename from src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForCPUShares.kt
rename to src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForCPUShares.kt
index a8280b72..b209ed04 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForCPUShares.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForCPUShares.kt
@@ -3,7 +3,7 @@ package net.sjrx.intellij.plugins.systemdunitfiles.inspections
 import junit.framework.TestCase
 import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
 
-class InvalidValidInspectionForCPUShares : AbstractUnitFileTest() {
+class InvalidValueInspectionForCPUShares : AbstractUnitFileTest() {
 
 
   fun testNoWarningWhenTwoSpecified() {
@@ -59,7 +59,7 @@ class InvalidValidInspectionForCPUShares : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("CPUShares's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("CPUShares's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("1", info.text)
   }
 
@@ -80,7 +80,7 @@ class InvalidValidInspectionForCPUShares : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("CPUShares's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("CPUShares's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("-10", info.text)
   }
 
@@ -102,7 +102,7 @@ class InvalidValidInspectionForCPUShares : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("CPUShares's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("CPUShares's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("262145", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForCPUWeight.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForCPUWeight.kt
similarity index 86%
rename from src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForCPUWeight.kt
rename to src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForCPUWeight.kt
index 0bee01c3..1c14f6b5 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForCPUWeight.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForCPUWeight.kt
@@ -3,7 +3,7 @@ package net.sjrx.intellij.plugins.systemdunitfiles.inspections
 import junit.framework.TestCase
 import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
 
-class InvalidValidInspectionForCPUWeight : AbstractUnitFileTest() {
+class InvalidValueInspectionForCPUWeight : AbstractUnitFileTest() {
 
   fun testNoWarningWhenIdleSpecified() {
     // Fixture Setup
@@ -76,7 +76,7 @@ class InvalidValidInspectionForCPUWeight : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("CPUWeight's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("CPUWeight's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("0", info.text)
   }
 
@@ -97,7 +97,7 @@ class InvalidValidInspectionForCPUWeight : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("CPUWeight's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("CPUWeight's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("-10", info.text)
   }
 
@@ -119,7 +119,7 @@ class InvalidValidInspectionForCPUWeight : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("CPUWeight's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("CPUWeight's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("-100000", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForConfigParseSecOptionValueTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForConfigParseSecOptionValueTest.kt
similarity index 85%
rename from src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForConfigParseSecOptionValueTest.kt
rename to src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForConfigParseSecOptionValueTest.kt
index 38d73991..7a046eed 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForConfigParseSecOptionValueTest.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForConfigParseSecOptionValueTest.kt
@@ -3,7 +3,7 @@ package net.sjrx.intellij.plugins.systemdunitfiles.inspections
 import junit.framework.TestCase
 import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
 
-class InvalidValidInspectionForConfigParseSecOptionValueTest : AbstractUnitFileTest() {
+class InvalidValueInspectionForConfigParseSecOptionValueTest : AbstractUnitFileTest() {
 
   fun testWeakWarningWhenStringSpecified() {
     // Fixture Setup
@@ -22,7 +22,7 @@ class InvalidValidInspectionForConfigParseSecOptionValueTest : AbstractUnitFileT
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Could not parse leading number", info!!.description)
+    assertStringContains("Could not parse leading number", info!!.description)
     TestCase.assertEquals("abc", info.text)
   }
 
@@ -43,7 +43,7 @@ class InvalidValidInspectionForConfigParseSecOptionValueTest : AbstractUnitFileT
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Negatives are not allowed", info!!.description)
+    assertStringContains("Negatives are not allowed", info!!.description)
     TestCase.assertEquals("-5", info.text)
   }
 
@@ -64,7 +64,7 @@ class InvalidValidInspectionForConfigParseSecOptionValueTest : AbstractUnitFileT
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Negatives are not allowed", info!!.description)
+    assertStringContains("Negatives are not allowed", info!!.description)
     TestCase.assertEquals("1 day -5 secs", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecDirectoriesOptionsTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecDirectoriesOptionsTest.kt
index 316a26ba..b06f0781 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecDirectoriesOptionsTest.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecDirectoriesOptionsTest.kt
@@ -62,7 +62,7 @@ class InvalidValueInspectionForExecDirectoriesOptionsTest : AbstractUnitFileTest
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("a list of relative paths", info!!.description)
+    assertStringContains("a list of relative paths", info!!.description)
     TestCase.assertEquals("/tmp/myunit", info.text)
   }
 
@@ -84,7 +84,7 @@ class InvalidValueInspectionForExecDirectoriesOptionsTest : AbstractUnitFileTest
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Takes a list of relative paths", info!!.description)
+    assertStringContains("Takes a list of relative paths", info!!.description)
     TestCase.assertEquals("/tmp/myunit /tmp/myunit2", info.text)
   }
 
@@ -106,7 +106,7 @@ class InvalidValueInspectionForExecDirectoriesOptionsTest : AbstractUnitFileTest
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Path cannot contain `..`", info!!.description)
+    assertStringContains("Path cannot contain `..`", info!!.description)
     TestCase.assertEquals("../myunit", info.text)
   }
 
@@ -128,7 +128,7 @@ class InvalidValueInspectionForExecDirectoriesOptionsTest : AbstractUnitFileTest
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Path cannot contain `..`", info!!.description)
+    assertStringContains("Path cannot contain `..`", info!!.description)
     TestCase.assertEquals("foo/bar test/tmp/ ../myunit", info.text)
   }
 }
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecOptionsTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecOptionsTest.kt
index a2027153..e759d0ef 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecOptionsTest.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecOptionsTest.kt
@@ -23,7 +23,7 @@ class InvalidValueInspectionForExecOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("an absolute path", info!!.description)
+    assertStringContains("an absolute path", info!!.description)
     TestCase.assertEquals("docker-compose", info.text)
   }
 
@@ -44,7 +44,7 @@ class InvalidValueInspectionForExecOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("an absolute path", info!!.description)
+    assertStringContains("an absolute path", info!!.description)
     TestCase.assertEquals("docker-compose", info.text)
   }
 
@@ -209,7 +209,7 @@ class InvalidValueInspectionForExecOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("an absolute path", info!!.description)
+    assertStringContains("an absolute path", info!!.description)
     TestCase.assertEquals("docker-compose", info.text)
   }
 
@@ -230,7 +230,7 @@ class InvalidValueInspectionForExecOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("an absolute path", info!!.description)
+    assertStringContains("an absolute path", info!!.description)
     TestCase.assertEquals("docker-compose", info.text)
   }
 
@@ -251,7 +251,7 @@ class InvalidValueInspectionForExecOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("an absolute path", info!!.description)
+    assertStringContains("an absolute path", info!!.description)
     TestCase.assertEquals("docker-compose", info.text)
   }
 
@@ -272,7 +272,7 @@ class InvalidValueInspectionForExecOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("an absolute path", info!!.description)
+    assertStringContains("an absolute path", info!!.description)
     TestCase.assertEquals("docker-compose", info.text)
   }
 
@@ -293,7 +293,7 @@ class InvalidValueInspectionForExecOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("an absolute path", info!!.description)
+    assertStringContains("an absolute path", info!!.description)
     TestCase.assertEquals("docker-compose", info.text)
   }
 
@@ -314,7 +314,7 @@ class InvalidValueInspectionForExecOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("an absolute path", info!!.description)
+    assertStringContains("an absolute path", info!!.description)
     TestCase.assertEquals("docker-compose", info.text)
   }
 
@@ -335,7 +335,7 @@ class InvalidValueInspectionForExecOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("an absolute path", info!!.description)
+    assertStringContains("an absolute path", info!!.description)
     TestCase.assertEquals("docker-compose", info.text)
   }
 }
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecOutputOptionsTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecOutputOptionsTest.kt
index 08ba617b..60295b4d 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecOutputOptionsTest.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForExecOutputOptionsTest.kt
@@ -59,7 +59,7 @@ class InvalidValueInspectionForExecOutputOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Takes one of", info!!.description)
+    assertStringContains("Takes one of", info!!.description)
     TestCase.assertEquals("foo", info.text)
   }
 
@@ -81,7 +81,7 @@ class InvalidValueInspectionForExecOutputOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("name must be specified after the colon", info!!.description)
+    assertStringContains("name must be specified after the colon", info!!.description)
     TestCase.assertEquals("fd:", info.text)
   }
 
@@ -103,7 +103,7 @@ class InvalidValueInspectionForExecOutputOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("path must be specified after the colon", info!!.description)
+    assertStringContains("path must be specified after the colon", info!!.description)
     TestCase.assertEquals("file:", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForIOReadBandwidthMax.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForIOReadBandwidthMax.kt
similarity index 78%
rename from src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForIOReadBandwidthMax.kt
rename to src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForIOReadBandwidthMax.kt
index 6fcf4fd7..ec72f9aa 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForIOReadBandwidthMax.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForIOReadBandwidthMax.kt
@@ -3,7 +3,7 @@ package net.sjrx.intellij.plugins.systemdunitfiles.inspections
 import junit.framework.TestCase
 import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
 
-class InvalidValidInspectionForIOReadBandwidthMax : AbstractUnitFileTest() {
+class InvalidValueInspectionForIOReadBandwidthMax : AbstractUnitFileTest() {
 
   fun testNoWarningWhenNumberSpecifiedWithoutUnit() {
     // Fixture Setup
@@ -60,7 +60,7 @@ class InvalidValidInspectionForIOReadBandwidthMax : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("IOReadBandwidthMax's value does not match the expected format. Possible reasons include unrecognized characters or premature end of input.", info!!.description)
+    assertStringContains("IOReadBandwidthMax's value does not match the expected format. Possible reasons include unrecognized characters or premature end of input.", info!!.description)
     TestCase.assertEquals("-5", info.text)
   }
 
@@ -81,7 +81,7 @@ class InvalidValidInspectionForIOReadBandwidthMax : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("IOReadBandwidthMax's value does not match the expected format. Possible reasons include unrecognized characters or premature end of input.", info!!.description)
+    assertStringContains("IOReadBandwidthMax's value does not match the expected format. Possible reasons include unrecognized characters or premature end of input.", info!!.description)
     TestCase.assertEquals("/home", info.text)
   }
 
@@ -103,7 +103,7 @@ class InvalidValidInspectionForIOReadBandwidthMax : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("IOReadBandwidthMax's value does not match the expected format. Possible reasons include unrecognized characters or premature end of input.", info!!.description)
+    assertStringContains("IOReadBandwidthMax's value does not match the expected format. Possible reasons include unrecognized characters or premature end of input.", info!!.description)
     TestCase.assertEquals("5", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForImagePolicy.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForImagePolicy.kt
similarity index 80%
rename from src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForImagePolicy.kt
rename to src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForImagePolicy.kt
index 4227cdf8..07ad152d 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForImagePolicy.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForImagePolicy.kt
@@ -3,7 +3,7 @@ package net.sjrx.intellij.plugins.systemdunitfiles.inspections
 import junit.framework.TestCase
 import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
 
-class InvalidValidInspectionForImagePolicy : AbstractUnitFileTest() {
+class InvalidValueInspectionForImagePolicy : AbstractUnitFileTest() {
 
   fun testNoWarningWhenNumberSpecifiedWithoutUnit() {
     // Fixture Setup
@@ -41,7 +41,7 @@ class InvalidValidInspectionForImagePolicy : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("RootImagePolicy's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("RootImagePolicy's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("opt", info.text)
   }
 
@@ -62,7 +62,7 @@ class InvalidValidInspectionForImagePolicy : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("RootImagePolicy's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("RootImagePolicy's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("unsigned", info.text)
   }
 
@@ -85,7 +85,7 @@ class InvalidValidInspectionForImagePolicy : AbstractUnitFileTest() {
     assertSize(1, highlights)
     val info = highlights[0]
 
-    AbstractUnitFileTest.Companion.assertStringContains("RootImagePolicy's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("RootImagePolicy's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("used", info.text)
     assertContainsQuickfix(info, "Replace 'used' with 'absent'")
   }
@@ -107,7 +107,7 @@ class InvalidValidInspectionForImagePolicy : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("RootImagePolicy's value does not match the expected format. Possible reasons include unrecognized characters or premature end of input", info!!.description)
+    assertStringContains("RootImagePolicy's value does not match the expected format. Possible reasons include unrecognized characters or premature end of input", info!!.description)
     TestCase.assertEquals("home=encrypted+absent+", info.text)
   }
 
@@ -128,7 +128,7 @@ class InvalidValidInspectionForImagePolicy : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("RootImagePolicy's value is correctly format but seems invalid", info!!.description)
+    assertStringContains("RootImagePolicy's value is correctly formatted but seems invalid", info!!.description)
     TestCase.assertEquals("used", info.text)
     assertContainsQuickfix(info, "Replace 'used' with 'absent'")
   }
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForPathOptionValueTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForPathOptionValueTest.kt
similarity index 87%
rename from src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForPathOptionValueTest.kt
rename to src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForPathOptionValueTest.kt
index 353d13a4..596da8ad 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForPathOptionValueTest.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForPathOptionValueTest.kt
@@ -3,7 +3,7 @@ package net.sjrx.intellij.plugins.systemdunitfiles.inspections
 import junit.framework.TestCase
 import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
 
-class InvalidValidInspectionForPathOptionValueTest : AbstractUnitFileTest() {
+class InvalidValueInspectionForPathOptionValueTest : AbstractUnitFileTest() {
 
   fun testWeakWarningWhenNegativeIntegerSpecified() {
     // Fixture Setup
@@ -22,7 +22,7 @@ class InvalidValidInspectionForPathOptionValueTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("absolute path", info!!.description)
+    assertStringContains("absolute path", info!!.description)
     TestCase.assertEquals("foo", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForSignalOptionsTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForSignalOptionsTest.kt
index 96b6d543..ae1f32bc 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForSignalOptionsTest.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForSignalOptionsTest.kt
@@ -21,7 +21,7 @@ class InvalidValueInspectionForSignalOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("signal(7) man page", info!!.description)
+    assertStringContains("signal(7) man page", info!!.description)
     TestCase.assertEquals("SIGARRET", info.text)
   }
 
@@ -41,7 +41,7 @@ class InvalidValueInspectionForSignalOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("signal(7) man page", info!!.description)
+    assertStringContains("signal(7) man page", info!!.description)
     TestCase.assertEquals("sigkill", info.text)
   }
 
@@ -61,7 +61,7 @@ class InvalidValueInspectionForSignalOptionsTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("if using an integer", info!!.description)
+    assertStringContains("if using an integer", info!!.description)
     TestCase.assertEquals("128", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForTTYSize.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForTTYSize.kt
similarity index 85%
rename from src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForTTYSize.kt
rename to src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForTTYSize.kt
index 9e450746..e96fa3ca 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForTTYSize.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForTTYSize.kt
@@ -3,7 +3,7 @@ package net.sjrx.intellij.plugins.systemdunitfiles.inspections
 import junit.framework.TestCase
 import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
 
-class InvalidValidInspectionForTTYSize : AbstractUnitFileTest() {
+class InvalidValueInspectionForTTYSize : AbstractUnitFileTest() {
 
   fun testWeakWarningWhenNegativeIntegerSpecified() {
     // Fixture Setup
@@ -22,7 +22,7 @@ class InvalidValidInspectionForTTYSize : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("must be an unsigned integer", info!!.description)
+    assertStringContains("must be an unsigned integer", info!!.description)
     TestCase.assertEquals("-5", info.text)
   }
 
@@ -43,7 +43,7 @@ class InvalidValidInspectionForTTYSize : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("must be an unsigned integer", info!!.description)
+    assertStringContains("must be an unsigned integer", info!!.description)
     TestCase.assertEquals("foo", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForUnsignedInteger.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForUnsignedInteger.kt
similarity index 85%
rename from src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForUnsignedInteger.kt
rename to src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForUnsignedInteger.kt
index a1c573f5..ad4056f9 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForUnsignedInteger.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionForUnsignedInteger.kt
@@ -3,7 +3,7 @@ package net.sjrx.intellij.plugins.systemdunitfiles.inspections
 import junit.framework.TestCase
 import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
 
-class InvalidValidInspectionForUnsignedInteger : AbstractUnitFileTest() {
+class InvalidValueInspectionForUnsignedInteger : AbstractUnitFileTest() {
 
   fun testWeakWarningWhenNegativeIntegerSpecified() {
     // Fixture Setup
@@ -22,7 +22,7 @@ class InvalidValidInspectionForUnsignedInteger : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("must be an unsigned integer", info!!.description)
+    assertStringContains("must be an unsigned integer", info!!.description)
     TestCase.assertEquals("-5", info.text)
   }
 
@@ -43,7 +43,7 @@ class InvalidValidInspectionForUnsignedInteger : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("must be an unsigned integer", info!!.description)
+    assertStringContains("must be an unsigned integer", info!!.description)
     TestCase.assertEquals("foo", info.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionTest.kt
index 029fe6b6..b86811da 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionTest.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValueInspectionTest.kt
@@ -55,10 +55,10 @@ class InvalidValueInspectionTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Most Def", info!!.description)
-    AbstractUnitFileTest.Companion.assertStringContains("must be one of", info.description)
-    AbstractUnitFileTest.Companion.assertStringContains("on", info.description)
-    AbstractUnitFileTest.Companion.assertStringContains("off", info.description)
+    assertStringContains("Most Def", info!!.description)
+    assertStringContains("must be one of", info.description)
+    assertStringContains("on", info.description)
+    assertStringContains("off", info.description)
     TestCase.assertEquals(HighlightInfoType.WARNING, info.type)
     val highlightElement = myFixture.file.findElementAt(info.getStartOffset())
     TestCase.assertNotNull(highlightElement)
@@ -116,10 +116,10 @@ class InvalidValueInspectionTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Most Def", info!!.description)
-    AbstractUnitFileTest.Companion.assertStringContains("must be one of", info.description)
-    AbstractUnitFileTest.Companion.assertStringContains("on", info.description)
-    AbstractUnitFileTest.Companion.assertStringContains("off", info.description)
+    assertStringContains("Most Def", info!!.description)
+    assertStringContains("must be one of", info.description)
+    assertStringContains("on", info.description)
+    assertStringContains("off", info.description)
     TestCase.assertEquals(HighlightInfoType.WARNING, info.type)
     val highlightElement = myFixture.file.findElementAt(info.getStartOffset())
     TestCase.assertNotNull(highlightElement)
@@ -193,8 +193,8 @@ class InvalidValueInspectionTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("ftp://www.google.com/rules.txt", info!!.description)
-    AbstractUnitFileTest.Companion.assertStringContains("a space separated list", info.description)
+    assertStringContains("ftp://www.google.com/rules.txt", info!!.description)
+    assertStringContains("a space separated list", info.description)
     TestCase.assertEquals(HighlightInfoType.WARNING, info.type)
     val highlightElement = myFixture.file.findElementAt(info.getStartOffset())
     TestCase.assertNotNull(highlightElement)
@@ -220,12 +220,12 @@ class InvalidValueInspectionTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("ftp://www.google.com/rules.txt", info!!.description)
-    AbstractUnitFileTest.Companion.assertStringContains("a space separated list", info.description)
+    assertStringContains("ftp://www.google.com/rules.txt", info!!.description)
+    assertStringContains("a space separated list", info.description)
     TestCase.assertEquals(HighlightInfoType.WARNING, info.type)
     val highlightElement = myFixture.file.findElementAt(info.getStartOffset())
     TestCase.assertNotNull(highlightElement)
-    AbstractUnitFileTest.Companion.assertStringContains("ftp://www.google.com/rules.txt", highlightElement!!.text)
+    assertStringContains("ftp://www.google.com/rules.txt", highlightElement!!.text)
   }
 
 
@@ -282,11 +282,11 @@ class InvalidValueInspectionTest : AbstractUnitFileTest() {
     // Verification
     assertSize(6, highlights)
     for (info in highlights) {
-      AbstractUnitFileTest.Companion.assertStringContains("Value is expected to be a 3 or 4 digit octal number not:", info!!.description)
+      assertStringContains("Value is expected to be a 3 or 4 digit octal number not:", info!!.description)
       TestCase.assertEquals(HighlightInfoType.WARNING, info.type)
       val highlightElement = myFixture.file.findElementAt(info.getStartOffset())
       TestCase.assertNotNull(highlightElement)
-      AbstractUnitFileTest.Companion.assertStringContains(highlightElement!!.text.trim { it <= ' ' }, info.description)
+      assertStringContains(highlightElement!!.text.trim { it <= ' ' }, info.description)
     }
   }
 
@@ -308,7 +308,7 @@ class InvalidValueInspectionTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Invalid unit name detected,", info!!.description)
+    assertStringContains("Invalid unit name detected,", info!!.description)
   }
 
   fun testInvalidUnitTypeInWantsTriggersWarning() {
@@ -328,7 +328,7 @@ class InvalidValueInspectionTest : AbstractUnitFileTest() {
     // Verification
     assertSize(1, highlights)
     val info = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Unit type foo", info!!.description)
+    assertStringContains("Unit type foo", info!!.description)
     TestCase.assertEquals("foo", info.text)
   }
 
@@ -348,19 +348,19 @@ class InvalidValueInspectionTest : AbstractUnitFileTest() {
     // Verification
     assertSize(5, highlights)
     val mysqlErrorMissingType = highlights[0]
-    AbstractUnitFileTest.Companion.assertStringContains("Invalid unit name detected", mysqlErrorMissingType!!.description)
+    assertStringContains("Invalid unit name detected", mysqlErrorMissingType!!.description)
     TestCase.assertEquals("mysql", mysqlErrorMissingType.text)
     val mongoInvalidType = highlights[1]
-    AbstractUnitFileTest.Companion.assertStringContains("Unit type db", mongoInvalidType!!.description)
+    assertStringContains("Unit type db", mongoInvalidType!!.description)
     TestCase.assertEquals("db", mongoInvalidType.text)
     val neo4jInvalidType = highlights[2]
-    AbstractUnitFileTest.Companion.assertStringContains("Unit type graph", neo4jInvalidType!!.description)
+    assertStringContains("Unit type graph", neo4jInvalidType!!.description)
     TestCase.assertEquals("graph", neo4jInvalidType.text)
     val cassandraMissingType = highlights[3]
-    AbstractUnitFileTest.Companion.assertStringContains("Invalid unit name detected", cassandraMissingType!!.description)
+    assertStringContains("Invalid unit name detected", cassandraMissingType!!.description)
     TestCase.assertEquals("cassandra", cassandraMissingType.text)
     val redisInvalidType = highlights[4]
-    AbstractUnitFileTest.Companion.assertStringContains("Unit type cache", redisInvalidType!!.description)
+    assertStringContains("Unit type cache", redisInvalidType!!.description)
     TestCase.assertEquals("cache", redisInvalidType.text)
   }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/OptionValueTest.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/OptionValueTest.kt
index 068c1953..b4f610fc 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/OptionValueTest.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/OptionValueTest.kt
@@ -35,7 +35,7 @@ class OptionValueTest : AbstractUnitFileTest() {
 
     println("Missing:$totalMissingValidators")
     println("Found:$totalFoundValidators")
-    if (totalMissingValidators > 611) {
+    if (totalMissingValidators > 530) {
       assertEquals("Number of missing validators is too high at ${totalMissingValidators} vs. found ${totalFoundValidators}", sortedList, "")
     }
 
diff --git a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/Grammar.kt b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/Grammar.kt
index 4ae0361e..fed38a94 100644
--- a/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/Grammar.kt
+++ b/src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/Grammar.kt
@@ -660,4 +660,76 @@ class GrammarTest : TestCase() {
     assertEquals(NoMatch, eof.SemanticMatch(invalidFromOffset, garbage.length))
   }
 
+  fun testOptionalWhitespacePrefixMatches() {
+    /**
+     * Fixture Setup
+     */
+
+    // This combinator should match the options passed in.
+
+    val on = LiteralChoiceTerminal("on")
+
+
+    val optionalWhitespacePrefix = OptionalWhitespacePrefix(on)
+
+    val semValid = "on"
+    val semValid2 = "\t on"
+    val invalid = "off"
+
+    val garbage = "XX"
+
+    val semValidFromOffset = "${garbage}${semValid}"
+    val semValid2FromOffset = "${garbage}${semValid2}"
+    val invalidFromOffset = "${garbage}${invalid}"
+
+    /**
+     * Execute SUT & Verification
+     */
+    var match = optionalWhitespacePrefix.SyntacticMatch(semValid, 0)
+    assertEquals(semValid.length, match.matchResult)
+    assertEquals(listOf("on"), match.tokens)
+    assertEquals(listOf("LiteralChoiceTerminal"), TerminalTypes(match.terminals))
+
+    match = optionalWhitespacePrefix.SemanticMatch(semValid, 0)
+    assertEquals(semValid.length, match.matchResult)
+    assertEquals(listOf("on"), match.tokens)
+    assertEquals(listOf("LiteralChoiceTerminal"), TerminalTypes(match.terminals))
+
+    match = optionalWhitespacePrefix.SyntacticMatch(semValid2, 0)
+    assertEquals(semValid2.length, match.matchResult)
+    assertEquals(listOf("\t ", "on"), match.tokens)
+    assertEquals(listOf("WhitespaceTerminal", "LiteralChoiceTerminal"), TerminalTypes(match.terminals))
+
+    match = optionalWhitespacePrefix.SemanticMatch(semValid2, 0)
+    assertEquals(semValid2.length, match.matchResult)
+    assertEquals(listOf("\t ", "on"), match.tokens)
+    assertEquals(listOf("WhitespaceTerminal", "LiteralChoiceTerminal"), TerminalTypes(match.terminals))
+
+    assertEquals(NoMatch, optionalWhitespacePrefix.SyntacticMatch(invalid, 0))
+    assertEquals(NoMatch, optionalWhitespacePrefix.SemanticMatch(invalid, 0))
+
+    match = optionalWhitespacePrefix.SemanticMatch(semValidFromOffset, garbage.length)
+    assertEquals(semValidFromOffset.length, match.matchResult)
+    assertEquals(listOf("on"), match.tokens)
+    assertEquals(listOf("LiteralChoiceTerminal"), TerminalTypes(match.terminals))
+
+    match = optionalWhitespacePrefix.SyntacticMatch(semValidFromOffset, garbage.length)
+    assertEquals(semValidFromOffset.length, match.matchResult)
+    assertEquals(listOf("on"), match.tokens)
+    assertEquals(listOf("LiteralChoiceTerminal"), TerminalTypes(match.terminals))
+
+    match = optionalWhitespacePrefix.SemanticMatch(semValid2FromOffset, garbage.length)
+    assertEquals(semValid2FromOffset.length, match.matchResult)
+    assertEquals(listOf("\t ", "on"), match.tokens)
+    assertEquals(listOf("WhitespaceTerminal", "LiteralChoiceTerminal"), TerminalTypes(match.terminals))
+
+    match = optionalWhitespacePrefix.SyntacticMatch(semValid2FromOffset, garbage.length)
+    assertEquals(semValid2FromOffset.length, match.matchResult)
+    assertEquals(listOf("\t ", "on"), match.tokens)
+    assertEquals(listOf("WhitespaceTerminal", "LiteralChoiceTerminal"), TerminalTypes(match.terminals))
+
+    assertEquals(NoMatch, optionalWhitespacePrefix.SemanticMatch(invalidFromOffset, garbage.length))
+    assertEquals(NoMatch, optionalWhitespacePrefix.SyntacticMatch(invalidFromOffset, garbage.length))
+  }
+
 }