github.com/westcoastroms/westcoastroms-build@v0.0.0-20190928114312-2350e5a73030/build/soong/android/neverallow_test.go (about)

     1  // Copyright 2018 Google Inc. All rights reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package android
    16  
    17  import (
    18  	"io/ioutil"
    19  	"os"
    20  	"testing"
    21  )
    22  
    23  var neverallowTests = []struct {
    24  	name          string
    25  	fs            map[string][]byte
    26  	expectedError string
    27  }{
    28  	{
    29  		name: "no vndk.enabled under vendor directory",
    30  		fs: map[string][]byte{
    31  			"vendor/Blueprints": []byte(`
    32  				cc_library {
    33  					name: "libvndk",
    34  					vendor_available: true,
    35  					vndk: {
    36  						enabled: true,
    37  					},
    38  				}`),
    39  		},
    40  		expectedError: "VNDK can never contain a library that is device dependent",
    41  	},
    42  	{
    43  		name: "no vndk.enabled under device directory",
    44  		fs: map[string][]byte{
    45  			"device/Blueprints": []byte(`
    46  				cc_library {
    47  					name: "libvndk",
    48  					vendor_available: true,
    49  					vndk: {
    50  						enabled: true,
    51  					},
    52  				}`),
    53  		},
    54  		expectedError: "VNDK can never contain a library that is device dependent",
    55  	},
    56  	{
    57  		name: "vndk-ext under vendor or device directory",
    58  		fs: map[string][]byte{
    59  			"device/Blueprints": []byte(`
    60  				cc_library {
    61  					name: "libvndk1_ext",
    62  					vendor: true,
    63  					vndk: {
    64  						enabled: true,
    65  					},
    66  				}`),
    67  			"vendor/Blueprints": []byte(`
    68  				cc_library {
    69  					name: "libvndk2_ext",
    70  					vendor: true,
    71  					vndk: {
    72  						enabled: true,
    73  					},
    74  				}`),
    75  		},
    76  		expectedError: "",
    77  	},
    78  
    79  	{
    80  		name: "no enforce_vintf_manifest.cflags",
    81  		fs: map[string][]byte{
    82  			"Blueprints": []byte(`
    83  				cc_library {
    84  					name: "libexample",
    85  					product_variables: {
    86  						enforce_vintf_manifest: {
    87  							cflags: ["-DSHOULD_NOT_EXIST"],
    88  						},
    89  					},
    90  				}`),
    91  		},
    92  		expectedError: "manifest enforcement should be independent",
    93  	},
    94  	{
    95  		name: "libhidltransport enforce_vintf_manifest.cflags",
    96  		fs: map[string][]byte{
    97  			"Blueprints": []byte(`
    98  				cc_library {
    99  					name: "libhidltransport",
   100  					product_variables: {
   101  						enforce_vintf_manifest: {
   102  							cflags: ["-DSHOULD_NOT_EXIST"],
   103  						},
   104  					},
   105  				}`),
   106  		},
   107  		expectedError: "",
   108  	},
   109  
   110  	{
   111  		name: "no treble_linker_namespaces.cflags",
   112  		fs: map[string][]byte{
   113  			"Blueprints": []byte(`
   114  				cc_library {
   115  					name: "libexample",
   116  					product_variables: {
   117  						treble_linker_namespaces: {
   118  							cflags: ["-DSHOULD_NOT_EXIST"],
   119  						},
   120  					},
   121  				}`),
   122  		},
   123  		expectedError: "nothing should care if linker namespaces are enabled or not",
   124  	},
   125  	{
   126  		name: "libc_bionic_ndk treble_linker_namespaces.cflags",
   127  		fs: map[string][]byte{
   128  			"Blueprints": []byte(`
   129  				cc_library {
   130  					name: "libc_bionic_ndk",
   131  					product_variables: {
   132  						treble_linker_namespaces: {
   133  							cflags: ["-DSHOULD_NOT_EXIST"],
   134  						},
   135  					},
   136  				}`),
   137  		},
   138  		expectedError: "",
   139  	},
   140  }
   141  
   142  func TestNeverallow(t *testing.T) {
   143  	buildDir, err := ioutil.TempDir("", "soong_neverallow_test")
   144  	if err != nil {
   145  		t.Fatal(err)
   146  	}
   147  	defer os.RemoveAll(buildDir)
   148  
   149  	config := TestConfig(buildDir, nil)
   150  
   151  	for _, test := range neverallowTests {
   152  		t.Run(test.name, func(t *testing.T) {
   153  			_, errs := testNeverallow(t, config, test.fs)
   154  
   155  			if test.expectedError == "" {
   156  				FailIfErrored(t, errs)
   157  			} else {
   158  				FailIfNoMatchingErrors(t, test.expectedError, errs)
   159  			}
   160  		})
   161  	}
   162  }
   163  
   164  func testNeverallow(t *testing.T, config Config, fs map[string][]byte) (*TestContext, []error) {
   165  	ctx := NewTestContext()
   166  	ctx.RegisterModuleType("cc_library", ModuleFactoryAdaptor(newMockCcLibraryModule))
   167  	ctx.PostDepsMutators(registerNeverallowMutator)
   168  	ctx.Register()
   169  
   170  	ctx.MockFileSystem(fs)
   171  
   172  	_, errs := ctx.ParseBlueprintsFiles("Blueprints")
   173  	if len(errs) > 0 {
   174  		return ctx, errs
   175  	}
   176  
   177  	_, errs = ctx.PrepareBuildActions(config)
   178  	return ctx, errs
   179  }
   180  
   181  type mockProperties struct {
   182  	Vendor_available *bool
   183  
   184  	Vndk struct {
   185  		Enabled                *bool
   186  		Support_system_process *bool
   187  		Extends                *string
   188  	}
   189  
   190  	Product_variables struct {
   191  		Enforce_vintf_manifest struct {
   192  			Cflags []string
   193  		}
   194  
   195  		Treble_linker_namespaces struct {
   196  			Cflags []string
   197  		}
   198  	}
   199  }
   200  
   201  type mockCcLibraryModule struct {
   202  	ModuleBase
   203  	properties mockProperties
   204  }
   205  
   206  func newMockCcLibraryModule() Module {
   207  	m := &mockCcLibraryModule{}
   208  	m.AddProperties(&m.properties)
   209  	InitAndroidModule(m)
   210  	return m
   211  }
   212  
   213  func (p *mockCcLibraryModule) DepsMutator(ctx BottomUpMutatorContext) {
   214  }
   215  
   216  func (p *mockCcLibraryModule) GenerateAndroidBuildActions(ModuleContext) {
   217  }