Download raw (10.2 KB)
import groovy.io.FileType
import org.apache.tools.ant.taskdefs.condition.Os
import org.gradle.api.tasks.Exec
buildscript {
repositories {
mavenCentral()
jcenter()
}
dependencies {
classpath 'com.eriwen:gradle-js-plugin:1.8.0'
classpath 'com.moowork.gradle:gradle-grunt-plugin:0.2'
}
}
apply plugin: 'js'
apply plugin: 'grunt'
repositories {
mavenCentral()
}
configurations {
rhino
}
dependencies {
rhino 'org.mozilla:rhino:1.7R4'
}
project.ext {
packageProps = new groovy.json.JsonSlurper().parseText(new File("package.json").toURL().text)
failures = 0;
rhinoTestSrc = "out/rhino-test-${packageProps.version}.js"
testSrc = 'test/less'
testOut = 'out/test'
}
task runGruntRhino(type: GruntTask) {
gruntArgs = "rhino"
}
combineJs {
dependsOn runGruntRhino
source = ["dist/less-rhino-${packageProps.version}.js", "test/rhino/test-header.js","dist/lessc-rhino-${packageProps.version}.js"]
dest = file(rhinoTestSrc)
}
task testRhino(type: AllRhinoTests) {
// dependsOn 'testRhinoBase'
dependsOn 'testRhinoBase', 'testRhinoErrors', 'testRhinoLegacy', 'testRhinoStaticUrls', 'testRhinoCompression', 'testRhinoDebugAll', 'testRhinoDebugComments', 'testRhinoDebugMediaquery', 'testRhinoNoJsError', 'testRhinoSourceMap'
}
task testRhinoBase(type: RhinoTest) {
options = [ '--strict-math=true', '--relative-urls' ]
}
task testRhinoDebugAll(type: DebugRhinoTest) {
options = [ '--strict-math=true', '--line-numbers=all' ]
testDir = 'debug' + fs
suffix = "-all"
}
task testRhinoDebugComments(type: DebugRhinoTest) {
options = [ '--strict-math=true', '--line-numbers=comments' ]
testDir = 'debug' + fs
suffix = "-comments"
}
task testRhinoDebugMediaquery(type: DebugRhinoTest) {
options = [ '--strict-math=true', '--line-numbers=mediaquery' ]
testDir = 'debug' + fs
suffix = "-mediaquery"
}
task testRhinoErrors(type: RhinoTest) {
options = [ '--strict-math=true', '--strict-units=true' ]
testDir = 'errors/'
expectErrors = true
}
task testRhinoChyby(type: RhinoTest) {
options = [ '--strict-math=true', '--strict-units=true' ]
testDir = 'chyby/'
// expectErrors = true
}
task testRhinoNoJsError(type: RhinoTest) {
options = [ '--strict-math=true', '--strict-units=true', '--no-js' ]
testDir = 'no-js-errors/'
expectErrors = true
}
task testRhinoLegacy(type: RhinoTest) {
testDir = 'legacy/'
}
task testRhinoStaticUrls(type: RhinoTest) {
options = [ '--strict-math=true', '--rootpath=folder (1)/' ]
testDir = 'static-urls/'
}
task testRhinoCompression(type: RhinoTest) {
options = [ '--compress=true' ]
testDir = 'compression/'
}
task testRhinoSourceMap(type: SourceMapRhinoTest) {
options = [ '--strict-math=true', '--strict-units=true']
testDir = 'sourcemaps/'
}
task setupTest {
dependsOn combineJs
doLast {
file(testOut).deleteDir()
}
}
task clean << {
file(rhinoTestSrc).delete()
file(testOut).deleteDir()
}
class SourceMapRhinoTest extends RhinoTest {
// helper to get the output map file
def getOutputMap(lessFile) {
def outFile = project.file(lessFile.path.replace('test/less', project.testOut).replace('.less', '.css'))
return project.file(outFile.path + ".map");
}
// callback to add SourceMap options to the options list
def postProcessOptions(options, lessFile) {
def outFile = getOutputMap(lessFile)
project.file(outFile.parent).mkdirs()
options << "--source-map=${testDir}${lessFile.name.replace('.less','.css')}"
options << "--source-map-basepath=${lessRootDir}"
options << "--source-map-rootpath=testweb/"
options << "--source-map-output-map-file=${outFile}"
options
}
// Callback to validate output
def handleResult(exec, out, lessFile) {
def actualFile = getOutputMap(lessFile)
def expectedFile = project.file(projectDir + fs + "test" + fs + testDir + fs + lessFile.name.replace(".less", ".json"))
assert actualFile.text == expectedFile.text
}
}
class DebugRhinoTest extends RhinoTest {
def escapeIt(it) {
return it.replaceAll("\\\\", "\\\\\\\\").replaceAll("/", "\\\\/").replaceAll(":", "\\\\:").replaceAll("\\.", "\\\\.");
}
def globalReplacements(input, directory) {
def pDirectory = toPlatformFs(directory)
def p = lessRootDir + fs + pDirectory
def pathimport = p + toPlatformFs("import/")
def pathesc = escapeIt(p)
def pathimportesc = escapeIt(pathimport)
def result = input.replace("{path}", p).replace("{pathesc}", pathesc).replace("{pathimport}", pathimport)
return result.replace("{pathimportesc}", pathimportesc).replace("\r\n", "\n")
}
}
class RhinoTest extends DefaultTask {
RhinoTest() {
dependsOn 'setupTest'
}
def suffix = ""
def testDir = ''
def options = []
def expectErrors = false
def fs = File.separator;
def projectDir = toUpperCaseDriveLetter(System.getProperty("user.dir"));
def lessRootDir = projectDir + fs + "test" + fs + "less"
def toUpperCaseDriveLetter(path) {
if (path.charAt(1)==':' && path.charAt(2)=='\\') {
return path.substring(0,1).toUpperCase() + path.substring(1);
}
return path;
}
def toPlatformFs(path) {
return path.replace('\\', fs).replace('/', fs);
}
def expectedCssPath(lessFilePath) {
lessFilePath.replace('.less', "${suffix}.css").replace("${fs}less${fs}", "${fs}css${fs}");
}
def globalReplacements(input, directory) {
return input;
}
def stylize(str, style) {
def styles = [
reset : [0, 0],
bold : [1, 22],
inverse : [7, 27],
underline : [4, 24],
yellow : [33, 39],
green : [32, 39],
red : [31, 39],
grey : [90, 39]
];
return '\033[' + styles[style][0] + 'm' + str +
'\033[' + styles[style][1] + 'm';
}
// Callback for subclasses to make any changes to the options
def postProcessOptions(options, lessFile) {
options
}
// Callback to validate output
def handleResult(exec, out, lessFile) {
def actual = out.toString().trim()
def actualResult = project.file(lessFile.path.replace('test/less', project.testOut).replace('.less', '.css'))
project.file(actualResult.parent).mkdirs()
actualResult << actual
def expected
if (expectErrors) {
assert exec.exitValue != 0
expected = project.file(lessFile.path.replace('.less', '.txt')).text.trim().
replace('{path}', lessFile.parent + '/').
replace('{pathhref}', '').
replace('{404status}', '')
} else {
assert exec.exitValue == 0
def expectedFile = expectedCssPath(lessFile.path)
expected = project.file(expectedFile).text.trim()
expected = globalReplacements(expected, testDir)
}
actual=actual.trim()
actual = actual.replace('\r\n', '\n')
expected = expected.replace('\r\n', '\n')
actual = actual.replace("/","\\")
expected = expected.replace("/","\\")
// println "* actual *"
// println actual
// new File("actual.txt").write(actual)
// println "* expected *"
// println expected
// new File("expected.txt").write(expected)
assert actual == expected
actualResult.delete()
}
@TaskAction
def runTest() {
int testSuccesses = 0, testFailures = 0, testErrors = 0
project.file('test/less/' + testDir).eachFileMatch(FileType.FILES, ~/.*\.less/) { lessFile ->
println "lessfile: $lessFile"
if (!project.hasProperty('test') || lessFile.name.startsWith(project.test)) {
def out = new java.io.ByteArrayOutputStream()
def processedOptions = postProcessOptions([project.rhinoTestSrc, lessFile] + options, lessFile)
def execOptions = {
main = 'org.mozilla.javascript.tools.shell.Main'
// main = 'org.mozilla.javascript.tools.debugger.Main'
classpath = project.configurations.rhino
args = processedOptions
standardOutput = out
ignoreExitValue = true
}
println "rhinoTestSrc: ${project.rhinoTestSrc}"
try {
def exec = project.javaexec(execOptions)
handleResult(exec, out, lessFile)
testSuccesses++
println stylize(' ok', 'green')
}
catch (ex) {
println ex
println()
testErrors++;
}
catch (AssertionError ae) {
println stylize(' failed', 'red')
println ae
testFailures++
}
} else {
println stylize(' skipped', 'yellow')
}
}
println stylize(testSuccesses + ' ok', 'green')
println stylize(testFailures + ' assertion failed', testFailures == 0 ? 'green' : 'red')
println stylize(testErrors + ' errors', testErrors == 0 ? 'green' : 'red')
if (testFailures != 0 || testErrors != 0) {
project.failures++;
}
}
}
class AllRhinoTests extends DefaultTask {
AllRhinoTests() {
}
@TaskAction
def runTest() {
println stylize(project.failures + ' test suites failed', project.failures == 0 ? 'green' : 'red')
}
def stylize(str, style) {
def styles = [
reset : [0, 0],
bold : [1, 22],
inverse : [7, 27],
underline : [4, 24],
yellow : [33, 39],
green : [32, 39],
red : [31, 39],
grey : [90, 39]
];
return '\033[' + styles[style][0] + 'm' + str +
'\033[' + styles[style][1] + 'm';
}
}
class GruntTask extends Exec {
private String gruntExecutable = Os.isFamily(Os.FAMILY_WINDOWS) ? "grunt.cmd" : "grunt"
private String switches = "--no-color"
String gruntArgs = ""
public GruntTask() {
super()
this.setExecutable(gruntExecutable)
}
public void setGruntArgs(String gruntArgs) {
this.args = "$switches $gruntArgs".trim().split(" ") as List
}
}