func TestSimple(t *testing.T) {
solution, err := parser.ParseSolution(`D:\Projects\Sungero\Main\Kernel\src\SungeroKernel.sln`)
if err != nil {
assert.Fail(t, err.Error())
return
}
assert.Equal(t, "SungeroKernel", solution.Name)
assert.Equal(t, 38, len(solution.Projects))
project := solution.FindProjectByName("DomainAPI.Server")
assert.NotNil(t, project)
assert.Exactly(t, solution, project.Solution)
assert.Equal(t, `Kernel\DomainAPI\DomainAPI.Server\`, project.RelativeDirectory)
assert.Equal(t, `bin\Debug\`, project.DebugOutputDirectory)
assert.Equal(t, `bin\Release\`, project.GetOutputDirectory("release"))
assert.Equal(t, `Library`, project.OutputType)
assert.Nil(t, parser.ParseProject(project))
// for _, project = range solution.Projects {
// fmt.Println("****************************")
// fmt.Println(project.AssemblyName)
// for _, ref := range project.GlobalReferences {
// fmt.Println(ref.Name)
// }
// for _, ref := range project.LibReferences {
// fmt.Println(ref.Name, ref.Path)
// }
// }
}
func TestCompare(t *testing.T) {
kernel_solution, _ := parser.ParseSolution(`D:\Projects\Sungero\Main\Kernel\src\SungeroKernel.sln`)
common_solution, _ := parser.ParseSolution(`D:\Projects\Sungero\Main\Common\src\CommonLibrary.sln`)
content_solution, _ := parser.ParseSolution(`D:\Projects\Sungero\Main\Content\src\SungeroLibrary.sln`)
workflow_solution, _ := parser.ParseSolution(`D:\Projects\Sungero\Main\Workflow\src\SungeroWorkflow.sln`)
report_solution, _ := parser.ParseSolution(`D:\Projects\Sungero\Main\Report\src\SungeroReport.sln`)
assert.True(t, kernel_solution.DependsOn(common_solution))
assert.False(t, common_solution.DependsOn(kernel_solution))
assert.True(t, workflow_solution.DependsOn(kernel_solution))
assert.True(t, content_solution.DependsOn(kernel_solution))
assert.False(t, common_solution.DependsOn(workflow_solution))
assert.False(t, content_solution.DependsOn(workflow_solution))
assert.False(t, workflow_solution.DependsOn(content_solution))
assert.False(t, report_solution.DependsOn(workflow_solution))
assert.False(t, workflow_solution.DependsOn(report_solution, "Sungero.Domain.Interfaces"))
}
func main() {
log.Println("START...")
parseCommandLine()
fillSolutionPaths()
defer func() {
if originalSolutionsAliasesPath != "" {
copyFileContents(originalSolutionsAliasesPath, solutionsAliasesPath)
}
}()
log.Println(solutionsPaths)
solutions := make([]*parser.Solution, len(solutionsPaths))
buildSolutions := make([]*parser.Solution, 0, len(solutionsPaths))
for i, solutionPath := range solutionsPaths {
solution, _ := parser.ParseSolution(solutionPath)
solutions[i] = solution
if _, ok := buildSolutionPaths[solutionPath]; ok {
buildSolutions = append(buildSolutions, solution)
}
}
dependsOn := make(map[*parser.Solution]chan bool)
dependsOnCounter := make(map[*parser.Solution]int)
affectsOn := make(map[*parser.Solution][]chan bool)
for _, solution := range solutions {
dependsOn[solution] = make(chan bool, len(solutions))
dependsOnCounter[solution] = 0
affectsOn[solution] = make([]chan bool, 0, len(solutions))
}
for _, solution := range solutions {
for _, other := range buildSolutions {
if solution == other {
continue
}
if solution.DependsOn(other) {
dep, _ := dependsOn[solution]
dependsOnCounter[solution] += 1
deps, _ := affectsOn[other]
deps = append(deps, dep)
affectsOn[other] = deps
}
}
}
doneChan := make(chan bool, len(buildSolutions))
for _, solution := range buildSolutions {
go build(solution, doneChan, dependsOn[solution], dependsOnCounter[solution], affectsOn[solution], solutions)
}
for i := 0; i < len(buildSolutions); i++ {
<-doneChan
}
}