Quelle  repack_test.go   Sprache: unbekannt

// Copyright 2024 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 proptools

import (
 "regexp"
 "strings"
 "testing"

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

type testSymlinkStruct struct {
 Target string
 Name   string
}

type testPropStructNested struct {
 My_string_ptr *string
}

type testPropStruct struct {
 My_string                   string
 My_configurable_string      Configurable[string]
 My_configurable_string_list Configurable[[]string]
 My_string_ptr               *string
 My_string_list              []string
 My_struct_list              []testSymlinkStruct
 My_bool                     bool
 My_int                      int
 My_int64                    int64
 Nested                      testPropStructNested
}

type testPropStructOnlyConfigurableStringList struct {
 My_configurable_string_list Configurable[[]string]
}

func TestRepack(t *testing.T) {
 testCases := []struct {
  name        string
  propStructs []interface{}
  expectedBp  string
  expectedErr string
 }{
  {
   name: "Simple prop struct",
   propStructs: []interface{}{&testPropStruct{
    My_string:                   "foo",
    My_configurable_string:      NewSimpleConfigurable("qux"),
    My_configurable_string_list: NewSimpleConfigurable([]string{"a", "b", "c"}),
    My_string_ptr:               StringPtr("bar"),
    My_string_list:              []string{"foo", "bar"},
    My_struct_list: []testSymlinkStruct{
     {Name: "foo", Target: "foo_target"},
     {Name: "bar", Target: "bar_target"},
    },
    My_bool:  true,
    My_int:   5,
    My_int64: 64,
    Nested: testPropStructNested{
     My_string_ptr: StringPtr("baz"),
    },
   }},
   expectedBp: `
module {
    my_string: "foo",
    my_configurable_string: "qux",
    my_configurable_string_list: [
        "a",
        "b",
        "c",
    ],
    my_string_ptr: "bar",
    my_string_list: [
        "foo",
        "bar",
    ],
    my_struct_list: [
        {
            Target: "foo_target",
            Name: "foo",
        },
        {
            Target: "bar_target",
            Name: "bar",
        },
    ],
    my_bool: true,
    my_int: 5,
    my_int64: 64,
    nested: {
        my_string_ptr: "baz",
    },
}`,
  },
  {
   name: "Complicated select",
   propStructs: []interface{}{&testPropStructOnlyConfigurableStringList{
    My_configurable_string_list: createComplicatedSelect(),
   }},
   expectedBp: `
module {
    my_configurable_string_list: ["a"] + select((os(), arch()), {
        ("android", "x86"): [
            "android",
            "x86",
        ],
        ("android", "arm64"): [
            "android",
            "arm64",
        ],
        (default, "x86"): [
            "default",
            "x86",
        ],
        (default, default): [
            "default",
            "default",
        ],
    }) + ["b"],
}`,
  },
  {
   name: "Multiple property structs",
   propStructs: []interface{}{
    &testPropStruct{
     My_string:      "foo",
     My_string_ptr:  nil,
     My_string_list: []string{"foo", "bar"},
     My_bool:        true,
     My_int:         5,
    },
    &testPropStructNested{
     My_string_ptr: StringPtr("bar"),
    },
   },
   expectedBp: `
module {
    my_string: "foo",
    my_string_ptr: "bar",
    my_string_list: [
        "foo",
        "bar",
    ],
    my_struct_list: [],
    my_bool: true,
    my_int: 5,
    my_int64: 0,
}`,
  },
  {
   name: "Multiple conflicting property structs",
   propStructs: []interface{}{
    &testPropStruct{
     My_string:      "foo",
     My_string_ptr:  StringPtr("foo"),
     My_string_list: []string{"foo", "bar"},
     My_bool:        true,
     My_int:         5,
    },
    &testPropStructNested{
     My_string_ptr: StringPtr("bar"),
    },
   },
   expectedErr: `Conflicting fields in property structs had values "foo" and "bar"`,
  },
 }

 for _, tc := range testCases {
  t.Run(tc.name, func(t *testing.T) {
   result, err := RepackProperties(tc.propStructs)
   if err != nil {
    if tc.expectedErr != "" {
     match, err2 := regexp.MatchString(tc.expectedErr, err.Error())
     if err2 != nil {
      t.Fatal(err2)
     }
     if !match {
      t.Fatalf("Expected error matching %q, found %q", tc.expectedErr, err.Error())
     }
     return
    } else {
     t.Fatal(err)
    }
   } else if tc.expectedErr != "" {
    t.Fatalf("Expected error matching %q, but got success", tc.expectedErr)
   }
   file := &parser.File{
    Defs: []parser.Definition{
     &parser.Module{
      Type: "module",
      Map:  *result,
     },
    },
   }
   bytes, err := parser.Print(file)
   if err != nil {
    t.Fatal(err)
   }
   expected := strings.TrimSpace(tc.expectedBp)
   actual := strings.TrimSpace(string(bytes))
   if expected != actual {
    t.Fatalf("Expected:\n%s\nBut found:\n%s\n", expected, actual)
   }
  })
 }
}

func createComplicatedSelect() Configurable[[]string] {
 result := NewSimpleConfigurable([]string{"a"})
 result.Append(NewConfigurable([]ConfigurableCondition{
  NewConfigurableCondition("os", nil),
  NewConfigurableCondition("arch", nil),
 }, []ConfigurableCase[[]string]{
  NewConfigurableCase([]ConfigurablePattern{
   NewStringConfigurablePattern("android"),
   NewStringConfigurablePattern("x86"),
  }, &[]string{"android", "x86"}),
  NewConfigurableCase([]ConfigurablePattern{
   NewStringConfigurablePattern("android"),
   NewStringConfigurablePattern("arm64"),
  }, &[]string{"android", "arm64"}),
  NewConfigurableCase([]ConfigurablePattern{
   NewDefaultConfigurablePattern(),
   NewStringConfigurablePattern("x86"),
  }, &[]string{"default", "x86"}),
  NewConfigurableCase([]ConfigurablePattern{
   NewDefaultConfigurablePattern(),
   NewDefaultConfigurablePattern(),
  }, &[]string{"default", "default"}),
 }))
 result.Append(NewSimpleConfigurable([]string{"b"}))
 return result
}