AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-17 14:30:15 +00:00
Code Issues Projects Releases Wiki Activity
fae3eaffcd
gtk/testsuite/css/parser/background-shorthand-single.ref.css

3250 lines
111 KiB
CSS
Raw Normal View History

reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
a {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
b {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
c {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
d {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
e {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
f {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
g {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
h {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
i {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
j {
background-clip: padding-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
k {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
l {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
m {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
n {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
o {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
p {
background-clip: padding-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
q {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
r {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
s {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
t {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
u {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
v {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
w {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
x {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
y {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
z {
background-clip: content-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ab {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
cb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
db {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
eb {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fb {
background-clip: content-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ib {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jb {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
kb {
background-clip: padding-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
lb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
mb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
nb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ob {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pb {
background-clip: content-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
rb {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
sb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
tb {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ub {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yb {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zb {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ac {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
cc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
dc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ec {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fc {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hc {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ic {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jc {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
kc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
lc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
mc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
nc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
oc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
rc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
sc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
tc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
uc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vc {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wc {
background-clip: padding-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zc {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ad {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bd {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
cd {
background-clip: padding-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
dd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ed {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
id {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
kd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ld {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
md {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
nd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
od {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
rd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
sd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
td {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ud {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wd {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xd {
background-clip: padding-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zd {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ae {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
be {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ce {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
de {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ee {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fe {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ge {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
he {
background-clip: padding-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ie {
background-clip: padding-box;
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
je {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ke {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
le {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
me {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ne {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
oe {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pe {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qe {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
re {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
se {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
te {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ue {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ve {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
we {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xe {
background-clip: padding-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ye {
background-clip: padding-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ze {
background-clip: padding-box;
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
af {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
cf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
df {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ef {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ff {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
if {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jf {
background-clip: content-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
kf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
lf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
mf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
nf {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
of {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pf {
background-clip: content-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
rf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
sf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
tf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
uf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zf {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ag {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
cg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
dg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
eg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ig {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jg {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
kg {
background-clip: content-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
lg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
mg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ng {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
og {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
rg {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
sg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
tg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ug {
background-clip: content-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vg {
background-clip: content-box;
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yg {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zg {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ah {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ch {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
dh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
eh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hh {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ih {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
kh {
background-clip: content-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
lh {
background-clip: content-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
mh {
background-clip: content-box;
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
nh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
oh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ph {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qh {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
rh {
background-clip: padding-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
sh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
th {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
uh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vh {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wh {
background-clip: content-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yh {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zh {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ai {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bi {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ci {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
di {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ei {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fi {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gi {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hi {
background-clip: padding-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ii {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ji {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ki {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
li {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
mi {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ni {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
oi {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pi {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qi {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ri {
background-clip: padding-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
si {
background-clip: padding-box;
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ti {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ui {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vi {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wi {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xi {
background-clip: content-box;
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yi {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zi {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
aj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
cj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
dj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ej {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hj {
background-clip: content-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ij {
background-clip: content-box;
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
kj {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
lj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
mj {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
nj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
oj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pj {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
rj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
sj {
background-clip: padding-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
tj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
uj {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xj {
background-clip: content-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zj {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: initial;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ak {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ck {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
dk {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ek {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ik {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jk {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
kk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
lk {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
mk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
nk {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ok {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
qk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
rk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
sk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
tk {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
uk {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zk {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
al {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bl {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
cl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
dl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
el {
background-clip: padding-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fl {
background-clip: padding-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
il {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jl {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
kl {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ll {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ml {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
nl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ol {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
pl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ql {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
rl {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
sl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
tl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
ul {
background-clip: content-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
vl {
background-clip: content-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
wl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
xl {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
yl {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
zl {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
am {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
bm {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
cm {
background-clip: padding-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
dm {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
em {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: content-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
fm {
background-clip: padding-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
gm {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
hm {
background-clip: content-box;
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
im {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAABmJLR0QA/wD/AP+gvaeTAAAAFUlEQVQImQXBAQEAAACAEP9PF1CpMCnkBftPnd1xAAAAAElFTkSuQmCC");
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
jm {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: padding-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
km {
background-clip: content-box;
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: content-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
lm {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-repeat: no-repeat;
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
mm {
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-clip: border-box;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
background-color: rgb(255,192,203);
tests: move background-shorthand test to background-shorthand-single And update/fix it for the new shorthand parsing, since the old test did a couple of things wrong: - it erroneously flipped background-clip and background-origin when testing - it was missing default initial values for background-size and background-position from the generated test output
2012-05-15 16:45:39 +00:00
background-image: none;
background-origin: padding-box;
background-position: left top;
background-repeat: repeat;
background-size: auto;
reftests: Add a test for 'background' It just tests all the permutations to make sure my idea for implementing random ordering actually works. It does (at least currently).
2012-01-04 20:53:01 +00:00
}
Reference in New Issue Copy Permalink