tequilaOS/platform_build_blueprint
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

apply gofmt

Browse source 
Change-Id: I2416e246b3d8485a6b7810b998cff2f45f6a0494
This commit is contained in:
Sam Delmerico 2023-02-21 14:40:56 -05:00
parent a988f08000
commit 26e44b7b78
9 changed files with 114 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
context_test.go
View file

@ -174,11 +174,11 @@ func TestContextParse(t *testing.T) {
}
}
// |===B---D - represents a non-walkable edge
// A = represents a walkable edge
// |===C===E---G
// | | A should not be visited because it's the root node.
// |===F===| B, D and E should not be walked.
// > |===B---D - represents a non-walkable edge
// > A = represents a walkable edge
// > |===C===E---G
// > | | A should not be visited because it's the root node.
// > |===F===| B, D and E should not be walked.
func TestWalkDeps(t *testing.T) {
ctx := NewContext()
ctx.MockFileSystem(map[string][]byte{
@ -249,12 +249,12 @@ func TestWalkDeps(t *testing.T) {
}
}
// |===B---D - represents a non-walkable edge
// A = represents a walkable edge
// |===C===E===\ A should not be visited because it's the root node.
// | | B, D should not be walked.
// |===F===G===H G should be visited multiple times
// \===/ H should only be visited once
// > |===B---D - represents a non-walkable edge
// > A = represents a walkable edge
// > |===C===E===\ A should not be visited because it's the root node.
// > | | B, D should not be walked.
// > |===F===G===H G should be visited multiple times
// > \===/ H should only be visited once
func TestWalkDepsDuplicates(t *testing.T) {
ctx := NewContext()
ctx.MockFileSystem(map[string][]byte{
@ -330,11 +330,11 @@ func TestWalkDepsDuplicates(t *testing.T) {
}
}
// - represents a non-walkable edge
// A = represents a walkable edge
// |===B-------\ A should not be visited because it's the root node.
// | | B -> D should not be walked.
// |===C===D===E B -> C -> D -> E should be walked
// > - represents a non-walkable edge
// > A = represents a walkable edge
// > |===B-------\ A should not be visited because it's the root node.
// > | | B -> D should not be walked.
// > |===C===D===E B -> C -> D -> E should be walked
func TestWalkDepsDuplicates_IgnoreFirstPath(t *testing.T) {
ctx := NewContext()
ctx.MockFileSystem(map[string][]byte{
@ -1107,24 +1107,24 @@ func TestPackageIncludes(t *testing.T) {
"dir1/Android.bp": []byte(dir1_foo_bp),
"dir2/Android.bp": []byte(dir2_foo_bp),
}
testCases := []struct{
desc string
testCases := []struct {
desc string
includeTags []string
expectedDir string
expectedErr string
}{
{
desc: "use_dir1 is set, use dir1 foo",
desc: "use_dir1 is set, use dir1 foo",
includeTags: []string{"use_dir1"},
expectedDir: "dir1",
},
{
desc: "use_dir2 is set, use dir2 foo",
desc: "use_dir2 is set, use dir2 foo",
includeTags: []string{"use_dir2"},
expectedDir: "dir2",
},
{
desc: "duplicate module error if both use_dir1 and use_dir2 are set",
desc: "duplicate module error if both use_dir1 and use_dir2 are set",
includeTags: []string{"use_dir1", "use_dir2"},
expectedDir: "",
expectedErr: `module "foo" already defined`,

20
doc.go
View file

@ -35,17 +35,17 @@
// the module type looks like a function call, and the properties of the module
// look like optional arguments. For example, a simple module might look like:
//
// cc_library {
// name: "cmd",
// srcs: [
// "main.c",
// ],
// deps: [
// "libc",
// ],
// }
// cc_library {
// name: "cmd",
// srcs: [
// "main.c",
// ],
// deps: [
// "libc",
// ],
// }
//
// subdirs = ["subdir1", "subdir2"]
// subdirs = ["subdir1", "subdir2"]
//
// The modules from the top level Blueprints file and recursively through any
// subdirectories listed by the "subdirs" variable are read by Blueprint, and

4
microfactory/microfactory.go
View file

@ -16,8 +16,8 @@
// to `go install`, but doesn't require a GOPATH. A package->path mapping can
// be specified as command line options:
//
// -pkg-path android/soong=build/soong
// -pkg-path github.com/google/blueprint=build/blueprint
// -pkg-path android/soong=build/soong
// -pkg-path github.com/google/blueprint=build/blueprint
//
// The paths can be relative to the current working directory, or an absolute
// path. Both packages and paths are compared with full directory names, so the

34
module_ctx.go
View file

@ -58,27 +58,27 @@ import (
// that other modules can link against. The library Module might implement the
// following interface:
//
// type LibraryProducer interface {
// LibraryFileName() string
// }
// type LibraryProducer interface {
// LibraryFileName() string
// }
//
// func IsLibraryProducer(module blueprint.Module) {
// _, ok := module.(LibraryProducer)
// return ok
// }
// func IsLibraryProducer(module blueprint.Module) {
// _, ok := module.(LibraryProducer)
// return ok
// }
//
// A binary-producing Module that depends on the library Module could then do:
//
// func (m *myBinaryModule) GenerateBuildActions(ctx blueprint.ModuleContext) {
// ...
// var libraryFiles []string
// ctx.VisitDepsDepthFirstIf(IsLibraryProducer,
// func(module blueprint.Module) {
// libProducer := module.(LibraryProducer)
// libraryFiles = append(libraryFiles, libProducer.LibraryFileName())
// })
// ...
// }
// func (m *myBinaryModule) GenerateBuildActions(ctx blueprint.ModuleContext) {
// ...
// var libraryFiles []string
// ctx.VisitDepsDepthFirstIf(IsLibraryProducer,
// func(module blueprint.Module) {
// libProducer := module.(LibraryProducer)
// libraryFiles = append(libraryFiles, libProducer.LibraryFileName())
// })
// ...
// }
//
// to build the list of library file names that should be included in its link
// command.

64
package_ctx.go
View file

@ -31,29 +31,29 @@ import (
// passed to all calls to define module- or singleton-specific Ninja
// definitions. For example:
//
// package blah
// package blah
//
// import (
// "blueprint"
// )
// import (
// "blueprint"
// )
//
// var (
// pctx = NewPackageContext("path/to/blah")
// var (
// pctx = NewPackageContext("path/to/blah")
//
// myPrivateVar = pctx.StaticVariable("myPrivateVar", "abcdef")
// MyExportedVar = pctx.StaticVariable("MyExportedVar", "$myPrivateVar 123456!")
// myPrivateVar = pctx.StaticVariable("myPrivateVar", "abcdef")
// MyExportedVar = pctx.StaticVariable("MyExportedVar", "$myPrivateVar 123456!")
//
// SomeRule = pctx.StaticRule(...)
// )
// SomeRule = pctx.StaticRule(...)
// )
//
// // ...
// // ...
//
// func (m *MyModule) GenerateBuildActions(ctx blueprint.Module) {
// ctx.Build(pctx, blueprint.BuildParams{
// Rule: SomeRule,
// Outputs: []string{"$myPrivateVar"},
// })
// }
// func (m *MyModule) GenerateBuildActions(ctx blueprint.Module) {
// ctx.Build(pctx, blueprint.BuildParams{
// Rule: SomeRule,
// Outputs: []string{"$myPrivateVar"},
// })
// }
type PackageContext interface {
Import(pkgPath string)
ImportAs(as, pkgPath string)
@ -190,25 +190,25 @@ func pkgPathToName(pkgPath string) string {
// "${pkg.Variable}", while the imported rules can simply be accessed as
// exported Go variables from the package. For example:
//
// import (
// "blueprint"
// "foo/bar"
// )
// import (
// "blueprint"
// "foo/bar"
// )
//
// var pctx = NewPackagePath("blah")
// var pctx = NewPackagePath("blah")
//
// func init() {
// pctx.Import("foo/bar")
// }
// func init() {
// pctx.Import("foo/bar")
// }
//
// ...
// ...
//
// func (m *MyModule) GenerateBuildActions(ctx blueprint.Module) {
// ctx.Build(pctx, blueprint.BuildParams{
// Rule: bar.SomeRule,
// Outputs: []string{"${bar.SomeVariable}"},
// })
// }
// func (m *MyModule) GenerateBuildActions(ctx blueprint.Module) {
// ctx.Build(pctx, blueprint.BuildParams{
// Rule: bar.SomeRule,
// Outputs: []string{"${bar.SomeVariable}"},
// })
// }
//
// Note that the local name used to refer to the package in Ninja variable names
// is derived from pkgPath by extracting the last path component. This differs

2
pathtools/lists_test.go
View file

@ -4,7 +4,7 @@
// 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
// 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,

8
proptools/unpack.go
View file

@ -53,9 +53,13 @@ type unpackContext struct {
// If a property a.b.c has a value, a field with the matching name in each runtime value is initialized
// from it. See PropertyNameForField for field and property name matching.
// For instance, if the input contains
// { foo: "abc", bar: {x: 1},}
//
// { foo: "abc", bar: {x: 1},}
//
// and a runtime value being has been declared as
// var v struct { Foo string; Bar int }
//
// var v struct { Foo string; Bar int }
//
// then v.Foo will be set to "abc" and v.Bar will be set to 1
// (cf. unpack_test.go for further examples)
//

24
visit_test.go
View file

@ -74,18 +74,18 @@ func visitMutator(ctx TopDownMutatorContext) {
}
}
// A
// |
// B
// |\
// C \
// \|
// D
// |
// E
// / \
// \ /
// F
// > A
// > |
// > B
// > |\
// > C \
// > \|
// > D
// > |
// > E
// > / \
// > \ /
// > F
func setupVisitTest(t *testing.T) *Context {
ctx := NewContext()
ctx.RegisterModuleType("visit_module", newVisitModule)