516 lines
17 KiB
Ziran
516 lines
17 KiB
Ziran
// CSS fuzz: generated and damaged sheets through the parser, the sheet, the
|
|
// formatter and the DOM export.
|
|
//
|
|
// css_fuzz CURRENT SEED COUNT FILE... COUNT cases from SEED; each FILE
|
|
// (.css) seeds damaged cases
|
|
// css_fuzz CURRENT corpus FILE... the checks on each file; one named
|
|
// *.ok.css must parse
|
|
// css_fuzz CURRENT check FILE the checks on one file
|
|
//
|
|
// Every case is checked for:
|
|
// - no abort (Ziran stops a program on an out-of-range index or cast) and,
|
|
// under the sanitizers, no memory error;
|
|
// - an end: the shell's timeout stops a parse that never finishes;
|
|
// - a failure that says what went wrong, never a partial sheet;
|
|
// - formatting that keeps meaning (CssFormat re-parses its own output), only
|
|
// moves whitespace and line ends, and is stable when run again;
|
|
// - an export that is whole or refused with a reason;
|
|
//
|
|
// Before each case the input is written to CURRENT, so when a check fails or
|
|
// the program is killed, CURRENT holds the sheet that did it.
|
|
#import "byte_text_linux"
|
|
#import "c_string"
|
|
#import "file_linux"
|
|
#import "css_parser"
|
|
#import "css_sheet"
|
|
#import "css_format"
|
|
#import "css_export"
|
|
#import "kryon/style"
|
|
#import "kryon/style_sheet"
|
|
|
|
libc :: #system_library "libc";
|
|
RawWrite :: (descriptor: s32, input: *u8, count: u64) -> s64 #foreign libc "write";
|
|
|
|
fuzz_sheet: CssSheet;
|
|
fuzz_rules: StyleRules;
|
|
fuzz_source: [65536]u8;
|
|
fuzz_length: s32 = 0;
|
|
fuzz_formatted: [262144]u8;
|
|
fuzz_again: [262144]u8;
|
|
fuzz_exported: [262144]u8;
|
|
fuzz_file: [65536]u8;
|
|
fuzz_seeds: [8][65536]u8;
|
|
fuzz_seed_lengths: [8]s32;
|
|
fuzz_seed_count: s32 = 0;
|
|
fuzz_current: string;
|
|
fuzz_random: u64 = 1;
|
|
fuzz_failed: bool = false;
|
|
fuzz_diagnostic: [256]u8;
|
|
|
|
Say :: (descriptor: s32, text: string) {
|
|
chunk: [512]u8
|
|
at: s32 = 0
|
|
while at < cast(s32)text.count {
|
|
count: s32 = cast(s32)text.count - at
|
|
if count > 512 { count = 512 }
|
|
for index: cast(s32)0..count - 1 { chunk[index] = text[at + index] }
|
|
if RawWrite(descriptor, *chunk[0], cast(u64)count) <= 0 { return }
|
|
at += count
|
|
}
|
|
}
|
|
|
|
SayNumber :: (descriptor: s32, value: s64) {
|
|
digits: [24]u8
|
|
count: s32 = 0
|
|
number: s64 = value
|
|
if number == 0 {
|
|
Say(descriptor, "0")
|
|
return
|
|
}
|
|
while number > 0 && count < 24 {
|
|
digits[23 - count] = cast(u8)(48 + number % 10)
|
|
number = number / 10
|
|
count += 1
|
|
}
|
|
Say(descriptor, TextView(digits[24 - count:24]))
|
|
}
|
|
|
|
Fail :: (message: string) {
|
|
if fuzz_failed { return }
|
|
fuzz_failed = true
|
|
Say(2, "css fuzz: ")
|
|
Say(2, message)
|
|
Say(2, "\n")
|
|
}
|
|
|
|
// ------------------------------------------------------------------ random
|
|
|
|
Next :: () -> u64 {
|
|
x: u64 = fuzz_random
|
|
x = x ^ (x << cast(u64)13)
|
|
x = x ^ (x >> cast(u64)7)
|
|
x = x ^ (x << cast(u64)17)
|
|
fuzz_random = x
|
|
return x
|
|
}
|
|
|
|
Below :: (count: s32) -> s32 {
|
|
if count <= 1 { return 0 }
|
|
return cast(s32)(Next() % cast(u64)count)
|
|
}
|
|
|
|
// ------------------------------------------------------------------ text
|
|
|
|
Add :: (text: string) {
|
|
for byte: text {
|
|
if fuzz_length < cast(s32)fuzz_source.count {
|
|
fuzz_source[fuzz_length] = byte
|
|
fuzz_length += 1
|
|
}
|
|
}
|
|
}
|
|
|
|
Pick :: (choices: []string) -> string {
|
|
return choices[Below(cast(s32)choices.count)]
|
|
}
|
|
|
|
css_selectors: [16]string = .["Button", "Text", "App", "*", "Card", ".x", ".primary", "Button.x",
|
|
"Button:hover", "Text:disabled", "Tab:selected", "Button[role=Label]", "Button[tone=Accent]:active",
|
|
"TextField:focus", "Button:loading", "Checkbox:checked"];
|
|
|
|
css_declarations: [26]string = .["color: #102030", "color: red", "color: var(--ink)",
|
|
"color: var(--missing, #fff)", "background: rgb(1 2 3 / 50%)",
|
|
"background: linear-gradient(#000000, #ffffff)", "border-color: hsl(120 50% 50%)",
|
|
"border: 1px solid red", "border-radius: 4px", "padding: 2px 4px", "padding-inline: 0.5rem",
|
|
"padding-block: var(--pad)", "gap: 3px", "font-size: 1.25rem", "font-family: \"Inter\", sans-serif",
|
|
"opacity: 0.5", "translate: 1px 2px", "outline-color: #abc", "-kryon-material: glass",
|
|
"-kryon-icon-size: 16px", "letter-spacing: 1px", "width: 20px", "margin-inline: 4px",
|
|
"transition: color 150ms", "border-width: var(--pad)", "opacity: var(--n)"];
|
|
|
|
css_definitions: [7]string = .["--ink: #123456", "--pad: 4px", "--fast: 150ms", "--alias: var(--ink)",
|
|
"--glass: glass", "--n: 0.5", "--ink: rgba(0, 0, 0, 0.5)"];
|
|
|
|
css_media: [6]string = .["(prefers-color-scheme: dark)", "(min-width: 600px)",
|
|
"(-kryon-density: compact), (pointer: coarse)", "(prefers-contrast: more)", "(-kryon-theme: ocean)",
|
|
"(prefers-reduced-motion: reduce)"];
|
|
|
|
Rule :: () {
|
|
Add(Pick(css_selectors[:]))
|
|
if Below(4) == 0 {
|
|
Add(", ")
|
|
Add(Pick(css_selectors[:]))
|
|
}
|
|
Add(" { ")
|
|
for index: cast(s32)0..Below(4) {
|
|
Add(Pick(css_declarations[:]))
|
|
Add("; ")
|
|
}
|
|
Add("}\n")
|
|
}
|
|
|
|
Root :: () {
|
|
Add(":root {\n")
|
|
for index: cast(s32)0..Below(4) {
|
|
Add(" ")
|
|
Add(Pick(css_definitions[:]))
|
|
Add(";\n")
|
|
}
|
|
Add("}\n")
|
|
}
|
|
|
|
Item :: (depth: s32) {
|
|
choice: s32 = Below(12)
|
|
if choice < 5 {
|
|
Rule()
|
|
} else if choice == 5 {
|
|
Root()
|
|
} else if choice == 6 && depth < 2 {
|
|
Add("@media ")
|
|
Add(Pick(css_media[:]))
|
|
Add(" {\n")
|
|
for index: cast(s32)0..Below(3) { Item(depth + 1) }
|
|
Add("}\n")
|
|
} else if choice == 7 && depth < 2 {
|
|
Add(ifx Below(2) == 0 then "@layer a {\n" else "@layer b {\n")
|
|
for index: cast(s32)0..Below(3) { Item(depth + 1) }
|
|
Add("}\n")
|
|
} else if choice == 8 {
|
|
Add("@layer a, b;\n")
|
|
} else if choice == 9 {
|
|
Add("@keyframes spin { from { opacity: 0; } to { opacity: 1; } }\n")
|
|
} else if choice == 10 {
|
|
Add(ifx Below(3) == 0 then "@import \"loop\";\n" else "@import \"base\";\n")
|
|
} else {
|
|
Add("/* note { } */\n")
|
|
}
|
|
}
|
|
|
|
// One random CSS sheet.
|
|
Generate :: () {
|
|
fuzz_length = 0
|
|
count: s32 = 1 + Below(10)
|
|
for index: cast(s32)0..count - 1 {
|
|
Item(0)
|
|
}
|
|
}
|
|
|
|
damage_bytes :: "{}();:,\"'/*@-.#[]=! \n%";
|
|
|
|
// Damage the sheet in place: flipped bytes, deleted, repeated or cut ranges.
|
|
Damage :: () {
|
|
rounds: s32 = 1 + Below(4)
|
|
for round: cast(s32)0..rounds - 1 {
|
|
if fuzz_length == 0 { return }
|
|
kind: s32 = Below(5)
|
|
at: s32 = Below(fuzz_length)
|
|
if kind == 0 {
|
|
fuzz_source[at] = damage_bytes[Below(cast(s32)damage_bytes.count)]
|
|
} else if kind == 1 {
|
|
span: s32 = 1 + Below(16)
|
|
if at + span > fuzz_length { span = fuzz_length - at }
|
|
for index: at..fuzz_length - span - 1 { fuzz_source[index] = fuzz_source[index + span] }
|
|
fuzz_length -= span
|
|
} else if kind == 2 {
|
|
span: s32 = 1 + Below(32)
|
|
if at + span > fuzz_length { span = fuzz_length - at }
|
|
if fuzz_length + span <= cast(s32)fuzz_source.count {
|
|
index: s32 = fuzz_length - 1
|
|
while index >= at + span {
|
|
fuzz_source[index + span] = fuzz_source[index]
|
|
index -= 1
|
|
}
|
|
fuzz_length += span
|
|
}
|
|
} else if kind == 3 {
|
|
fuzz_length = at
|
|
} else if fuzz_length < cast(s32)fuzz_source.count {
|
|
index: s32 = fuzz_length
|
|
while index > at {
|
|
fuzz_source[index] = fuzz_source[index - 1]
|
|
index -= 1
|
|
}
|
|
fuzz_source[at] = damage_bytes[Below(cast(s32)damage_bytes.count)]
|
|
fuzz_length += 1
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------ checks
|
|
|
|
FuzzImports :: (name: string) -> CssImportAnswer {
|
|
answer: CssImportAnswer
|
|
if name == "base" {
|
|
answer.found = true
|
|
answer.source = "Button { color: red; gap: 1px; }"
|
|
} else if name == "loop" {
|
|
answer.found = true
|
|
answer.source = "@import \"loop\";"
|
|
}
|
|
return answer
|
|
}
|
|
|
|
// The bytes that are not whitespace or ';', with strings and comments whole.
|
|
SameBytes :: (a: string, b: string) -> bool {
|
|
i: s32 = 0
|
|
j: s32 = 0
|
|
while true {
|
|
i = Significant(a, i)
|
|
j = Significant(b, j)
|
|
if i >= cast(s32)a.count || j >= cast(s32)b.count {
|
|
return i >= cast(s32)a.count && j >= cast(s32)b.count
|
|
}
|
|
if a[i] != b[j] { return false }
|
|
i += 1
|
|
j += 1
|
|
}
|
|
return false
|
|
}
|
|
|
|
// The next byte at or after `at` that formatting must keep. Inside strings
|
|
// and comments every byte counts; the caller walks them in step.
|
|
Significant :: (text: string, at: s32) -> s32 {
|
|
index: s32 = at
|
|
while index < cast(s32)text.count {
|
|
byte: u8 = text[index]
|
|
if byte == 32 || byte == 9 || byte == 10 || byte == 13 || byte == 12 || byte == #char ";" {
|
|
index += 1
|
|
continue
|
|
}
|
|
return index
|
|
}
|
|
return index
|
|
}
|
|
|
|
// Strings and comments must come through byte for byte; the formatter only
|
|
// collapses space between tokens, so compare those runs exactly.
|
|
SameQuoted :: (a: string, b: string) -> bool {
|
|
ra: s32 = 0
|
|
rb: s32 = 0
|
|
while true {
|
|
sa: s32 = NextQuoted(a, ra)
|
|
sb: s32 = NextQuoted(b, rb)
|
|
if sa < 0 || sb < 0 { return sa < 0 && sb < 0 }
|
|
ea: s32 = QuotedEnd(a, sa)
|
|
eb: s32 = QuotedEnd(b, sb)
|
|
if a[sa:ea] != b[sb:eb] { return false }
|
|
ra = ea
|
|
rb = eb
|
|
}
|
|
return false
|
|
}
|
|
|
|
NextQuoted :: (text: string, at: s32) -> s32 {
|
|
index: s32 = at
|
|
while index < cast(s32)text.count {
|
|
byte: u8 = text[index]
|
|
if byte == #char "\"" || byte == #char "'" { return index }
|
|
if byte == #char "/" && index + 1 < cast(s32)text.count && text[index + 1] == #char "*" { return index }
|
|
index += 1
|
|
}
|
|
return -1
|
|
}
|
|
|
|
QuotedEnd :: (text: string, start: s32) -> s32 {
|
|
count: s32 = cast(s32)text.count
|
|
if text[start] == #char "/" {
|
|
index: s32 = start + 2
|
|
while index + 1 < count && !(text[index] == #char "*" && text[index + 1] == #char "/") { index += 1 }
|
|
return ifx index + 2 <= count then index + 2 else count
|
|
}
|
|
index: s32 = start + 1
|
|
while index < count && text[index] != text[start] && text[index] != 10 { index += 1 }
|
|
return ifx index < count then index + 1 else count
|
|
}
|
|
|
|
EmptyImports :: (name: string) -> CssImportAnswer {
|
|
answer: CssImportAnswer
|
|
answer.found = true
|
|
answer.source = ""
|
|
return answer
|
|
}
|
|
|
|
CheckCss :: (source: string, must_parse: bool) {
|
|
// The sheet, with imports.
|
|
CssSheetReset(*fuzz_sheet)
|
|
if CssSheetParse(*fuzz_sheet, source, "fuzz.css", FuzzImports) {
|
|
for theme: cast(s32)0..1 {
|
|
env: CssEnvironment = CssEnvironmentWithNames(CssDefaultEnvironment(),
|
|
ifx theme == 1 then "dark" else "light", "", "", "", "")
|
|
if !CssSheetBuild(*fuzz_sheet, env, null, *fuzz_rules) &&
|
|
CssSheetDiagnostic(*fuzz_sheet, fuzz_diagnostic[:]).count == 0 {
|
|
Fail("a build failed without a diagnostic")
|
|
}
|
|
}
|
|
} else if CssSheetDiagnostic(*fuzz_sheet, fuzz_diagnostic[:]).count == 0 {
|
|
Fail("a parse failed without a diagnostic")
|
|
}
|
|
CssSheetReset(*fuzz_sheet)
|
|
if !CssSheetParseWithDiagnostics(*fuzz_sheet, source, "fuzz.css", FuzzImports, CssDiagnostics.{}) &&
|
|
CssSheetDiagnostic(*fuzz_sheet, fuzz_diagnostic[:]).count == 0 {
|
|
Fail("a recovering parse failed without a diagnostic")
|
|
}
|
|
// The formatter answers imports with empty sheets.
|
|
CssSheetReset(*fuzz_sheet)
|
|
parses: bool = CssSheetParse(*fuzz_sheet, source, "fuzz.css", EmptyImports)
|
|
if must_parse && !parses {
|
|
Say(2, " parser: ")
|
|
Say(2, CssSheetDiagnostic(*fuzz_sheet, fuzz_diagnostic[:]))
|
|
Say(2, "\n")
|
|
Fail("a sheet that must parse did not")
|
|
}
|
|
formatted: CssFormatResult = CssFormat(source, fuzz_formatted[:])
|
|
if !formatted.ok {
|
|
message: string = TextView(formatted.diagnostic[:formatted.diagnostic_length])
|
|
if message.count == 0 { Fail("formatting failed without a diagnostic") }
|
|
if parses {
|
|
Say(2, " formatter: ")
|
|
Say(2, message)
|
|
Say(2, "\n")
|
|
Fail("a sheet that parses did not format")
|
|
}
|
|
} else {
|
|
if !parses { Fail("a sheet that does not parse was formatted") }
|
|
output: string = TextView(fuzz_formatted[:formatted.count])
|
|
if !SameBytes(source, output) { Fail("formatting changed more than whitespace") }
|
|
if !SameQuoted(source, output) { Fail("formatting changed a string or comment") }
|
|
again: CssFormatResult = CssFormat(output, fuzz_again[:])
|
|
if !again.ok || TextView(fuzz_again[:again.count]) != output { Fail("formatting is not stable") }
|
|
}
|
|
// The export, for both schemes.
|
|
for theme: cast(s32)0..1 {
|
|
env: CssEnvironment = CssEnvironmentWithNames(CssDefaultEnvironment(),
|
|
ifx theme == 1 then "dark" else "light", "", "", "", "")
|
|
exported: CSSExport = ExportCSS(source, "fuzz.css", env, fuzz_exported[:])
|
|
if exported.ok {
|
|
if exported.count < 0 || exported.count > cast(s32)fuzz_exported.count { Fail("export count out of range") }
|
|
} else if exported.error_length == 0 {
|
|
Fail("an export failed without a reason")
|
|
}
|
|
}
|
|
}
|
|
|
|
SaveCurrent :: (source: string) {
|
|
file: FileHandle = OpenReplace(fuzz_current)
|
|
if !file.valid { return }
|
|
copy: [65536]u8
|
|
count: s32 = cast(s32)source.count
|
|
if count > 65536 { count = 65536 }
|
|
for index: cast(s32)0..count - 1 { copy[index] = source[index] }
|
|
unused WriteAt(file, copy[:count], 0)
|
|
CloseFile(file)
|
|
}
|
|
|
|
Case :: (source: string, must_parse: bool) -> bool {
|
|
SaveCurrent(source)
|
|
CheckCss(source, must_parse)
|
|
return !fuzz_failed
|
|
}
|
|
|
|
EndsWith :: (text: string, tail: string) -> bool {
|
|
if tail.count > text.count { return false }
|
|
return text[cast(s32)(text.count - tail.count):] == tail
|
|
}
|
|
|
|
ReadInto :: (path: string, output: []u8) -> s32 {
|
|
file: FileHandle = OpenRead(path)
|
|
if !file.valid { return -1 }
|
|
read: s64 = ReadAt(file, output, 0)
|
|
CloseFile(file)
|
|
if read < 0 || read >= cast(s64)output.count { return -1 }
|
|
return cast(s32)read
|
|
}
|
|
|
|
Argument :: (argv: **s8, index: s32) -> string {
|
|
return TextFromCString(cast(*u8)argv[index])
|
|
}
|
|
|
|
ParseCount :: (text: string) -> s64 {
|
|
value: s64 = 0
|
|
for byte: text {
|
|
if byte < #char "0" || byte > #char "9" { return -1 }
|
|
value = value * 10 + cast(s64)(byte - #char "0")
|
|
}
|
|
return value
|
|
}
|
|
|
|
#program_export
|
|
main :: (argc: s32, argv: **s8) -> s32 {
|
|
if argc < 4 {
|
|
Say(2, "usage: css_fuzz CURRENT SEED COUNT FILE... | CURRENT corpus FILE... | CURRENT check FILE\n")
|
|
return 2
|
|
}
|
|
fuzz_current = Argument(argv, 1)
|
|
mode: string = Argument(argv, 2)
|
|
if mode == "corpus" || mode == "check" {
|
|
for index: cast(s32)3..argc - 1 {
|
|
path: string = Argument(argv, index)
|
|
count: s32 = ReadInto(path, fuzz_file[:])
|
|
if count < 0 {
|
|
Say(2, "css fuzz: cannot read ")
|
|
Say(2, path)
|
|
Say(2, "\n")
|
|
return 1
|
|
}
|
|
ok: bool = EndsWith(path, ".ok.css")
|
|
if !Case(TextView(fuzz_file[:count]), ok) {
|
|
Say(2, " in ")
|
|
Say(2, path)
|
|
Say(2, "\n")
|
|
return 1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
seed: s64 = ParseCount(mode)
|
|
total: s64 = ParseCount(Argument(argv, 3))
|
|
if seed < 0 || total < 0 {
|
|
Say(2, "css fuzz: SEED and COUNT are numbers\n")
|
|
return 2
|
|
}
|
|
fuzz_random = cast(u64)seed * cast(u64)2654435761 + cast(u64)1
|
|
for index: cast(s32)4..argc - 1 {
|
|
if fuzz_seed_count >= 8 { break }
|
|
path: string = Argument(argv, index)
|
|
count: s32 = ReadInto(path, fuzz_seeds[fuzz_seed_count][:])
|
|
if count < 0 { continue }
|
|
fuzz_seed_lengths[fuzz_seed_count] = count
|
|
fuzz_seed_count += 1
|
|
}
|
|
for case_index: cast(s64)0..total - 1 {
|
|
kind: s32 = Below(8)
|
|
if kind < 3 || fuzz_seed_count == 0 {
|
|
Generate()
|
|
if Below(2) == 0 { Damage() }
|
|
} else {
|
|
seed_index: s32 = Below(fuzz_seed_count)
|
|
// A slice of a seed file, damaged.
|
|
length: s32 = fuzz_seed_lengths[seed_index]
|
|
start: s32 = ifx Below(2) == 0 then 0 else Below(length)
|
|
span: s32 = length - start
|
|
if span > 6000 { span = 1 + Below(6000) }
|
|
fuzz_length = 0
|
|
for at: start..start + span - 1 {
|
|
if fuzz_length < cast(s32)fuzz_source.count {
|
|
fuzz_source[fuzz_length] = fuzz_seeds[seed_index][at]
|
|
fuzz_length += 1
|
|
}
|
|
}
|
|
Damage()
|
|
}
|
|
if !Case(TextView(fuzz_source[:fuzz_length]), false) {
|
|
Say(2, " CSS case ")
|
|
SayNumber(2, case_index)
|
|
Say(2, " of seed ")
|
|
SayNumber(2, seed)
|
|
Say(2, "\n")
|
|
return 1
|
|
}
|
|
}
|
|
Say(1, "css fuzz: ")
|
|
SayNumber(1, total)
|
|
Say(1, " cases from seed ")
|
|
SayNumber(1, seed)
|
|
Say(1, " passed\n")
|
|
return 0
|
|
}
|