provider_test.go - platform/build/blueprint - Git at Google

 // Copyright 2020 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 blueprint

 import (
 	"bytes"
 	"fmt"
 	"reflect"
 	"strings"
 	"testing"

 	"github.com/google/blueprint/gobtools"
 )

 type providerTestModule struct {
 	ModuleBase
 	SimpleName
 	properties struct {
 		Deps []string
 	}

 	mutatorProviderValues              []string
 	generateBuildActionsProviderValues []string
 }

 func newProviderTestModule() (Module, []interface{}) {
 	m := &providerTestModule{}
 	return m, []interface{}{&m.properties, &m.SimpleName.Properties}
 }

 var providerTestSingletonProvider = NewSingletonProvider[bool]()

 type providerTestParallelSingleton struct {
 	visitAllSingletons bool
 }

 func (s *providerTestParallelSingleton) GenerateBuildActions(ctx SingletonContext) {
 	if s.visitAllSingletons {
 		ctx.VisitAllSingletons(func(s SingletonProxy) {})
 	}
 	ctx.SetSingletonProvider(providerTestSingletonProvider, true)
 }

 func (s *providerTestParallelSingleton) IncrementalSupported() bool {
 	return true
 }

 type providerTestSequentialSingleton struct {
 	getModuleProvider bool
 	setModuleProvider bool
 }

 func (s *providerTestSequentialSingleton) GenerateBuildActions(ctx SingletonContext) {
 	if s.getModuleProvider {
 		ctx.VisitAllSingletons(func(s SingletonProxy) {
 			ctx.OtherSingletonProvider(s, providerTestMutatorInfoProvider)
 		})
 	}
 	if s.setModuleProvider {
 		ctx.SetSingletonProvider(providerTestMutatorInfoProvider, nil)
 	}
 	ctx.VisitAllSingletons(func(s SingletonProxy) {
 		ctx.OtherSingletonProvider(s, providerTestSingletonProvider)
 	})
 }

 func (s *providerTestSequentialSingleton) IncrementalSupported() bool {
 	return true
 }

 type providerTestMutatorInfo struct {
 	Values []string
 }

 type providerTestGenerateBuildActionsInfo struct {
 	Value string
 }

 func (providerTestGenerateBuildActionsInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 	return nil
 }

 func (providerTestGenerateBuildActionsInfo) GetTypeId() int16 {
 	return -1
 }

 type providerTestUnsetInfo string

 var providerTestMutatorInfoProvider = NewMutatorProvider[*providerTestMutatorInfo]("provider_mutator")
 var providerTestGenerateBuildActionsInfoProvider = NewProvider[*providerTestGenerateBuildActionsInfo]()
 var providerTestUnsetInfoProvider = NewMutatorProvider[providerTestUnsetInfo]("provider_mutator")
 var providerTestUnusedMutatorProvider = NewMutatorProvider[*struct{ unused string }]("nonexistent_mutator")

 func (p *providerTestModule) GenerateBuildActions(ctx ModuleContext) {
 	unset, ok := ModuleProvider(ctx, providerTestUnsetInfoProvider)
 	if ok {
 		panic(fmt.Errorf("expected false return value for providerTestGenerateBuildActionsInfoProvider before it was set"))
 	}
 	if unset != "" {
 		panic(fmt.Errorf("expected zero value for providerTestGenerateBuildActionsInfoProvider before it was set, got %q",
 			unset))
 	}

 	// Verify reading providerTestUnusedMutatorProvider doesn't panic
 	_, _ = ModuleProvider(ctx, providerTestUnusedMutatorProvider)

 	SetProvider(ctx, providerTestGenerateBuildActionsInfoProvider, &providerTestGenerateBuildActionsInfo{
 		Value: ctx.ModuleName(),
 	})

 	mp, ok := ModuleProvider(ctx, providerTestMutatorInfoProvider)
 	if ok {
 		p.mutatorProviderValues = mp.Values
 	}

 	ctx.VisitDirectDeps(func(module Module) {
 		gbap, _ := OtherModuleProvider(ctx, module, providerTestGenerateBuildActionsInfoProvider)
 		if gbap != nil {
 			p.generateBuildActionsProviderValues = append(p.generateBuildActionsProviderValues, gbap.Value)
 		}
 	})
 }

 func providerTestDepsMutator(ctx BottomUpMutatorContext) {
 	if p, ok := ctx.Module().(*providerTestModule); ok {
 		ctx.AddDependency(ctx.Module(), nil, p.properties.Deps...)
 	}
 }

 func providerTestMutator(ctx BottomUpMutatorContext) {
 	values := []string{strings.ToLower(ctx.ModuleName())}

 	ctx.VisitDirectDeps(func(module Module) {
 		mp, _ := OtherModuleProvider(ctx, module, providerTestMutatorInfoProvider)
 		if mp != nil {
 			values = append(values, mp.Values...)
 		}
 	})

 	SetProvider(ctx, providerTestMutatorInfoProvider, &providerTestMutatorInfo{
 		Values: values,
 	})
 }

 func providerTestAfterMutator(ctx BottomUpMutatorContext) {
 	// Verify reading providerTestUnusedMutatorProvider doesn't panic
 	_, _ = ModuleProvider(ctx, providerTestMutatorInfoProvider)
 }

 func TestProviders(t *testing.T) {
 	ctx := NewContext()
 	ctx.RegisterModuleType("provider_module", newProviderTestModule)
 	ctx.RegisterBottomUpMutator("provider_deps_mutator", providerTestDepsMutator)
 	ctx.RegisterBottomUpMutator("provider_mutator", providerTestMutator)
 	ctx.RegisterBottomUpMutator("provider_after_mutator", providerTestAfterMutator)

 	ctx.MockFileSystem(map[string][]byte{
 		"Android.bp": []byte(`
 			provider_module {
 				name: "A",
 				deps: ["B"],
 			}

 			provider_module {
 				name: "B",
 				deps: ["C", "D"],
 			}

 			provider_module {
 				name: "C",
 				deps: ["D"],
 			}

 			provider_module {
 				name: "D",
 			}
 		`),
 	})

 	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
 	if len(errs) == 0 {
 		_, errs = ctx.ResolveDependencies(nil)
 	}
 	if len(errs) == 0 {
 		_, errs = ctx.PrepareBuildActions(nil)
 	}
 	if len(errs) > 0 {
 		t.Errorf("unexpected errors:")
 		for _, err := range errs {
 			t.Errorf("  %s", err)
 		}
 		t.FailNow()
 	}

 	aModule := ctx.moduleGroupFromName("A", nil).moduleByVariantName("").logicModule.(*providerTestModule)
 	if g, w := aModule.generateBuildActionsProviderValues, []string{"B"}; !reflect.DeepEqual(g, w) {
 		t.Errorf("expected A.generateBuildActionsProviderValues %q, got %q", w, g)
 	}
 	if g, w := aModule.mutatorProviderValues, []string{"a", "b", "c", "d", "d"}; !reflect.DeepEqual(g, w) {
 		t.Errorf("expected A.mutatorProviderValues %q, got %q", w, g)
 	}

 	bModule := ctx.moduleGroupFromName("B", nil).moduleByVariantName("").logicModule.(*providerTestModule)
 	if g, w := bModule.generateBuildActionsProviderValues, []string{"C", "D"}; !reflect.DeepEqual(g, w) {
 		t.Errorf("expected B.generateBuildActionsProviderValues %q, got %q", w, g)
 	}
 	if g, w := bModule.mutatorProviderValues, []string{"b", "c", "d", "d"}; !reflect.DeepEqual(g, w) {
 		t.Errorf("expected B.mutatorProviderValues %q, got %q", w, g)
 	}
 }

 type invalidProviderUsageMutatorInfo string
 type invalidProviderUsageGenerateBuildActionsInfo string

 func (invalidProviderUsageGenerateBuildActionsInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
 	return nil
 }

 func (invalidProviderUsageGenerateBuildActionsInfo) GetTypeId() int16 {
 	return -1
 }

 var invalidProviderUsageMutatorInfoProvider = NewMutatorProvider[invalidProviderUsageMutatorInfo]("mutator_under_test")
 var invalidProviderUsageGenerateBuildActionsInfoProvider = NewProvider[invalidProviderUsageGenerateBuildActionsInfo]()

 type invalidProviderUsageTestModule struct {
 	ModuleBase
 	SimpleName
 	properties struct {
 		Deps []string

 		Early_mutator_set_of_mutator_provider       bool
 		Late_mutator_set_of_mutator_provider        bool
 		Late_build_actions_set_of_mutator_provider  bool
 		Early_mutator_set_of_build_actions_provider bool

 		Early_mutator_get_of_mutator_provider       bool
 		Early_mutator_get_of_build_actions_provider bool

 		Duplicate_set bool
 	}
 }

 func invalidProviderUsageDepsMutator(ctx BottomUpMutatorContext) {
 	if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
 		ctx.AddDependency(ctx.Module(), nil, i.properties.Deps...)
 	}
 }

 func invalidProviderUsageBeforeMutator(ctx BottomUpMutatorContext) {
 	if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
 		if i.properties.Early_mutator_set_of_mutator_provider {
 			// A mutator attempting to set the value of a provider associated with a later mutator.
 			SetProvider(ctx, invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
 		}
 		if i.properties.Early_mutator_get_of_mutator_provider {
 			// A mutator attempting to get the value of a provider associated with a later mutator.
 			_, _ = ModuleProvider(ctx, invalidProviderUsageMutatorInfoProvider)
 		}
 	}
 }

 func invalidProviderUsageMutatorUnderTest(ctx BottomUpMutatorContext) {
 	if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
 		if i.properties.Early_mutator_set_of_build_actions_provider {
 			// A mutator attempting to set the value of a non-mutator provider.
 			SetProvider(ctx, invalidProviderUsageGenerateBuildActionsInfoProvider, invalidProviderUsageGenerateBuildActionsInfo(""))
 		}
 		if i.properties.Early_mutator_get_of_build_actions_provider {
 			// A mutator attempting to get the value of a non-mutator provider.
 			_, _ = ModuleProvider(ctx, invalidProviderUsageGenerateBuildActionsInfoProvider)
 		}
 	}
 }

 func invalidProviderUsageAfterMutator(ctx BottomUpMutatorContext) {
 	if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
 		if i.properties.Late_mutator_set_of_mutator_provider {
 			// A mutator trying to set the value of a provider associated with an earlier mutator.
 			SetProvider(ctx, invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
 		}
 		if i.properties.Late_mutator_set_of_mutator_provider {
 			// A mutator trying to set the value of a provider associated with an earlier mutator.
 			SetProvider(ctx, invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
 		}
 	}
 }

 func (i *invalidProviderUsageTestModule) GenerateBuildActions(ctx ModuleContext) {
 	if i.properties.Late_build_actions_set_of_mutator_provider {
 		// A GenerateBuildActions trying to set the value of a provider associated with a mutator.
 		SetProvider(ctx, invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
 	}
 	if i.properties.Duplicate_set {
 		SetProvider(ctx, invalidProviderUsageGenerateBuildActionsInfoProvider, invalidProviderUsageGenerateBuildActionsInfo(""))
 		SetProvider(ctx, invalidProviderUsageGenerateBuildActionsInfoProvider, invalidProviderUsageGenerateBuildActionsInfo(""))
 	}
 }

 func TestInvalidProvidersUsage(t *testing.T) {
 	run := func(t *testing.T, module string, prop string, panicMsg string) {
 		t.Helper()
 		ctx := NewContext()
 		ctx.RegisterModuleType("invalid_provider_usage_test_module", func() (Module, []interface{}) {
 			m := &invalidProviderUsageTestModule{}
 			return m, []interface{}{&m.properties, &m.SimpleName.Properties}
 		})
 		ctx.RegisterBottomUpMutator("deps", invalidProviderUsageDepsMutator)
 		ctx.RegisterBottomUpMutator("before", invalidProviderUsageBeforeMutator)
 		ctx.RegisterBottomUpMutator("mutator_under_test", invalidProviderUsageMutatorUnderTest)
 		ctx.RegisterBottomUpMutator("after", invalidProviderUsageAfterMutator)

 		// Don't invalidate the parent pointer and before GenerateBuildActions.
 		ctx.SkipCloneModulesAfterMutators = true

 		var parentBP, moduleUnderTestBP, childBP string

 		prop += ": true,"

 		switch module {
 		case "parent":
 			parentBP = prop
 		case "module_under_test":
 			moduleUnderTestBP = prop
 		case "child":
 			childBP = prop
 		}

 		bp := fmt.Sprintf(`
 			invalid_provider_usage_test_module {
 				name: "parent",
 				deps: ["module_under_test"],
 				%s
 			}

 			invalid_provider_usage_test_module {
 				name: "module_under_test",
 				deps: ["child"],
 				%s
 			}

 			invalid_provider_usage_test_module {
 				name: "child",
 				%s
 			}

 		`,
 			parentBP,
 			moduleUnderTestBP,
 			childBP)

 		ctx.MockFileSystem(map[string][]byte{
 			"Android.bp": []byte(bp),
 		})

 		_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)

 		if len(errs) == 0 {
 			_, errs = ctx.ResolveDependencies(nil)
 		}

 		if len(errs) == 0 {
 			_, errs = ctx.PrepareBuildActions(nil)
 		}

 		if len(errs) == 0 {
 			t.Fatal("expected an error")
 		}

 		if len(errs) > 1 {
 			t.Errorf("expected a single error, got %d:", len(errs))
 			for i, err := range errs {
 				t.Errorf("%d:  %s", i, err)
 			}
 			t.FailNow()
 		}

 		if panicErr, ok := errs[0].(panicError); ok {
 			if panicErr.panic != panicMsg {
 				t.Fatalf("expected panic %q, got %q", panicMsg, panicErr.panic)
 			}
 		} else {
 			t.Fatalf("expected a panicError, got %T: %s", errs[0], errs[0].Error())
 		}

 	}

 	tests := []struct {
 		prop   string
 		module string

 		panicMsg string
 		skip     string
 	}{
 		{
 			prop:     "early_mutator_set_of_mutator_provider",
 			module:   "module_under_test",
 			panicMsg: "Can't set value of provider blueprint.invalidProviderUsageMutatorInfo before mutator mutator_under_test started",
 		},
 		{
 			prop:     "late_mutator_set_of_mutator_provider",
 			module:   "module_under_test",
 			panicMsg: "Can't set value of provider blueprint.invalidProviderUsageMutatorInfo after mutator mutator_under_test finished",
 		},
 		{
 			prop:     "late_build_actions_set_of_mutator_provider",
 			module:   "module_under_test",
 			panicMsg: "Can't set value of provider blueprint.invalidProviderUsageMutatorInfo after mutator mutator_under_test finished",
 		},
 		{
 			prop:     "early_mutator_set_of_build_actions_provider",
 			module:   "module_under_test",
 			panicMsg: "Can't set value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo before GenerateBuildActions started",
 		},

 		{
 			prop:     "early_mutator_get_of_mutator_provider",
 			module:   "module_under_test",
 			panicMsg: "Can't get value of provider blueprint.invalidProviderUsageMutatorInfo before mutator mutator_under_test finished",
 		},
 		{
 			prop:     "early_mutator_get_of_build_actions_provider",
 			module:   "module_under_test",
 			panicMsg: "Can't get value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo before GenerateBuildActions finished",
 		},
 		{
 			prop:     "duplicate_set",
 			module:   "module_under_test",
 			panicMsg: "Value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo is already set",
 		},
 	}

 	for _, tt := range tests {
 		t.Run(tt.prop, func(t *testing.T) {
 			run(t, tt.module, tt.prop, tt.panicMsg)
 		})
 	}
 }

 func TestInvalidSingletonProvidersUsage(t *testing.T) {
 	type singletonType struct {
 		name     string
 		factory  SingletonFactory
 		parallel bool
 	}

 	run := func(t *testing.T, singletons []singletonType, panicMsg string) {
 		t.Helper()
 		ctx := NewContext()
 		for _, s := range singletons {
 			ctx.RegisterSingletonType(s.name, s.factory, s.parallel)
 		}

 		ctx.MockFileSystem(map[string][]byte{
 			"Android.bp": {},
 		})

 		_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)

 		if len(errs) == 0 {
 			_, errs = ctx.ResolveDependencies(nil)
 		}

 		if len(errs) == 0 {
 			_, errs = ctx.PrepareBuildActions(nil)
 		}

 		if len(panicMsg) == 0 {
 			if len(errs) != 0 {
 				t.Fatal("got an error: ", errs)
 			}
 			return
 		}

 		if len(errs) == 0 {
 			t.Fatal("expected an error")
 		}

 		if len(errs) > 1 {
 			t.Errorf("expected a single error, got %d:", len(errs))
 			for i, err := range errs {
 				t.Errorf("%d:  %s", i, err)
 			}
 			t.FailNow()
 		}

 		if panicErr, ok := errs[0].(panicError); ok {
 			if panicErr.panic != panicMsg {
 				t.Fatalf("expected panic %q, got %q", panicMsg, panicErr.panic)
 			}
 		} else {
 			t.Fatalf("expected a panicError, got %T: %s", errs[0], errs[0].Error())
 		}

 	}

 	tests := []struct {
 		testName   string
 		singletons []singletonType
 		panicMsg   string
 	}{
 		{
 			testName: "get_non_singleton_provider",
 			singletons: []singletonType{
 				{
 					name: "parallel_singleton",
 					factory: func() Singleton {
 						return &providerTestParallelSingleton{}
 					},
 					parallel: true,
 				},
 				{
 					name: "sequential_singleton",
 					factory: func() Singleton {
 						return &providerTestSequentialSingleton{
 							getModuleProvider: true,
 						}
 					},
 					parallel: false,
 				},
 			},
 			panicMsg: "Can't get value of non-singleton provider *blueprint.providerTestMutatorInfo usign singleton specific get method",
 		},
 		{
 			testName: "set_non_singleton_provider",
 			singletons: []singletonType{
 				{
 					name: "sequential_singleton",
 					factory: func() Singleton {
 						return &providerTestSequentialSingleton{
 							setModuleProvider: true,
 						}
 					},
 					parallel: false,
 				},
 			},
 			panicMsg: "Can't set value of non-singleton provider *blueprint.providerTestMutatorInfo inside singleton sequential_singleton",
 		},
 		{
 			testName: "set_get_singleton_provider",
 			singletons: []singletonType{
 				{
 					name: "parallel_singleton",
 					factory: func() Singleton {
 						return &providerTestParallelSingleton{}
 					},
 					parallel: true,
 				},
 				{
 					name: "sequential_singleton",
 					factory: func() Singleton {
 						return &providerTestSequentialSingleton{}
 					},
 					parallel: false,
 				},
 			},
 			panicMsg: "",
 		},
 		{
 			testName: "visit_all_singletons_in_parallel_singleton",
 			singletons: []singletonType{
 				{
 					name: "parallel_singleton",
 					factory: func() Singleton {
 						return &providerTestParallelSingleton{visitAllSingletons: true}
 					},
 					parallel: true,
 				},
 			},
 			panicMsg: "VisitAllSingletons not allowed in parallel singletons parallel_singleton",
 		},
 	}

 	for _, tt := range tests {
 		t.Run(tt.testName, func(t *testing.T) {
 			run(t, tt.singletons, tt.panicMsg)
 		})
 	}
 }
	// Copyright 2020 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 blueprint

	import (
	"bytes"
	"fmt"
	"reflect"
	"strings"
	"testing"

	"github.com/google/blueprint/gobtools"
	)

	type providerTestModule struct {
	ModuleBase
	SimpleName
	properties struct {
	Deps []string
	}

	mutatorProviderValues []string
	generateBuildActionsProviderValues []string
	}

	func newProviderTestModule() (Module, []interface{}) {
	m := &providerTestModule{}
	return m, []interface{}{&m.properties, &m.SimpleName.Properties}
	}

	var providerTestSingletonProvider = NewSingletonProvider[bool]()

	type providerTestParallelSingleton struct {
	visitAllSingletons bool
	}

	func (s *providerTestParallelSingleton) GenerateBuildActions(ctx SingletonContext) {
	if s.visitAllSingletons {
	ctx.VisitAllSingletons(func(s SingletonProxy) {})
	}
	ctx.SetSingletonProvider(providerTestSingletonProvider, true)
	}

	func (s *providerTestParallelSingleton) IncrementalSupported() bool {
	return true
	}

	type providerTestSequentialSingleton struct {
	getModuleProvider bool
	setModuleProvider bool
	}

	func (s *providerTestSequentialSingleton) GenerateBuildActions(ctx SingletonContext) {
	if s.getModuleProvider {
	ctx.VisitAllSingletons(func(s SingletonProxy) {
	ctx.OtherSingletonProvider(s, providerTestMutatorInfoProvider)
	})
	}
	if s.setModuleProvider {
	ctx.SetSingletonProvider(providerTestMutatorInfoProvider, nil)
	}
	ctx.VisitAllSingletons(func(s SingletonProxy) {
	ctx.OtherSingletonProvider(s, providerTestSingletonProvider)
	})
	}

	func (s *providerTestSequentialSingleton) IncrementalSupported() bool {
	return true
	}

	type providerTestMutatorInfo struct {
	Values []string
	}

	type providerTestGenerateBuildActionsInfo struct {
	Value string
	}

	func (providerTestGenerateBuildActionsInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	return nil
	}

	func (providerTestGenerateBuildActionsInfo) GetTypeId() int16 {
	return -1
	}

	type providerTestUnsetInfo string

	var providerTestMutatorInfoProvider = NewMutatorProvider[*providerTestMutatorInfo]("provider_mutator")
	var providerTestGenerateBuildActionsInfoProvider = NewProvider[*providerTestGenerateBuildActionsInfo]()
	var providerTestUnsetInfoProvider = NewMutatorProvider[providerTestUnsetInfo]("provider_mutator")
	var providerTestUnusedMutatorProvider = NewMutatorProvider[*struct{ unused string }]("nonexistent_mutator")

	func (p *providerTestModule) GenerateBuildActions(ctx ModuleContext) {
	unset, ok := ModuleProvider(ctx, providerTestUnsetInfoProvider)
	if ok {
	panic(fmt.Errorf("expected false return value for providerTestGenerateBuildActionsInfoProvider before it was set"))
	}
	if unset != "" {
	panic(fmt.Errorf("expected zero value for providerTestGenerateBuildActionsInfoProvider before it was set, got %q",
	unset))
	}

	// Verify reading providerTestUnusedMutatorProvider doesn't panic
	_, _ = ModuleProvider(ctx, providerTestUnusedMutatorProvider)

	SetProvider(ctx, providerTestGenerateBuildActionsInfoProvider, &providerTestGenerateBuildActionsInfo{
	Value: ctx.ModuleName(),
	})

	mp, ok := ModuleProvider(ctx, providerTestMutatorInfoProvider)
	if ok {
	p.mutatorProviderValues = mp.Values
	}

	ctx.VisitDirectDeps(func(module Module) {
	gbap, _ := OtherModuleProvider(ctx, module, providerTestGenerateBuildActionsInfoProvider)
	if gbap != nil {
	p.generateBuildActionsProviderValues = append(p.generateBuildActionsProviderValues, gbap.Value)
	}
	})
	}

	func providerTestDepsMutator(ctx BottomUpMutatorContext) {
	if p, ok := ctx.Module().(*providerTestModule); ok {
	ctx.AddDependency(ctx.Module(), nil, p.properties.Deps...)
	}
	}

	func providerTestMutator(ctx BottomUpMutatorContext) {
	values := []string{strings.ToLower(ctx.ModuleName())}

	ctx.VisitDirectDeps(func(module Module) {
	mp, _ := OtherModuleProvider(ctx, module, providerTestMutatorInfoProvider)
	if mp != nil {
	values = append(values, mp.Values...)
	}
	})

	SetProvider(ctx, providerTestMutatorInfoProvider, &providerTestMutatorInfo{
	Values: values,
	})
	}

	func providerTestAfterMutator(ctx BottomUpMutatorContext) {
	// Verify reading providerTestUnusedMutatorProvider doesn't panic
	_, _ = ModuleProvider(ctx, providerTestMutatorInfoProvider)
	}

	func TestProviders(t *testing.T) {
	ctx := NewContext()
	ctx.RegisterModuleType("provider_module", newProviderTestModule)
	ctx.RegisterBottomUpMutator("provider_deps_mutator", providerTestDepsMutator)
	ctx.RegisterBottomUpMutator("provider_mutator", providerTestMutator)
	ctx.RegisterBottomUpMutator("provider_after_mutator", providerTestAfterMutator)

	ctx.MockFileSystem(map[string][]byte{
	"Android.bp": []byte(`
	provider_module {
	name: "A",
	deps: ["B"],
	}

	provider_module {
	name: "B",
	deps: ["C", "D"],
	}

	provider_module {
	name: "C",
	deps: ["D"],
	}

	provider_module {
	name: "D",
	}
	`),
	})

	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)
	if len(errs) == 0 {
	_, errs = ctx.ResolveDependencies(nil)
	}
	if len(errs) == 0 {
	_, errs = ctx.PrepareBuildActions(nil)
	}
	if len(errs) > 0 {
	t.Errorf("unexpected errors:")
	for _, err := range errs {
	t.Errorf(" %s", err)
	}
	t.FailNow()
	}

	aModule := ctx.moduleGroupFromName("A", nil).moduleByVariantName("").logicModule.(*providerTestModule)
	if g, w := aModule.generateBuildActionsProviderValues, []string{"B"}; !reflect.DeepEqual(g, w) {
	t.Errorf("expected A.generateBuildActionsProviderValues %q, got %q", w, g)
	}
	if g, w := aModule.mutatorProviderValues, []string{"a", "b", "c", "d", "d"}; !reflect.DeepEqual(g, w) {
	t.Errorf("expected A.mutatorProviderValues %q, got %q", w, g)
	}

	bModule := ctx.moduleGroupFromName("B", nil).moduleByVariantName("").logicModule.(*providerTestModule)
	if g, w := bModule.generateBuildActionsProviderValues, []string{"C", "D"}; !reflect.DeepEqual(g, w) {
	t.Errorf("expected B.generateBuildActionsProviderValues %q, got %q", w, g)
	}
	if g, w := bModule.mutatorProviderValues, []string{"b", "c", "d", "d"}; !reflect.DeepEqual(g, w) {
	t.Errorf("expected B.mutatorProviderValues %q, got %q", w, g)
	}
	}

	type invalidProviderUsageMutatorInfo string
	type invalidProviderUsageGenerateBuildActionsInfo string

	func (invalidProviderUsageGenerateBuildActionsInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	return nil
	}

	func (invalidProviderUsageGenerateBuildActionsInfo) GetTypeId() int16 {
	return -1
	}

	var invalidProviderUsageMutatorInfoProvider = NewMutatorProvider[invalidProviderUsageMutatorInfo]("mutator_under_test")
	var invalidProviderUsageGenerateBuildActionsInfoProvider = NewProvider[invalidProviderUsageGenerateBuildActionsInfo]()

	type invalidProviderUsageTestModule struct {
	ModuleBase
	SimpleName
	properties struct {
	Deps []string

	Early_mutator_set_of_mutator_provider bool
	Late_mutator_set_of_mutator_provider bool
	Late_build_actions_set_of_mutator_provider bool
	Early_mutator_set_of_build_actions_provider bool

	Early_mutator_get_of_mutator_provider bool
	Early_mutator_get_of_build_actions_provider bool

	Duplicate_set bool
	}
	}

	func invalidProviderUsageDepsMutator(ctx BottomUpMutatorContext) {
	if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
	ctx.AddDependency(ctx.Module(), nil, i.properties.Deps...)
	}
	}

	func invalidProviderUsageBeforeMutator(ctx BottomUpMutatorContext) {
	if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
	if i.properties.Early_mutator_set_of_mutator_provider {
	// A mutator attempting to set the value of a provider associated with a later mutator.
	SetProvider(ctx, invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
	}
	if i.properties.Early_mutator_get_of_mutator_provider {
	// A mutator attempting to get the value of a provider associated with a later mutator.
	_, _ = ModuleProvider(ctx, invalidProviderUsageMutatorInfoProvider)
	}
	}
	}

	func invalidProviderUsageMutatorUnderTest(ctx BottomUpMutatorContext) {
	if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
	if i.properties.Early_mutator_set_of_build_actions_provider {
	// A mutator attempting to set the value of a non-mutator provider.
	SetProvider(ctx, invalidProviderUsageGenerateBuildActionsInfoProvider, invalidProviderUsageGenerateBuildActionsInfo(""))
	}
	if i.properties.Early_mutator_get_of_build_actions_provider {
	// A mutator attempting to get the value of a non-mutator provider.
	_, _ = ModuleProvider(ctx, invalidProviderUsageGenerateBuildActionsInfoProvider)
	}
	}
	}

	func invalidProviderUsageAfterMutator(ctx BottomUpMutatorContext) {
	if i, ok := ctx.Module().(*invalidProviderUsageTestModule); ok {
	if i.properties.Late_mutator_set_of_mutator_provider {
	// A mutator trying to set the value of a provider associated with an earlier mutator.
	SetProvider(ctx, invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
	}
	if i.properties.Late_mutator_set_of_mutator_provider {
	// A mutator trying to set the value of a provider associated with an earlier mutator.
	SetProvider(ctx, invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
	}
	}
	}

	func (i *invalidProviderUsageTestModule) GenerateBuildActions(ctx ModuleContext) {
	if i.properties.Late_build_actions_set_of_mutator_provider {
	// A GenerateBuildActions trying to set the value of a provider associated with a mutator.
	SetProvider(ctx, invalidProviderUsageMutatorInfoProvider, invalidProviderUsageMutatorInfo(""))
	}
	if i.properties.Duplicate_set {
	SetProvider(ctx, invalidProviderUsageGenerateBuildActionsInfoProvider, invalidProviderUsageGenerateBuildActionsInfo(""))
	SetProvider(ctx, invalidProviderUsageGenerateBuildActionsInfoProvider, invalidProviderUsageGenerateBuildActionsInfo(""))
	}
	}

	func TestInvalidProvidersUsage(t *testing.T) {
	run := func(t *testing.T, module string, prop string, panicMsg string) {
	t.Helper()
	ctx := NewContext()
	ctx.RegisterModuleType("invalid_provider_usage_test_module", func() (Module, []interface{}) {
	m := &invalidProviderUsageTestModule{}
	return m, []interface{}{&m.properties, &m.SimpleName.Properties}
	})
	ctx.RegisterBottomUpMutator("deps", invalidProviderUsageDepsMutator)
	ctx.RegisterBottomUpMutator("before", invalidProviderUsageBeforeMutator)
	ctx.RegisterBottomUpMutator("mutator_under_test", invalidProviderUsageMutatorUnderTest)
	ctx.RegisterBottomUpMutator("after", invalidProviderUsageAfterMutator)

	// Don't invalidate the parent pointer and before GenerateBuildActions.
	ctx.SkipCloneModulesAfterMutators = true

	var parentBP, moduleUnderTestBP, childBP string

	prop += ": true,"

	switch module {
	case "parent":
	parentBP = prop
	case "module_under_test":
	moduleUnderTestBP = prop
	case "child":
	childBP = prop
	}

	bp := fmt.Sprintf(`
	invalid_provider_usage_test_module {
	name: "parent",
	deps: ["module_under_test"],
	%s
	}

	invalid_provider_usage_test_module {
	name: "module_under_test",
	deps: ["child"],
	%s
	}

	invalid_provider_usage_test_module {
	name: "child",
	%s
	}

	`,
	parentBP,
	moduleUnderTestBP,
	childBP)

	ctx.MockFileSystem(map[string][]byte{
	"Android.bp": []byte(bp),
	})

	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)

	if len(errs) == 0 {
	_, errs = ctx.ResolveDependencies(nil)
	}

	if len(errs) == 0 {
	_, errs = ctx.PrepareBuildActions(nil)
	}

	if len(errs) == 0 {
	t.Fatal("expected an error")
	}

	if len(errs) > 1 {
	t.Errorf("expected a single error, got %d:", len(errs))
	for i, err := range errs {
	t.Errorf("%d: %s", i, err)
	}
	t.FailNow()
	}

	if panicErr, ok := errs[0].(panicError); ok {
	if panicErr.panic != panicMsg {
	t.Fatalf("expected panic %q, got %q", panicMsg, panicErr.panic)
	}
	} else {
	t.Fatalf("expected a panicError, got %T: %s", errs[0], errs[0].Error())
	}

	}

	tests := []struct {
	prop string
	module string

	panicMsg string
	skip string
	}{
	{
	prop: "early_mutator_set_of_mutator_provider",
	module: "module_under_test",
	panicMsg: "Can't set value of provider blueprint.invalidProviderUsageMutatorInfo before mutator mutator_under_test started",
	},
	{
	prop: "late_mutator_set_of_mutator_provider",
	module: "module_under_test",
	panicMsg: "Can't set value of provider blueprint.invalidProviderUsageMutatorInfo after mutator mutator_under_test finished",
	},
	{
	prop: "late_build_actions_set_of_mutator_provider",
	module: "module_under_test",
	panicMsg: "Can't set value of provider blueprint.invalidProviderUsageMutatorInfo after mutator mutator_under_test finished",
	},
	{
	prop: "early_mutator_set_of_build_actions_provider",
	module: "module_under_test",
	panicMsg: "Can't set value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo before GenerateBuildActions started",
	},

	{
	prop: "early_mutator_get_of_mutator_provider",
	module: "module_under_test",
	panicMsg: "Can't get value of provider blueprint.invalidProviderUsageMutatorInfo before mutator mutator_under_test finished",
	},
	{
	prop: "early_mutator_get_of_build_actions_provider",
	module: "module_under_test",
	panicMsg: "Can't get value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo before GenerateBuildActions finished",
	},
	{
	prop: "duplicate_set",
	module: "module_under_test",
	panicMsg: "Value of provider blueprint.invalidProviderUsageGenerateBuildActionsInfo is already set",
	},
	}

	for _, tt := range tests {
	t.Run(tt.prop, func(t *testing.T) {
	run(t, tt.module, tt.prop, tt.panicMsg)
	})
	}
	}

	func TestInvalidSingletonProvidersUsage(t *testing.T) {
	type singletonType struct {
	name string
	factory SingletonFactory
	parallel bool
	}

	run := func(t *testing.T, singletons []singletonType, panicMsg string) {
	t.Helper()
	ctx := NewContext()
	for _, s := range singletons {
	ctx.RegisterSingletonType(s.name, s.factory, s.parallel)
	}

	ctx.MockFileSystem(map[string][]byte{
	"Android.bp": {},
	})

	_, errs := ctx.ParseBlueprintsFiles("Android.bp", nil)

	if len(errs) == 0 {
	_, errs = ctx.ResolveDependencies(nil)
	}

	if len(errs) == 0 {
	_, errs = ctx.PrepareBuildActions(nil)
	}

	if len(panicMsg) == 0 {
	if len(errs) != 0 {
	t.Fatal("got an error: ", errs)
	}
	return
	}

	if len(errs) == 0 {
	t.Fatal("expected an error")
	}

	if len(errs) > 1 {
	t.Errorf("expected a single error, got %d:", len(errs))
	for i, err := range errs {
	t.Errorf("%d: %s", i, err)
	}
	t.FailNow()
	}

	if panicErr, ok := errs[0].(panicError); ok {
	if panicErr.panic != panicMsg {
	t.Fatalf("expected panic %q, got %q", panicMsg, panicErr.panic)
	}
	} else {
	t.Fatalf("expected a panicError, got %T: %s", errs[0], errs[0].Error())
	}

	}

	tests := []struct {
	testName string
	singletons []singletonType
	panicMsg string
	}{
	{
	testName: "get_non_singleton_provider",
	singletons: []singletonType{
	{
	name: "parallel_singleton",
	factory: func() Singleton {
	return &providerTestParallelSingleton{}
	},
	parallel: true,
	},
	{
	name: "sequential_singleton",
	factory: func() Singleton {
	return &providerTestSequentialSingleton{
	getModuleProvider: true,
	}
	},
	parallel: false,
	},
	},
	panicMsg: "Can't get value of non-singleton provider *blueprint.providerTestMutatorInfo usign singleton specific get method",
	},
	{
	testName: "set_non_singleton_provider",
	singletons: []singletonType{
	{
	name: "sequential_singleton",
	factory: func() Singleton {
	return &providerTestSequentialSingleton{
	setModuleProvider: true,
	}
	},
	parallel: false,
	},
	},
	panicMsg: "Can't set value of non-singleton provider *blueprint.providerTestMutatorInfo inside singleton sequential_singleton",
	},
	{
	testName: "set_get_singleton_provider",
	singletons: []singletonType{
	{
	name: "parallel_singleton",
	factory: func() Singleton {
	return &providerTestParallelSingleton{}
	},
	parallel: true,
	},
	{
	name: "sequential_singleton",
	factory: func() Singleton {
	return &providerTestSequentialSingleton{}
	},
	parallel: false,
	},
	},
	panicMsg: "",
	},
	{
	testName: "visit_all_singletons_in_parallel_singleton",
	singletons: []singletonType{
	{
	name: "parallel_singleton",
	factory: func() Singleton {
	return &providerTestParallelSingleton{visitAllSingletons: true}
	},
	parallel: true,
	},
	},
	panicMsg: "VisitAllSingletons not allowed in parallel singletons parallel_singleton",
	},
	}

	for _, tt := range tests {
	t.Run(tt.testName, func(t *testing.T) {
	run(t, tt.singletons, tt.panicMsg)
	})
	}
	}