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

import (
 "reflect"
 "testing"
)

func TestPropertyNameForField(t *testing.T) {
 tests := []struct {
  name  string
  input string
  want  string
 }{
  {
   name:  "short",
   input: "S",
   want:  "s",
  },
  {
   name:  "long",
   input: "String",
   want:  "string",
  },
  {
   name:  "uppercase",
   input: "STRING",
   want:  "STRING",
  },
  {
   name:  "mixed",
   input: "StRiNg",
   want:  "stRiNg",
  },
  {
   name:  "underscore",
   input: "Under_score",
   want:  "under_score",
  },
  {
   name:  "uppercase underscore",
   input: "UNDER_SCORE",
   want:  "UNDER_SCORE",
  },
  {
   name:  "x86",
   input: "X86",
   want:  "x86",
  },
  {
   name:  "x86_64",
   input: "X86_64",
   want:  "x86_64",
  },
 }
 for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
   if got := PropertyNameForField(tt.input); got != tt.want {
    t.Errorf("PropertyNameForField(%v) = %v, want %v", tt.input, got, tt.want)
   }
  })
 }
}

func TestFieldNameForProperty(t *testing.T) {
 tests := []struct {
  name  string
  input string
  want  string
 }{
  {
   name:  "short lowercase",
   input: "s",
   want:  "S",
  },
  {
   name:  "short uppercase",
   input: "S",
   want:  "S",
  },
  {
   name:  "long lowercase",
   input: "string",
   want:  "String",
  },
  {
   name:  "long uppercase",
   input: "STRING",
   want:  "STRING",
  },
  {
   name:  "mixed",
   input: "StRiNg",
   want:  "StRiNg",
  },
 }
 for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
   if got := FieldNameForProperty(tt.input); got != tt.want {
    t.Errorf("FieldNameForProperty(%v) = %v, want %v", tt.input, got, tt.want)
   }
  })
 }
}

func TestClearField(t *testing.T) {
 props := struct {
  i  int
  s  string
  ps *string
  ss []string
  c  struct {
   n int
  }
 }{}

 props.i = 42
 Clear(&props.i)
 if props.i != 0 {
  t.Error("int field is not cleared to zero.")
 }

 props.s = "foo"
 Clear(&props.s)
 if props.s != "" {
  t.Error("string field is not cleared to zero.")
 }

 props.ps = StringPtr("foo")
 Clear(&props.ps)
 if props.ps != nil {
  t.Error("string pointer field is not cleared to zero.")
 }

 props.ss = []string{"foo"}
 Clear(&props.ss)
 if props.ss != nil {
  t.Error("string array field is not cleared to zero.")
 }

 props.c.n = 42
 Clear(&props.c)
 if props.c.n != 0 {
  t.Error("struct field is not cleared to zero.")
 }
}

func TestIsConfigurable(t *testing.T) {
 testCases := []struct {
  name     string
  value    interface{}
  expected bool
 }{
  {
   name:     "Configurable string",
   value:    Configurable[string]{},
   expected: true,
  },
  {
   name:     "Configurable string list",
   value:    Configurable[[]string]{},
   expected: true,
  },
  {
   name:     "Configurable bool",
   value:    Configurable[bool]{},
   expected: true,
  },
  {
   name: "Other struct with a bool as the first field",
   value: struct {
    x bool
   }{},
   expected: false,
  },
 }
 for _, tc := range testCases {
  t.Run(tc.name, func(t *testing.T) {
   value := reflect.ValueOf(tc.value)
   if isConfigurable(value.Type()) != tc.expected {
    t.Errorf("Expected isConfigurable to return %t", tc.expected)
   }
  })
 }
}