Quelle  microfactory_test.go   Sprache: unbekannt

// Copyright 2017 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package microfactory

import (
 "flag"
 "io/ioutil"
 "os"
 "path/filepath"
 "reflect"
 "runtime"
 "testing"
 "time"
)

func TestSimplePackagePathMap(t *testing.T) {
 t.Parallel()

 pkgMap := pkgPathMappingVar{&Config{}}
 flags := flag.NewFlagSet("", flag.ContinueOnError)
 flags.Var(&pkgMap, "m", "")
 err := flags.Parse([]string{
  "-m", "android/soong=build/soong/",
  "-m", "github.com/google/blueprint/=build/blueprint",
 })
 if err != nil {
  t.Fatal(err)
 }

 compare := func(got, want interface{}) {
  if !reflect.DeepEqual(got, want) {
   t.Errorf("Unexpected values in .pkgs:\nwant: %v\n got: %v",
    want, got)
  }
 }

 wantPkgs := []string{"android/soong", "github.com/google/blueprint"}
 compare(pkgMap.pkgs, wantPkgs)
 compare(pkgMap.paths[wantPkgs[0]], "build/soong")
 compare(pkgMap.paths[wantPkgs[1]], "build/blueprint")

 got, ok, err := pkgMap.Path("android/soong/ui/test")
 if err != nil {
  t.Error("Unexpected error in pkgMap.Path(soong):", err)
 } else if !ok {
  t.Error("Expected a result from pkgMap.Path(soong)")
 } else {
  compare(got, "build/soong/ui/test")
 }

 got, ok, err = pkgMap.Path("github.com/google/blueprint")
 if err != nil {
  t.Error("Unexpected error in pkgMap.Path(blueprint):", err)
 } else if !ok {
  t.Error("Expected a result from pkgMap.Path(blueprint)")
 } else {
  compare(got, "build/blueprint")
 }
}

func TestBadPackagePathMap(t *testing.T) {
 t.Parallel()

 pkgMap := pkgPathMappingVar{&Config{}}
 if _, _, err := pkgMap.Path("testing"); err == nil {
  t.Error("Expected error if no maps are specified")
 }
 if err := pkgMap.Set(""); err == nil {
  t.Error("Expected error with blank argument, but none returned")
 }
 if err := pkgMap.Set("a=a"); err != nil {
  t.Errorf("Unexpected error: %v", err)
 }
 if err := pkgMap.Set("a=b"); err == nil {
  t.Error("Expected error with duplicate package prefix, but none returned")
 }
 if _, ok, err := pkgMap.Path("testing"); err != nil {
  t.Errorf("Unexpected error: %v", err)
 } else if ok {
  t.Error("Expected testing to be consider in the stdlib")
 }
}

// TestSingleBuild ensures that just a basic build works.
func TestSingleBuild(t *testing.T) {
 t.Parallel()

 setupDir(t, func(config *Config, dir string, loadPkg loadPkgFunc) {
  // The output binary
  out := filepath.Join(dir, "out", "test")

  pkg := loadPkg()

  if err := pkg.Compile(config, filepath.Join(dir, "out")); err != nil {
   t.Fatal("Got error when compiling:", err)
  }

  if err := pkg.Link(config, out); err != nil {
   t.Fatal("Got error when linking:", err)
  }

  if _, err := os.Stat(out); err != nil {
   t.Error("Cannot stat output:", err)
  }
 })
}

// testBuildAgain triggers two builds, running the modify function in between
// each build. It verifies that the second build did or did not actually need
// to rebuild anything based on the shouldRebuild argument.
func testBuildAgain(t *testing.T,
 shouldRecompile, shouldRelink bool,
 modify func(config *Config, dir string, loadPkg loadPkgFunc),
 after func(pkg *GoPackage)) {

 t.Parallel()

 setupDir(t, func(config *Config, dir string, loadPkg loadPkgFunc) {
  // The output binary
  out := filepath.Join(dir, "out", "test")

  pkg := loadPkg()

  if err := pkg.Compile(config, filepath.Join(dir, "out")); err != nil {
   t.Fatal("Got error when compiling:", err)
  }

  if err := pkg.Link(config, out); err != nil {
   t.Fatal("Got error when linking:", err)
  }

  var firstTime time.Time
  if stat, err := os.Stat(out); err == nil {
   firstTime = stat.ModTime()
  } else {
   t.Fatal("Failed to stat output file:", err)
  }

  // mtime on HFS+ (the filesystem on darwin) are stored with 1
  // second granularity, so the timestamp checks will fail unless
  // we wait at least a second. Sleeping 1.1s to be safe.
  if runtime.GOOS == "darwin" {
   time.Sleep(1100 * time.Millisecond)
  }

  modify(config, dir, loadPkg)

  pkg = loadPkg()

  if err := pkg.Compile(config, filepath.Join(dir, "out")); err != nil {
   t.Fatal("Got error when compiling:", err)
  }
  if shouldRecompile {
   if !pkg.rebuilt {
    t.Fatal("Package should have recompiled, but was not recompiled.")
   }
  } else {
   if pkg.rebuilt {
    t.Fatal("Package should not have needed to be recompiled, but was recompiled.")
   }
  }

  if err := pkg.Link(config, out); err != nil {
   t.Fatal("Got error while linking:", err)
  }
  if shouldRelink {
   if !pkg.rebuilt {
    t.Error("Package should have relinked, but was not relinked.")
   }
  } else {
   if pkg.rebuilt {
    t.Error("Package should not have needed to be relinked, but was relinked.")
   }
  }

  if stat, err := os.Stat(out); err == nil {
   if shouldRelink {
    if stat.ModTime() == firstTime {
     t.Error("Output timestamp should be different, but both were", firstTime)
    }
   } else {
    if stat.ModTime() != firstTime {
     t.Error("Output timestamp should be the same.")
     t.Error(" first:", firstTime)
     t.Error("second:", stat.ModTime())
    }
   }
  } else {
   t.Fatal("Failed to stat output file:", err)
  }

  after(pkg)
 })
}

// TestRebuildAfterNoChanges ensures that we don't rebuild if nothing
// changes
func TestRebuildAfterNoChanges(t *testing.T) {
 testBuildAgain(t, false, false, func(config *Config, dir string, loadPkg loadPkgFunc) {}, func(pkg *GoPackage) {})
}

// TestRebuildAfterTimestamp ensures that we don't rebuild because
// timestamps of important files have changed. We should only rebuild if the
// content hashes are different.
func TestRebuildAfterTimestampChange(t *testing.T) {
 testBuildAgain(t, false, false, func(config *Config, dir string, loadPkg loadPkgFunc) {
  // Ensure that we've spent some amount of time asleep
  time.Sleep(100 * time.Millisecond)

  newTime := time.Now().Local()
  os.Chtimes(filepath.Join(dir, "test.fact"), newTime, newTime)
  os.Chtimes(filepath.Join(dir, "main/main.go"), newTime, newTime)
  os.Chtimes(filepath.Join(dir, "a/a.go"), newTime, newTime)
  os.Chtimes(filepath.Join(dir, "a/b.go"), newTime, newTime)
  os.Chtimes(filepath.Join(dir, "b/a.go"), newTime, newTime)
 }, func(pkg *GoPackage) {})
}

// TestRebuildAfterGoChange ensures that we rebuild after a content change
// to a package's go file.
func TestRebuildAfterGoChange(t *testing.T) {
 testBuildAgain(t, true, true, func(config *Config, dir string, loadPkg loadPkgFunc) {
  if err := ioutil.WriteFile(filepath.Join(dir, "a", "a.go"), []byte(go_a_a+"\n"), 0666); err != nil {
   t.Fatal("Error writing a/a.go:", err)
  }
 }, func(pkg *GoPackage) {
  if !pkg.directDeps[0].rebuilt {
   t.Fatal("android/soong/a should have rebuilt")
  }
  if !pkg.directDeps[1].rebuilt {
   t.Fatal("android/soong/b should have rebuilt")
  }
 })
}

// TestRebuildAfterMainChange ensures that we don't rebuild any dependencies
// if only the main package's go files are touched.
func TestRebuildAfterMainChange(t *testing.T) {
 testBuildAgain(t, true, true, func(config *Config, dir string, loadPkg loadPkgFunc) {
  if err := ioutil.WriteFile(filepath.Join(dir, "main", "main.go"), []byte(go_main_main+"\n"), 0666); err != nil {
   t.Fatal("Error writing main/main.go:", err)
  }
 }, func(pkg *GoPackage) {
  if pkg.directDeps[0].rebuilt {
   t.Fatal("android/soong/a should not have rebuilt")
  }
  if pkg.directDeps[1].rebuilt {
   t.Fatal("android/soong/b should not have rebuilt")
  }
 })
}

// TestRebuildAfterRemoveOut ensures that we rebuild if the output file is
// missing, even if everything else doesn't need rebuilding.
func TestRebuildAfterRemoveOut(t *testing.T) {
 testBuildAgain(t, false, true, func(config *Config, dir string, loadPkg loadPkgFunc) {
  if err := os.Remove(filepath.Join(dir, "out", "test")); err != nil {
   t.Fatal("Failed to remove output:", err)
  }
 }, func(pkg *GoPackage) {})
}

// TestRebuildAfterPartialBuild ensures that even if the build was interrupted
// between the recompile and relink stages, we'll still relink when we run again.
func TestRebuildAfterPartialBuild(t *testing.T) {
 testBuildAgain(t, false, true, func(config *Config, dir string, loadPkg loadPkgFunc) {
  if err := ioutil.WriteFile(filepath.Join(dir, "main", "main.go"), []byte(go_main_main+"\n"), 0666); err != nil {
   t.Fatal("Error writing main/main.go:", err)
  }

  pkg := loadPkg()

  if err := pkg.Compile(config, filepath.Join(dir, "out")); err != nil {
   t.Fatal("Got error when compiling:", err)
  }
  if !pkg.rebuilt {
   t.Fatal("Package should have recompiled, but was not recompiled.")
  }
 }, func(pkg *GoPackage) {})
}

// BenchmarkInitialBuild computes how long a clean build takes (for tiny test
// inputs).
func BenchmarkInitialBuild(b *testing.B) {
 for i := 0; i < b.N; i++ {
  setupDir(b, func(config *Config, dir string, loadPkg loadPkgFunc) {
   pkg := loadPkg()
   if err := pkg.Compile(config, filepath.Join(dir, "out")); err != nil {
    b.Fatal("Got error when compiling:", err)
   }

   if err := pkg.Link(config, filepath.Join(dir, "out", "test")); err != nil {
    b.Fatal("Got error when linking:", err)
   }
  })
 }
}

// BenchmarkMinIncrementalBuild computes how long an incremental build that
// doesn't actually need to build anything takes.
func BenchmarkMinIncrementalBuild(b *testing.B) {
 setupDir(b, func(config *Config, dir string, loadPkg loadPkgFunc) {
  pkg := loadPkg()

  if err := pkg.Compile(config, filepath.Join(dir, "out")); err != nil {
   b.Fatal("Got error when compiling:", err)
  }

  if err := pkg.Link(config, filepath.Join(dir, "out", "test")); err != nil {
   b.Fatal("Got error when linking:", err)
  }

  b.ResetTimer()

  for i := 0; i < b.N; i++ {
   pkg := loadPkg()

   if err := pkg.Compile(config, filepath.Join(dir, "out")); err != nil {
    b.Fatal("Got error when compiling:", err)
   }

   if err := pkg.Link(config, filepath.Join(dir, "out", "test")); err != nil {
    b.Fatal("Got error when linking:", err)
   }

   if pkg.rebuilt {
    b.Fatal("Should not have rebuilt anything")
   }
  }
 })
}

///////////////////////////////////////////////////////
// Templates used to create fake compilable packages //
///////////////////////////////////////////////////////

const go_main_main = `
package main
import (
 "fmt"
 "android/soong/a"
 "android/soong/b"
)
func main() {
 fmt.Println(a.Stdout, b.Stdout)
}
`

const go_a_a = `
package a
import "os"
var Stdout = os.Stdout
`

const go_a_b = `
package a
`

const go_b_a = `
package b
import "android/soong/a"
var Stdout = a.Stdout
`

type T interface {
 Fatal(args ...interface{})
 Fatalf(format string, args ...interface{})
}

type loadPkgFunc func() *GoPackage

func setupDir(t T, test func(config *Config, dir string, loadPkg loadPkgFunc)) {
 dir, err := ioutil.TempDir("", "test")
 if err != nil {
  t.Fatalf("Error creating temporary directory: %#v", err)
 }
 defer os.RemoveAll(dir)

 writeFile := func(name, contents string) {
  if err := ioutil.WriteFile(filepath.Join(dir, name), []byte(contents), 0666); err != nil {
   t.Fatalf("Error writing %q: %#v", name, err)
  }
 }
 mkdir := func(name string) {
  if err := os.Mkdir(filepath.Join(dir, name), 0777); err != nil {
   t.Fatalf("Error creating %q directory: %#v", name, err)
  }
 }
 mkdir("main")
 mkdir("a")
 mkdir("b")
 writeFile("main/main.go", go_main_main)
 writeFile("a/a.go", go_a_a)
 writeFile("a/b.go", go_a_b)
 writeFile("b/a.go", go_b_a)

 config := &Config{}
 config.Map("android/soong", dir)

 loadPkg := func() *GoPackage {
  pkg := &GoPackage{
   Name: "main",
  }
  if err := pkg.FindDeps(config, filepath.Join(dir, "main")); err != nil {
   t.Fatalf("Error finding deps: %v", err)
  }
  return pkg
 }

 test(config, dir, loadPkg)
}