./middleware/logger.go has the most surviving mutants (10)—consider strengthening the tests covering that file.Tests with lower scores are weaker and may benefit from strengthened assertions or additional coverage of edge cases.
flawd handoff after a report
to generate context-rich prompts for your coding agent (Claude Code, Cursor, Copilot, etc.).
Use flawd handoff --install-skill to install a slash command that lets your agent
automatically fix surviving mutants with better assertions and edge case handling.
14 tests analyzed, all above 50% kill rate
| Test | Sites Covered | Killed | Survived | Score |
|---|---|---|---|---|
| ./middleware/client_ip_example_test.go | 217 | 183 | 34 | 84% |
| ./middleware/realip_test.go | 108 | 103 | 5 | 95% |
| ./middleware/sunset_test.go | 108 | 103 | 5 | 95% |
| ./middleware/url_format_test.go | 108 | 103 | 5 | 95% |
| ./middleware/throttle_test.go | 108 | 103 | 5 | 95% |
| ./middleware/client_ip_test.go | 108 | 103 | 5 | 95% |
| ./middleware/compress_test.go | 108 | 103 | 5 | 95% |
| ./middleware/content_charset_test.go | 108 | 103 | 5 | 95% |
| ./middleware/recoverer_test.go | 108 | 103 | 5 | 95% |
| ./middleware/request_id_test.go | 108 | 103 | 5 | 95% |
| ./middleware/content_type_test.go | 108 | 103 | 5 | 95% |
| ./middleware/strip_test.go | 108 | 103 | 5 | 95% |
| ./middleware/get_head_test.go | 108 | 103 | 5 | 95% |
| ./middleware/content_encoding_test.go | 108 | 103 | 5 | 95% |
Groups of 2+ surviving mutants in the same function and operator family — these concentrated clusters signal particularly weak spots that are more likely to harbor real bugs than isolated survivors.
| Count | File | Function | Family | Lines |
|---|---|---|---|---|
| 10 | ./middleware/logger.go | — | logical | 110, 117, 124, 142, 144, 146, 148, 157, 159, 174 |
| 5 | ./middleware/wrap_writer.go | — | logical | 31, 34, 39, 83, 84 |
| 3 | ./middleware/recoverer.go | — | logical | 126, 144, 193 |
| 2 | ./middleware/clean_path.go | — | logical | 17, 18 |
| 2 | ./mux.go | — | logical | 235, 338 |
| 2 | ./tree.go | — | logical | 478, 566 |
Complete list of every mutant tested, with status, source file, operator, and diff. Use the filters below to drill into specific files, test files, or statuses.
| Status | File | Operator | Runtime | Diff |
|---|---|---|---|---|
| KilledSyntacticTargeted (14) | ./chain.go | boolean_negation | 4.58s | Show diff-len(middlewares) == 0 +!(len(middlewares) == 0) Original
len(middlewares) == 0
Mutated
!(len(middlewares) == 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./chain.go | comparison_flip | 2.21s | Show diff->= +> Original
>=
Mutated
>
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./chain.go | comparison_flip | 2.29s | Show diff->= +< Original
>=
Mutated
<
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./context.go | boolean_negation | 4.91s | Show diff-rctx != nil +!(rctx != nil) Original
rctx != nil
Mutated
!(rctx != nil)
Covering Tests 14
...and 4 more
|
| SurvivedSyntacticTargeted (14)Weak Assertion | ./context.go | return_value | 28.74s | Show diff-"" +"mutated" Original
""
Mutated
"mutated"
Covering Tests 14
...and 4 more
Testing Gap
Tests do not distinguish `""` from `"mutated"` at ./context.go:14. Return value mutations show that tests check whether a function returns *something* but not the *exact* value
Suggested Fix
Assert the precise return value rather than just truthiness or presence
|
| KilledSyntacticTargeted (14) | ./context.go | boolean_negation | 12.04s | Show diff-x.URLParams.Keys[k] == key +!(x.URLParams.Keys[k] == key) Original
x.URLParams.Keys[k] == key
Mutated
!(x.URLParams.Keys[k] == key)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./context.go | boolean_negation | 32.72s | Show diff-x == nil +!(x == nil) Original
x == nil
Mutated
!(x == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./context.go | boolean_negation | 29.36s | Show diff-routePattern != "/" +!(routePattern != "/") Original
routePattern != "/"
Mutated
!(routePattern != "/")
Covering Tests 14
...and 4 more
|
| TimeoutSyntacticTargeted (14) | ./context.go | boolean_negation | 62.18s | Show diff-strings.Contains(p, "/*/") +!(strings.Contains(p, "/*/")) Original
strings.Contains(p, "/*/")
Mutated
!(strings.Contains(p, "/*/"))
Covering Tests 14
...and 4 more
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/clean_path.go | boolean_negation | 32.17s | Show diff-routePath == "" +!(routePath == "") Original
routePath == ""
Mutated
!(routePath == "")
Covering Tests 1
Testing Gap
Tests do not distinguish `routePath == ""` from `!(routePath == "")` at ./middleware/clean_path.go:17. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/clean_path.go | boolean_negation | 540ms | Show diff-r.URL.RawPath != "" +!(r.URL.RawPath != "") Original
r.URL.RawPath != ""
Mutated
!(r.URL.RawPath != "")
Covering Tests 1
Testing Gap
Tests do not distinguish `r.URL.RawPath != ""` from `!(r.URL.RawPath != "")` at ./middleware/clean_path.go:18. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | comparison_flip | 1.66s | Show diff-> +>= Original
>
Mutated
>=
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | comparison_flip | 747ms | Show diff-> +<= Original
>
Mutated
<=
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | return_value | 745ms | Show diff-true +false Original
true
Mutated
false
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 765ms | Show diff-inAnyPrefix(ip, prefixes) +!(inAnyPrefix(ip, prefixes)) Original
inAnyPrefix(ip, prefixes)
Mutated
!(inAnyPrefix(ip, prefixes))
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | return_value | 1.15s | Show diff-false +true Original
false
Mutated
true
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 923ms | Show diff-found.IsValid() +!(found.IsValid()) Original
found.IsValid()
Mutated
!(found.IsValid())
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | comparison_flip | 824ms | Show diff-< +<= Original
<
Mutated
<=
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | comparison_flip | 830ms | Show diff-< +>= Original
<
Mutated
>=
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 742ms | Show diff-n == 0 +!(n == 0) Original
n == 0
Mutated
!(n == 0)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 799ms | Show diff-entry != "" +!(entry != "") Original
entry != ""
Mutated
!(entry != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 768ms | Show diff-err == nil +!(err == nil) Original
err == nil
Mutated
!(err == nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 782ms | Show diff-!ip.IsValid() +ip.IsValid() Original
!ip.IsValid()
Mutated
ip.IsValid()
Covering Tests 1
|
| TimeoutSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 62.11s | Show diff-h != "" +!(h != "") Original
h != ""
Mutated
!(h != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 737ms | Show diff-i >= 0 +!(i >= 0) Original
i >= 0
Mutated
!(i >= 0)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 780ms | Show diff-v == "" +!(v == "") Original
v == ""
Mutated
!(v == "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 775ms | Show diff-visit(v) +!(visit(v)) Original
visit(v)
Mutated
!(visit(v))
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 749ms | Show diff-p.Contains(ip) +!(p.Contains(ip)) Original
p.Contains(ip)
Mutated
!(p.Contains(ip))
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 1.22s | Show diff-len(types) > 0 +!(len(types) > 0) Original
len(types) > 0
Mutated
!(len(types) > 0)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 836ms | Show diff-strings.Contains(strings.TrimSuffix(t, "/*"), "*") +!(strings.Contains(strings.TrimSuffix(t, "/*"), "*")) Original
strings.Contains(strings.TrimSuffix(t, "/*"), "*")
Mutated
!(strings.Contains(strings.TrimSuffix(t, "/*"), "*"))
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 842ms | Show diff-encoding == "" +!(encoding == "") Original
encoding == ""
Mutated
!(encoding == "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 755ms | Show diff-fn == nil +!(fn == nil) Original
fn == nil
Mutated
!(fn == nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 771ms | Show diff-v == encoding +!(v == encoding) Original
v == encoding
Mutated
!(v == encoding)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 915ms | Show diff-encoder != nil +!(encoder != nil) Original
encoder != nil
Mutated
!(encoder != nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 1.11s | Show diff-matchAcceptEncoding(accepted, name) +!(matchAcceptEncoding(accepted, name)) Original
matchAcceptEncoding(accepted, name)
Mutated
!(matchAcceptEncoding(accepted, name))
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 905ms | Show diff-strings.Contains(v, encoding) +!(strings.Contains(v, encoding)) Original
strings.Contains(v, encoding)
Mutated
!(strings.Contains(v, encoding))
Covering Tests 1
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/compress.go | boolean_negation | 26.88s | Show diff-hadSlash +!(hadSlash) Original
hadSlash
Mutated
!(hadSlash)
Covering Tests 1
Testing Gap
Tests do not distinguish `hadSlash` from `!(hadSlash)` at ./middleware/compress.go:285. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 882ms | Show diff-cw.wroteHeader +!(cw.wroteHeader) Original
cw.wroteHeader
Mutated
!(cw.wroteHeader)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 954ms | Show diff-cw.Header().Get("Content-Encoding") != "" +!(cw.Header().Get("Content-Encoding") != "") Original
cw.Header().Get("Content-Encoding") != ""
Mutated
!(cw.Header().Get("Content-Encoding") != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 1.12s | Show diff-!cw.isCompressible() +cw.isCompressible() Original
!cw.isCompressible()
Mutated
cw.isCompressible()
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 1.15s | Show diff-cw.encoding != "" +!(cw.encoding != "") Original
cw.encoding != ""
Mutated
!(cw.encoding != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 1.07s | Show diff-!cw.wroteHeader +cw.wroteHeader Original
!cw.wroteHeader
Mutated
cw.wroteHeader
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/compress.go | boolean_negation | 1.28s | Show diff-cw.compressible +!(cw.compressible) Original
cw.compressible
Mutated
!(cw.compressible)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/content_charset.go | boolean_negation | 27.80s | Show diff-!contentEncoding(r.Header.Get("Content-Type"), charsets...) +contentEncoding(r.Header.Get("Content-Type"), charsets...) Original
!contentEncoding(r.Header.Get("Content-Type"), charsets...)
Mutated
contentEncoding(r.Header.Get("Content-Type"), charsets...)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/content_charset.go | boolean_negation | 27.21s | Show diff-found +!(found) Original
found
Mutated
!(found)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/content_encoding.go | boolean_negation | 27.57s | Show diff-r.ContentLength == 0 +!(r.ContentLength == 0) Original
r.ContentLength == 0
Mutated
!(r.ContentLength == 0)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/get_head.go | boolean_negation | 5.46s | Show diff-r.Method == "HEAD" +!(r.Method == "HEAD") Original
r.Method == "HEAD"
Mutated
!(r.Method == "HEAD")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/get_head.go | boolean_negation | 2.60s | Show diff-!rctx.Routes.Match(tctx, "HEAD", routePath) +rctx.Routes.Match(tctx, "HEAD", routePath) Original
!rctx.Routes.Match(tctx, "HEAD", routePath)
Mutated
rctx.Routes.Match(tctx, "HEAD", routePath)
Covering Tests 1
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/heartbeat.go | boolean_negation | 28.75s | Show diff-(r.Method == "GET" || r.Method == "HEAD") && strings.EqualFold(r.URL.Path, endpoint) +!((r.Method == "GET" || r.Method == "HEAD") && strings.EqualFold(r.URL.Path, endpoint)) Original
(r.Method == "GET" || r.Method == "HEAD") && strings.EqualFold(r.URL.Path, endpoint)
Mutated
!((r.Method == "GET" || r.Method == "HEAD") && strings.EqualFold(r.URL.Path, endpoint))
Covering Tests 1
Testing Gap
Tests do not distinguish `(r.Method == "GET" || r.Method == "HEAD") && strings.EqualFold(r.URL.Path, endpoint)` from `!((r.Method == "GET" || r.Method == "HEAD") && strings.EqualFold(r.URL.Path, endpoint))` at ./middleware/heartbeat.go:15. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 29.84s | Show diff-reqID != "" +!(reqID != "") Original
reqID != ""
Mutated
!(reqID != "")
Covering Tests 1
Testing Gap
Tests do not distinguish `reqID != ""` from `!(reqID != "")` at ./middleware/logger.go:110. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 27.00s | Show diff-r.TLS != nil +!(r.TLS != nil) Original
r.TLS != nil
Mutated
!(r.TLS != nil)
Covering Tests 1
Testing Gap
Tests do not distinguish `r.TLS != nil` from `!(r.TLS != nil)` at ./middleware/logger.go:117. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 26.95s | Show diff-clientIP == "" +!(clientIP == "") Original
clientIP == ""
Mutated
!(clientIP == "")
Covering Tests 1
Testing Gap
Tests do not distinguish `clientIP == ""` from `!(clientIP == "")` at ./middleware/logger.go:124. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 27.12s | Show diff-status < 200 +!(status < 200) Original
status < 200
Mutated
!(status < 200)
Covering Tests 1
Testing Gap
Tests do not distinguish `status < 200` from `!(status < 200)` at ./middleware/logger.go:142. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 27.87s | Show diff-status < 300 +!(status < 300) Original
status < 300
Mutated
!(status < 300)
Covering Tests 1
Testing Gap
Tests do not distinguish `status < 300` from `!(status < 300)` at ./middleware/logger.go:144. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 26.87s | Show diff-status < 400 +!(status < 400) Original
status < 400
Mutated
!(status < 400)
Covering Tests 1
Testing Gap
Tests do not distinguish `status < 400` from `!(status < 400)` at ./middleware/logger.go:146. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 27.20s | Show diff-status < 500 +!(status < 500) Original
status < 500
Mutated
!(status < 500)
Covering Tests 1
Testing Gap
Tests do not distinguish `status < 500` from `!(status < 500)` at ./middleware/logger.go:148. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 27.19s | Show diff-elapsed < 500*time.Millisecond +!(elapsed < 500*time.Millisecond) Original
elapsed < 500*time.Millisecond
Mutated
!(elapsed < 500*time.Millisecond)
Covering Tests 1
Testing Gap
Tests do not distinguish `elapsed < 500*time.Millisecond` from `!(elapsed < 500*time.Millisecond)` at ./middleware/logger.go:157. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 27.18s | Show diff-elapsed < 5*time.Second +!(elapsed < 5*time.Second) Original
elapsed < 5*time.Second
Mutated
!(elapsed < 5*time.Second)
Covering Tests 1
Testing Gap
Tests do not distinguish `elapsed < 5*time.Second` from `!(elapsed < 5*time.Second)` at ./middleware/logger.go:159. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/logger.go | boolean_negation | 27.25s | Show diff-runtime.GOOS == "windows" +!(runtime.GOOS == "windows") Original
runtime.GOOS == "windows"
Mutated
!(runtime.GOOS == "windows")
Covering Tests 1
Testing Gap
Tests do not distinguish `runtime.GOOS == "windows"` from `!(runtime.GOOS == "windows")` at ./middleware/logger.go:174. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/maybe.go | boolean_negation | 27.50s | Show diff-maybeFn(r) +!(maybeFn(r)) Original
maybeFn(r)
Mutated
!(maybeFn(r))
Covering Tests 1
Testing Gap
Tests do not distinguish `maybeFn(r)` from `!(maybeFn(r))` at ./middleware/maybe.go:11. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/nocache.go | boolean_negation | 27.97s | Show diff-r.Header.Get(v) != "" +!(r.Header.Get(v) != "") Original
r.Header.Get(v) != ""
Mutated
!(r.Header.Get(v) != "")
Covering Tests 1
Testing Gap
Tests do not distinguish `r.Header.Get(v) != ""` from `!(r.Header.Get(v) != "")` at ./middleware/nocache.go:45. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/page_route.go | boolean_negation | 1.27s | Show diff-r.Method == "GET" && strings.EqualFold(r.URL.Path, path) +!(r.Method == "GET" && strings.EqualFold(r.URL.Path, path)) Original
r.Method == "GET" && strings.EqualFold(r.URL.Path, path)
Mutated
!(r.Method == "GET" && strings.EqualFold(r.URL.Path, path))
Covering Tests 1
Testing Gap
Tests do not distinguish `r.Method == "GET" && strings.EqualFold(r.URL.Path, path)` from `!(r.Method == "GET" && strings.EqualFold(r.URL.Path, path))` at ./middleware/page_route.go:13. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/realip.go | boolean_negation | 1.81s | Show diff-rip != "" +!(rip != "") Original
rip != ""
Mutated
!(rip != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/realip.go | boolean_negation | 1.19s | Show diff-tcip != "" +!(tcip != "") Original
tcip != ""
Mutated
!(tcip != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/realip.go | boolean_negation | 1.19s | Show diff-xrip != "" +!(xrip != "") Original
xrip != ""
Mutated
!(xrip != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/realip.go | boolean_negation | 1.22s | Show diff-xff != "" +!(xff != "") Original
xff != ""
Mutated
!(xff != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/realip.go | boolean_negation | 1.12s | Show diff-ip == "" || net.ParseIP(ip) == nil +!(ip == "" || net.ParseIP(ip) == nil) Original
ip == "" || net.ParseIP(ip) == nil
Mutated
!(ip == "" || net.ParseIP(ip) == nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/recoverer.go | boolean_negation | 3.61s | Show diff-rvr != nil +!(rvr != nil) Original
rvr != nil
Mutated
!(rvr != nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/recoverer.go | boolean_negation | 1.41s | Show diff-rvr == http.ErrAbortHandler +!(rvr == http.ErrAbortHandler) Original
rvr == http.ErrAbortHandler
Mutated
!(rvr == http.ErrAbortHandler)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/recoverer.go | boolean_negation | 1.75s | Show diff-logEntry != nil +!(logEntry != nil) Original
logEntry != nil
Mutated
!(logEntry != nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/recoverer.go | boolean_negation | 1.81s | Show diff-r.Header.Get("Connection") != "Upgrade" +!(r.Header.Get("Connection") != "Upgrade") Original
r.Header.Get("Connection") != "Upgrade"
Mutated
!(r.Header.Get("Connection") != "Upgrade")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/recoverer.go | boolean_negation | 1.40s | Show diff-strings.HasPrefix(stack[i], "panic(") +!(strings.HasPrefix(stack[i], "panic(")) Original
strings.HasPrefix(stack[i], "panic(")
Mutated
!(strings.HasPrefix(stack[i], "panic("))
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/recoverer.go | boolean_negation | 1.91s | Show diff-strings.HasPrefix(line, "\t") || strings.Contains(line, ".go:") +!(strings.HasPrefix(line, "\t") || strings.Contains(line, ".go:")) Original
strings.HasPrefix(line, "\t") || strings.Contains(line, ".go:")
Mutated
!(strings.HasPrefix(line, "\t") || strings.Contains(line, ".go:"))
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/recoverer.go | boolean_negation | 1.70s | Show diff-strings.HasSuffix(line, ")") +!(strings.HasSuffix(line, ")")) Original
strings.HasSuffix(line, ")")
Mutated
!(strings.HasSuffix(line, ")"))
Covering Tests 1
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/recoverer.go | boolean_negation | 27.56s | Show diff-strings.HasPrefix(line, "\t") +!(strings.HasPrefix(line, "\t")) Original
strings.HasPrefix(line, "\t")
Mutated
!(strings.HasPrefix(line, "\t"))
Covering Tests 1
Testing Gap
Tests do not distinguish `strings.HasPrefix(line, "\t")` from `!(strings.HasPrefix(line, "\t"))` at ./middleware/recoverer.go:126. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/recoverer.go | boolean_negation | 905ms | Show diff-idx < 0 +!(idx < 0) Original
idx < 0
Mutated
!(idx < 0)
Covering Tests 1
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/recoverer.go | boolean_negation | 27.05s | Show diff-idx > 0 +!(idx > 0) Original
idx > 0
Mutated
!(idx > 0)
Covering Tests 1
Testing Gap
Tests do not distinguish `idx > 0` from `!(idx > 0)` at ./middleware/recoverer.go:144. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/recoverer.go | boolean_negation | 847ms | Show diff-num == 0 +!(num == 0) Original
num == 0
Mutated
!(num == 0)
Covering Tests 1
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/recoverer.go | boolean_negation | 26.96s | Show diff-num == 1 +!(num == 1) Original
num == 1
Mutated
!(num == 1)
Covering Tests 1
Testing Gap
Tests do not distinguish `num == 1` from `!(num == 1)` at ./middleware/recoverer.go:193. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/request_id.go | boolean_negation | 27.91s | Show diff-hostname == "" || err != nil +!(hostname == "" || err != nil) Original
hostname == "" || err != nil
Mutated
!(hostname == "" || err != nil)
Covering Tests 1
Testing Gap
Tests do not distinguish `hostname == "" || err != nil` from `!(hostname == "" || err != nil)` at ./middleware/request_id.go:48. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/request_id.go | boolean_negation | 1.17s | Show diff-len(b64) < 10 +!(len(b64) < 10) Original
len(b64) < 10
Mutated
!(len(b64) < 10)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/request_id.go | boolean_negation | 1.25s | Show diff-requestID == "" +!(requestID == "") Original
requestID == ""
Mutated
!(requestID == "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/request_id.go | boolean_negation | 1.18s | Show diff-ctx == nil +!(ctx == nil) Original
ctx == nil
Mutated
!(ctx == nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/route_headers.go | boolean_negation | 1.87s | Show diff-k == nil +!(k == nil) Original
k == nil
Mutated
!(k == nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/route_headers.go | boolean_negation | 1.10s | Show diff-len(hr) == 0 +!(len(hr) == 0) Original
len(hr) == 0
Mutated
!(len(hr) == 0)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/route_headers.go | boolean_negation | 967ms | Show diff-headerValue == "" +!(headerValue == "") Original
headerValue == ""
Mutated
!(headerValue == "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/route_headers.go | boolean_negation | 1.52s | Show diff-matcher.IsMatch(headerValue) +!(matcher.IsMatch(headerValue)) Original
matcher.IsMatch(headerValue)
Mutated
!(matcher.IsMatch(headerValue))
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/route_headers.go | boolean_negation | 1.31s | Show diff-len(r.MatchAny) > 0 +!(len(r.MatchAny) > 0) Original
len(r.MatchAny) > 0
Mutated
!(len(r.MatchAny) > 0)
Covering Tests 1
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/route_headers.go | boolean_negation | 27.34s | Show diff-m.Match(value) +!(m.Match(value)) Original
m.Match(value)
Mutated
!(m.Match(value))
Covering Tests 1
Testing Gap
Tests do not distinguish `m.Match(value)` from `!(m.Match(value))` at ./middleware/route_headers.go:119. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/route_headers.go | boolean_negation | 942ms | Show diff-r.MatchOne.Match(value) +!(r.MatchOne.Match(value)) Original
r.MatchOne.Match(value)
Mutated
!(r.MatchOne.Match(value))
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/route_headers.go | boolean_negation | 1.04s | Show diff-!p.wildcard +p.wildcard Original
!p.wildcard
Mutated
p.wildcard
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/strip.go | boolean_negation | 1.92s | Show diff-rctx != nil && rctx.RoutePath != "" +!(rctx != nil && rctx.RoutePath != "") Original
rctx != nil && rctx.RoutePath != ""
Mutated
!(rctx != nil && rctx.RoutePath != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/strip.go | boolean_negation | 1.34s | Show diff-len(path) > 1 && path[len(path)-1] == '/' +!(len(path) > 1 && path[len(path)-1] == '/') Original
len(path) > 1 && path[len(path)-1] == '/'
Mutated
!(len(path) > 1 && path[len(path)-1] == '/')
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/strip.go | boolean_negation | 1.28s | Show diff-rctx == nil +!(rctx == nil) Original
rctx == nil
Mutated
!(rctx == nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/strip.go | boolean_negation | 1.25s | Show diff-r.URL.RawQuery != "" +!(r.URL.RawQuery != "") Original
r.URL.RawQuery != ""
Mutated
!(r.URL.RawQuery != "")
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/sunset.go | boolean_negation | 2.33s | Show diff-!sunsetAt.IsZero() +sunsetAt.IsZero() Original
!sunsetAt.IsZero()
Mutated
sunsetAt.IsZero()
Covering Tests 1
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/supress_notfound.go | boolean_negation | 28.02s | Show diff-!match +match Original
!match
Mutated
match
Covering Tests 1
Testing Gap
Tests do not distinguish `!match` from `match` at ./middleware/supress_notfound.go:20. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/terminal.go | boolean_negation | 1.29s | Show diff-IsTTY && useColor +!(IsTTY && useColor) Original
IsTTY && useColor
Mutated
!(IsTTY && useColor)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/throttle.go | boolean_negation | 2.94s | Show diff-opts.Limit < 1 +!(opts.Limit < 1) Original
opts.Limit < 1
Mutated
!(opts.Limit < 1)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/throttle.go | boolean_negation | 1.83s | Show diff-opts.BacklogLimit < 0 +!(opts.BacklogLimit < 0) Original
opts.BacklogLimit < 0
Mutated
!(opts.BacklogLimit < 0)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/throttle.go | boolean_negation | 21.56s | Show diff-statusCode == 0 +!(statusCode == 0) Original
statusCode == 0
Mutated
!(statusCode == 0)
Covering Tests 1
|
| TimeoutSyntacticTargeted (1) | ./middleware/throttle.go | boolean_negation | 62.05s | Show diff-i < opts.Limit +!(i < opts.Limit) Original
i < opts.Limit
Mutated
!(i < opts.Limit)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/throttle.go | boolean_negation | 19.93s | Show diff-t.retryAfterFn == nil +!(t.retryAfterFn == nil) Original
t.retryAfterFn == nil
Mutated
!(t.retryAfterFn == nil)
Covering Tests 1
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/timeout.go | boolean_negation | 27.97s | Show diff-ctx.Err() == context.DeadlineExceeded +!(ctx.Err() == context.DeadlineExceeded) Original
ctx.Err() == context.DeadlineExceeded
Mutated
!(ctx.Err() == context.DeadlineExceeded)
Covering Tests 1
Testing Gap
Tests do not distinguish `ctx.Err() == context.DeadlineExceeded` from `!(ctx.Err() == context.DeadlineExceeded)` at ./middleware/timeout.go:38. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/url_format.go | boolean_negation | 28.57s | Show diff-strings.Index(path, ".") > 0 +!(strings.Index(path, ".") > 0) Original
strings.Index(path, ".") > 0
Mutated
!(strings.Index(path, ".") > 0)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/wrap_writer.go | boolean_negation | 2.24s | Show diff-protoMajor == 2 +!(protoMajor == 2) Original
protoMajor == 2
Mutated
!(protoMajor == 2)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/wrap_writer.go | boolean_negation | 1.20s | Show diff-fl && ps +!(fl && ps) Original
fl && ps
Mutated
!(fl && ps)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/wrap_writer.go | boolean_negation | 1.05s | Show diff-fl && hj && rf +!(fl && hj && rf) Original
fl && hj && rf
Mutated
!(fl && hj && rf)
Covering Tests 1
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/wrap_writer.go | boolean_negation | 27.01s | Show diff-fl && hj +!(fl && hj) Original
fl && hj
Mutated
!(fl && hj)
Covering Tests 1
Testing Gap
Tests do not distinguish `fl && hj` from `!(fl && hj)` at ./middleware/wrap_writer.go:31. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/wrap_writer.go | boolean_negation | 27.10s | Show diff-hj +!(hj) Original
hj
Mutated
!(hj)
Covering Tests 1
Testing Gap
Tests do not distinguish `hj` from `!(hj)` at ./middleware/wrap_writer.go:34. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/wrap_writer.go | boolean_negation | 27.26s | Show diff-fl +!(fl) Original
fl
Mutated
!(fl)
Covering Tests 1
Testing Gap
Tests do not distinguish `fl` from `!(fl)` at ./middleware/wrap_writer.go:39. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/wrap_writer.go | boolean_negation | 27.23s | Show diff-code >= 100 && code <= 199 && code != http.StatusSwitchingProtocols +!(code >= 100 && code <= 199 && code != http.StatusSwitchingProtocols) Original
code >= 100 && code <= 199 && code != http.StatusSwitchingProtocols
Mutated
!(code >= 100 && code <= 199 && code != http.StatusSwitchingProtocols)
Covering Tests 1
Testing Gap
Tests do not distinguish `code >= 100 && code <= 199 && code != http.StatusSwitchingProtocols` from `!(code >= 100 && code <= 199 && code != http.StatusSwitchingProtocols)` at ./middleware/wrap_writer.go:83. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| SurvivedSyntacticTargeted (1)Weak AssertionMedium Risk | ./middleware/wrap_writer.go | boolean_negation | 27.13s | Show diff-!b.discard +b.discard Original
!b.discard
Mutated
b.discard
Covering Tests 1
Testing Gap
Tests do not distinguish `!b.discard` from `b.discard` at ./middleware/wrap_writer.go:84. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (1) | ./middleware/wrap_writer.go | boolean_negation | 828ms | Show diff-!b.wroteHeader +b.wroteHeader Original
!b.wroteHeader
Mutated
b.wroteHeader
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/wrap_writer.go | boolean_negation | 758ms | Show diff-b.tee != nil +!(b.tee != nil) Original
b.tee != nil
Mutated
!(b.tee != nil)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/wrap_writer.go | boolean_negation | 26.98s | Show diff-f.basicWriter.tee != nil || f.basicWriter.discard +!(f.basicWriter.tee != nil || f.basicWriter.discard) Original
f.basicWriter.tee != nil || f.basicWriter.discard
Mutated
!(f.basicWriter.tee != nil || f.basicWriter.discard)
Covering Tests 1
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 1.95s | Show diff-mx.handler == nil +!(mx.handler == nil) Original
mx.handler == nil
Mutated
!(mx.handler == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 1.07s | Show diff-mx.handler != nil +!(mx.handler != nil) Original
mx.handler != nil
Mutated
!(mx.handler != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 1.23s | Show diff-mx.inline && mx.parent != nil +!(mx.inline && mx.parent != nil) Original
mx.inline && mx.parent != nil
Mutated
!(mx.inline && mx.parent != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 27.20s | Show diff-subMux.notFoundHandler == nil +!(subMux.notFoundHandler == nil) Original
subMux.notFoundHandler == nil
Mutated
!(subMux.notFoundHandler == nil)
Covering Tests 14
...and 4 more
|
| SurvivedSyntacticTargeted (14)Weak AssertionMedium Risk | ./mux.go | boolean_negation | 27.25s | Show diff-subMux.methodNotAllowedHandler == nil +!(subMux.methodNotAllowedHandler == nil) Original
subMux.methodNotAllowedHandler == nil
Mutated
!(subMux.methodNotAllowedHandler == nil)
Covering Tests 14
...and 4 more
Testing Gap
Tests do not distinguish `subMux.methodNotAllowedHandler == nil` from `!(subMux.methodNotAllowedHandler == nil)` at ./mux.go:235. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 29.34s | Show diff-mx.inline +!(mx.inline) Original
mx.inline
Mutated
!(mx.inline)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 29.20s | Show diff-fn != nil +!(fn != nil) Original
fn != nil
Mutated
!(fn != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 6.44s | Show diff-handler == nil +!(handler == nil) Original
handler == nil
Mutated
!(handler == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 6.29s | Show diff-mx.tree.findPattern(pattern+"*") || mx.tree.findPattern(pattern+"/*") +!(mx.tree.findPattern(pattern+"*") || mx.tree.findPattern(pattern+"/*")) Original
mx.tree.findPattern(pattern+"*") || mx.tree.findPattern(pattern+"/*")
Mutated
!(mx.tree.findPattern(pattern+"*") || mx.tree.findPattern(pattern+"/*"))
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 30.15s | Show diff-ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil +!(ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil) Original
ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil
Mutated
!(ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 29.37s | Show diff-ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil +!(ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil) Original
ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil
Mutated
!(ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 5.71s | Show diff-n >= 0 && rctx.URLParams.Keys[n] == "*" && len(rctx.URLParams.Values) > n +!(n >= 0 && rctx.URLParams.Keys[n] == "*" && len(rctx.URLParams.Values) > n) Original
n >= 0 && rctx.URLParams.Keys[n] == "*" && len(rctx.URLParams.Values) > n
Mutated
!(n >= 0 && rctx.URLParams.Keys[n] == "*" && len(rctx.URLParams.Values) > n)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 5.39s | Show diff-pattern == "" || pattern[len(pattern)-1] != '/' +!(pattern == "" || pattern[len(pattern)-1] != '/') Original
pattern == "" || pattern[len(pattern)-1] != '/'
Mutated
!(pattern == "" || pattern[len(pattern)-1] != '/')
Covering Tests 14
...and 4 more
|
| SurvivedSyntacticTargeted (14)Weak AssertionMedium Risk | ./mux.go | boolean_negation | 29.33s | Show diff-subroutes != nil +!(subroutes != nil) Original
subroutes != nil
Mutated
!(subroutes != nil)
Covering Tests 14
...and 4 more
Testing Gap
Tests do not distinguish `subroutes != nil` from `!(subroutes != nil)` at ./mux.go:338. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 7.67s | Show diff-node != nil +!(node != nil) Original
node != nil
Mutated
!(node != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 10.76s | Show diff-node.subroutes == nil +!(node.subroutes == nil) Original
node.subroutes == nil
Mutated
!(node.subroutes == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 6.84s | Show diff-subPattern == "" +!(subPattern == "") Original
subPattern == ""
Mutated
!(subPattern == "")
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 5.41s | Show diff-mx.notFoundHandler != nil +!(mx.notFoundHandler != nil) Original
mx.notFoundHandler != nil
Mutated
!(mx.notFoundHandler != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 29.21s | Show diff-mx.methodNotAllowedHandler != nil +!(mx.methodNotAllowedHandler != nil) Original
mx.methodNotAllowedHandler != nil
Mutated
!(mx.methodNotAllowedHandler != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 5.38s | Show diff-len(pattern) == 0 || pattern[0] != '/' +!(len(pattern) == 0 || pattern[0] != '/') Original
len(pattern) == 0 || pattern[0] != '/'
Mutated
!(len(pattern) == 0 || pattern[0] != '/')
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 5.49s | Show diff-rctx.RouteMethod == "" +!(rctx.RouteMethod == "") Original
rctx.RouteMethod == ""
Mutated
!(rctx.RouteMethod == "")
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 5.46s | Show diff-h != nil +!(h != nil) Original
h != nil
Mutated
!(h != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 5.50s | Show diff-rctx.methodNotAllowed +!(rctx.methodNotAllowed) Original
rctx.methodNotAllowed
Mutated
!(rctx.methodNotAllowed)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./mux.go | boolean_negation | 5.41s | Show diff-nx >= 0 && rctx.routeParams.Keys[nx] == "*" && len(rctx.routeParams.Values) > nx +!(nx >= 0 && rctx.routeParams.Keys[nx] == "*" && len(rctx.routeParams.Values) > nx) Original
nx >= 0 && rctx.routeParams.Keys[nx] == "*" && len(rctx.routeParams.Values) > nx
Mutated
!(nx >= 0 && rctx.routeParams.Keys[nx] == "*" && len(rctx.routeParams.Values) > nx)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 396ms | Show diff-method == "" +!(method == "") Original
method == ""
Mutated
!(method == "")
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 390ms | Show diff-n > strconv.IntSize-2 +!(n > strconv.IntSize-2) Original
n > strconv.IntSize-2
Mutated
!(n > strconv.IntSize-2)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 388ms | Show diff-len(search) == 0 +!(len(search) == 0) Original
len(search) == 0
Mutated
!(len(search) == 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 414ms | Show diff-label == '{' || label == '*' +!(label == '{' || label == '*') Original
label == '{' || label == '*'
Mutated
!(label == '{' || label == '*')
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 394ms | Show diff-segTyp == ntRegexp +!(segTyp == ntRegexp) Original
segTyp == ntRegexp
Mutated
!(segTyp == ntRegexp)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 429ms | Show diff-n == nil +!(n == nil) Original
n == nil
Mutated
!(n == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 384ms | Show diff-n.typ > ntStatic +!(n.typ > ntStatic) Original
n.typ > ntStatic
Mutated
!(n.typ > ntStatic)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 331ms | Show diff-commonPrefix == len(n.prefix) +!(commonPrefix == len(n.prefix)) Original
commonPrefix == len(n.prefix)
Mutated
!(commonPrefix == len(n.prefix))
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 326ms | Show diff-segStartIdx == 0 +!(segStartIdx == 0) Original
segStartIdx == 0
Mutated
!(segStartIdx == 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 323ms | Show diff-segTyp == ntCatchAll +!(segTyp == ntCatchAll) Original
segTyp == ntCatchAll
Mutated
!(segTyp == ntCatchAll)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 334ms | Show diff-segStartIdx < 0 +!(segStartIdx < 0) Original
segStartIdx < 0
Mutated
!(segStartIdx < 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 401ms | Show diff-segStartIdx != len(search) +!(segStartIdx != len(search)) Original
segStartIdx != len(search)
Mutated
!(segStartIdx != len(search))
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 310ms | Show diff-segStartIdx > 0 +!(segStartIdx > 0) Original
segStartIdx > 0
Mutated
!(segStartIdx > 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 404ms | Show diff-n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail +!(n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail) Original
n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail
Mutated
!(n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 305ms | Show diff-nds[i].label == label && nds[i].tail == tail +!(nds[i].label == label && nds[i].tail == tail) Original
nds[i].label == label && nds[i].tail == tail
Mutated
!(nds[i].label == label && nds[i].tail == tail)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 396ms | Show diff-ntyp == ntRegexp && nds[i].prefix != prefix +!(ntyp == ntRegexp && nds[i].prefix != prefix) Original
ntyp == ntRegexp && nds[i].prefix != prefix
Mutated
!(ntyp == ntRegexp && nds[i].prefix != prefix)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 303ms | Show diff-n.endpoints == nil +!(n.endpoints == nil) Original
n.endpoints == nil
Mutated
!(n.endpoints == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 335ms | Show diff-method&mSTUB == mSTUB +!(method&mSTUB == mSTUB) Original
method&mSTUB == mSTUB
Mutated
!(method&mSTUB == mSTUB)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 323ms | Show diff-method&mALL == mALL +!(method&mALL == mALL) Original
method&mALL == mALL
Mutated
!(method&mALL == mALL)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 327ms | Show diff-rn == nil +!(rn == nil) Original
rn == nil
Mutated
!(rn == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 358ms | Show diff-rn.endpoints[method].pattern != "" +!(rn.endpoints[method].pattern != "") Original
rn.endpoints[method].pattern != ""
Mutated
!(rn.endpoints[method].pattern != "")
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 314ms | Show diff-len(nds) == 0 +!(len(nds) == 0) Original
len(nds) == 0
Mutated
!(len(nds) == 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 339ms | Show diff-search != "" +!(search != "") Original
search != ""
Mutated
!(search != "")
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 403ms | Show diff-xn == nil || !strings.HasPrefix(xsearch, xn.prefix) +!(xn == nil || !strings.HasPrefix(xsearch, xn.prefix)) Original
xn == nil || !strings.HasPrefix(xsearch, xn.prefix)
Mutated
!(xn == nil || !strings.HasPrefix(xsearch, xn.prefix))
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 406ms | Show diff-xsearch == "" +!(xsearch == "") Original
xsearch == ""
Mutated
!(xsearch == "")
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 389ms | Show diff-p < 0 +!(p < 0) Original
p < 0
Mutated
!(p < 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 367ms | Show diff-xn.tail == '/' +!(xn.tail == '/') Original
xn.tail == '/'
Mutated
!(xn.tail == '/')
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 378ms | Show diff-ntyp == ntRegexp && p == 0 +!(ntyp == ntRegexp && p == 0) Original
ntyp == ntRegexp && p == 0
Mutated
!(ntyp == ntRegexp && p == 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 467ms | Show diff-ntyp == ntRegexp && xn.rex != nil +!(ntyp == ntRegexp && xn.rex != nil) Original
ntyp == ntRegexp && xn.rex != nil
Mutated
!(ntyp == ntRegexp && xn.rex != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 392ms | Show diff-!xn.rex.MatchString(xsearch[:p]) +xn.rex.MatchString(xsearch[:p]) Original
!xn.rex.MatchString(xsearch[:p])
Mutated
xn.rex.MatchString(xsearch[:p])
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 417ms | Show diff-strings.IndexByte(xsearch[:p], '/') != -1 +!(strings.IndexByte(xsearch[:p], '/') != -1) Original
strings.IndexByte(xsearch[:p], '/') != -1
Mutated
!(strings.IndexByte(xsearch[:p], '/') != -1)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 287ms | Show diff-len(xsearch) == 0 +!(len(xsearch) == 0) Original
len(xsearch) == 0
Mutated
!(len(xsearch) == 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 302ms | Show diff-xn.isLeaf() +!(xn.isLeaf()) Original
xn.isLeaf()
Mutated
!(xn.isLeaf())
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 296ms | Show diff-h != nil && h.handler != nil +!(h != nil && h.handler != nil) Original
h != nil && h.handler != nil
Mutated
!(h != nil && h.handler != nil)
Covering Tests 14
...and 4 more
|
| SurvivedSyntacticTargeted (14)Weak AssertionMedium Risk | ./tree.go | boolean_negation | 329ms | Show diff-endpoints == mALL || endpoints == mSTUB +!(endpoints == mALL || endpoints == mSTUB) Original
endpoints == mALL || endpoints == mSTUB
Mutated
!(endpoints == mALL || endpoints == mSTUB)
Covering Tests 14
...and 4 more
Testing Gap
Tests do not distinguish `endpoints == mALL || endpoints == mSTUB` from `!(endpoints == mALL || endpoints == mSTUB)` at ./tree.go:478. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 324ms | Show diff-fin != nil +!(fin != nil) Original
fin != nil
Mutated
!(fin != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 242ms | Show diff-xn == nil +!(xn == nil) Original
xn == nil
Mutated
!(xn == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 360ms | Show diff-xn.typ > ntStatic +!(xn.typ > ntStatic) Original
xn.typ > ntStatic
Mutated
!(xn.typ > ntStatic)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 221ms | Show diff-len(rctx.routeParams.Values) > 0 +!(len(rctx.routeParams.Values) > 0) Original
len(rctx.routeParams.Values) > 0
Mutated
!(len(rctx.routeParams.Values) > 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 233ms | Show diff-i <= j +!(i <= j) Original
i <= j
Mutated
!(i <= j)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 306ms | Show diff-label > nds[idx].label +!(label > nds[idx].label) Original
label > nds[idx].label
Mutated
!(label > nds[idx].label)
Covering Tests 14
...and 4 more
|
| SurvivedSyntacticTargeted (14)Weak AssertionMedium Risk | ./tree.go | boolean_negation | 274ms | Show diff-label < nds[idx].label +!(label < nds[idx].label) Original
label < nds[idx].label
Mutated
!(label < nds[idx].label)
Covering Tests 14
...and 4 more
Testing Gap
Tests do not distinguish `label < nds[idx].label` from `!(label < nds[idx].label)` at ./tree.go:566. Boolean negation mutations show that tests do not exercise both branches of a conditional, leaving one path untested
Suggested Fix
Add a test that exercises the negated branch, ensuring both true and false paths produce distinct, verified outcomes
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 355ms | Show diff-nds[idx].label != label +!(nds[idx].label != label) Original
nds[idx].label != label
Mutated
!(nds[idx].label != label)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 295ms | Show diff-idx < len(n.prefix) +!(idx < len(n.prefix)) Original
idx < len(n.prefix)
Mutated
!(idx < len(n.prefix))
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 221ms | Show diff-len(xpattern) == 0 +!(len(xpattern) == 0) Original
len(xpattern) == 0
Mutated
!(len(xpattern) == 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 284ms | Show diff-eps[mSTUB] != nil && eps[mSTUB].handler != nil && subroutes == nil +!(eps[mSTUB] != nil && eps[mSTUB].handler != nil && subroutes == nil) Original
eps[mSTUB] != nil && eps[mSTUB].handler != nil && subroutes == nil
Mutated
!(eps[mSTUB] != nil && eps[mSTUB].handler != nil && subroutes == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 249ms | Show diff-h.pattern == "" +!(h.pattern == "") Original
h.pattern == ""
Mutated
!(h.pattern == "")
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 380ms | Show diff-mh[mALL] != nil && mh[mALL].handler != nil +!(mh[mALL] != nil && mh[mALL].handler != nil) Original
mh[mALL] != nil && mh[mALL].handler != nil
Mutated
!(mh[mALL] != nil && mh[mALL].handler != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 222ms | Show diff-h.handler == nil +!(h.handler == nil) Original
h.handler == nil
Mutated
!(h.handler == nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 278ms | Show diff-(n.endpoints != nil || n.subroutes != nil) && fn(n.endpoints, n.subroutes) +!((n.endpoints != nil || n.subroutes != nil) && fn(n.endpoints, n.subroutes)) Original
(n.endpoints != nil || n.subroutes != nil) && fn(n.endpoints, n.subroutes)
Mutated
!((n.endpoints != nil || n.subroutes != nil) && fn(n.endpoints, n.subroutes))
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 208ms | Show diff-cn.walk(fn) +!(cn.walk(fn)) Original
cn.walk(fn)
Mutated
!(cn.walk(fn))
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 289ms | Show diff-ps < 0 && ws < 0 +!(ps < 0 && ws < 0) Original
ps < 0 && ws < 0
Mutated
!(ps < 0 && ws < 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | return_value | 240ms | Show diff-0 +-1 Original
0
Mutated
-1
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 291ms | Show diff-ps >= 0 && ws >= 0 && ws < ps +!(ps >= 0 && ws >= 0 && ws < ps) Original
ps >= 0 && ws >= 0 && ws < ps
Mutated
!(ps >= 0 && ws >= 0 && ws < ps)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 276ms | Show diff-ps >= 0 +!(ps >= 0) Original
ps >= 0
Mutated
!(ps >= 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 290ms | Show diff-c == '{' +!(c == '{') Original
c == '{'
Mutated
!(c == '{')
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 253ms | Show diff-c == '}' +!(c == '}') Original
c == '}'
Mutated
!(c == '}')
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 337ms | Show diff-cc == 0 +!(cc == 0) Original
cc == 0
Mutated
!(cc == 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 291ms | Show diff-pe == ps +!(pe == ps) Original
pe == ps
Mutated
!(pe == ps)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 455ms | Show diff-pe < len(pattern) +!(pe < len(pattern)) Original
pe < len(pattern)
Mutated
!(pe < len(pattern))
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 359ms | Show diff-isRegexp +!(isRegexp) Original
isRegexp
Mutated
!(isRegexp)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 407ms | Show diff-len(rexpat) > 0 +!(len(rexpat) > 0) Original
len(rexpat) > 0
Mutated
!(len(rexpat) > 0)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 380ms | Show diff-rexpat[0] != '^' +!(rexpat[0] != '^') Original
rexpat[0] != '^'
Mutated
!(rexpat[0] != '^')
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 381ms | Show diff-rexpat[len(rexpat)-1] != '$' +!(rexpat[len(rexpat)-1] != '$') Original
rexpat[len(rexpat)-1] != '$'
Mutated
!(rexpat[len(rexpat)-1] != '$')
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 400ms | Show diff-ws < len(pattern)-1 +!(ws < len(pattern)-1) Original
ws < len(pattern)-1
Mutated
!(ws < len(pattern)-1)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | return_value | 376ms | Show diff-"*" +"" Original
"*"
Mutated
""
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 447ms | Show diff-ptyp == ntStatic +!(ptyp == ntStatic) Original
ptyp == ntStatic
Mutated
!(ptyp == ntStatic)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 396ms | Show diff-paramKeys[i] == paramKey +!(paramKeys[i] == paramKey) Original
paramKeys[i] == paramKey
Mutated
!(paramKeys[i] == paramKey)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 338ms | Show diff-k1[i] != k2[i] +!(k1[i] != k2[i]) Original
k1[i] != k2[i]
Mutated
!(k1[i] != k2[i])
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 409ms | Show diff-ns[i].typ > ntStatic && ns[i].tail == '/' +!(ns[i].typ > ntStatic && ns[i].tail == '/') Original
ns[i].typ > ntStatic && ns[i].tail == '/'
Mutated
!(ns[i].typ > ntStatic && ns[i].tail == '/')
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 296ms | Show diff-label > ns[idx].label +!(label > ns[idx].label) Original
label > ns[idx].label
Mutated
!(label > ns[idx].label)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 352ms | Show diff-label < ns[idx].label +!(label < ns[idx].label) Original
label < ns[idx].label
Mutated
!(label < ns[idx].label)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 383ms | Show diff-ns[idx].label != label +!(ns[idx].label != label) Original
ns[idx].label != label
Mutated
!(ns[idx].label != label)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 384ms | Show diff-route.SubRoutes != nil +!(route.SubRoutes != nil) Original
route.SubRoutes != nil
Mutated
!(route.SubRoutes != nil)
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (14) | ./tree.go | boolean_negation | 449ms | Show diff-method == "*" +!(method == "*") Original
method == "*"
Mutated
!(method == "*")
Covering Tests 14
...and 4 more
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 1.29s | Show diff-len(values) > 0 +!(len(values) > 0) Original
len(values) > 0
Mutated
!(len(values) > 0)
Covering Tests 1
|
| KilledSyntacticTargeted (1) | ./middleware/client_ip.go | boolean_negation | 1.65s | Show diff-numTrustedProxies < 1 +!(numTrustedProxies < 1) Original
numTrustedProxies < 1
Mutated
!(numTrustedProxies < 1)
Covering Tests 1
|