styleparam_test.go

// Copyright 2019 DeepMap, Inc.
//
// 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 runtime

import (
	"fmt"
	"testing"
	"time"

	"github.com/google/uuid"
	"github.com/oapi-codegen/runtime/types"
	"github.com/stretchr/testify/assert"
)

func TestStyleParam(t *testing.T) {
	primitive := 5
	primitiveString := "123"
	primitiveStringWithReservedChar := "123;456"
	array := []int{3, 4, 5}
	type TestObject struct {
		FirstName string `json:"firstName"`
		Role      string `json:"role"`
	}
	object := TestObject{
		FirstName: "Alex",
		Role:      "admin",
	}
	dict := map[string]interface{}{}
	dict["firstName"] = "Alex"
	dict["role"] = "admin"

	type AliasedTime time.Time
	ti, _ := time.Parse(time.RFC3339, "2020-01-01T22:00:00+02:00")
	timestamp := AliasedTime(ti)

	type AliasedDate types.Date
	date := AliasedDate{Time: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)}

	type AliasedUUID types.UUID
	aUUID := AliasedUUID(uuid.MustParse("baa07328-452e-40bd-aa2e-fa823ec13605"))

	// ---------------------------- Simple Style -------------------------------

	result, err := StyleParamWithLocation("simple", false, "id", ParamLocationQuery, primitive)
	assert.NoError(t, err)
	assert.EqualValues(t, "5", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, primitive)
	assert.NoError(t, err)
	assert.EqualValues(t, "5", result)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, "3,4,5", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, "3,4,5", result)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, object)
	assert.NoError(t, err)
	assert.EqualValues(t, "firstName,Alex,role,admin", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, object)
	assert.NoError(t, err)
	assert.EqualValues(t, "firstName=Alex,role=admin", result)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, dict)
	assert.NoError(t, err)
	assert.EqualValues(t, "firstName,Alex,role,admin", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, dict)
	assert.NoError(t, err)
	assert.EqualValues(t, "firstName=Alex,role=admin", result)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, "2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, "2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, &timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, "2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, &timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, "2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, date)
	assert.NoError(t, err)
	assert.EqualValues(t, "2020-01-01", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, date)
	assert.NoError(t, err)
	assert.EqualValues(t, "2020-01-01", result)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, &date)
	assert.NoError(t, err)
	assert.EqualValues(t, "2020-01-01", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, &date)
	assert.NoError(t, err)
	assert.EqualValues(t, "2020-01-01", result)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, "baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, "baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, &aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, "baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("simple", true, "id", ParamLocationQuery, &aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, "baa07328-452e-40bd-aa2e-fa823ec13605", result)

	// ----------------------------- Label Style -------------------------------

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, primitive)
	assert.NoError(t, err)
	assert.EqualValues(t, ".5", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, primitive)
	assert.NoError(t, err)
	assert.EqualValues(t, ".5", result)

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, ".3,4,5", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, ".3.4.5", result)

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, object)
	assert.NoError(t, err)
	assert.EqualValues(t, ".firstName,Alex,role,admin", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, object)
	assert.NoError(t, err)
	assert.EqualValues(t, ".firstName=Alex.role=admin", result)

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, dict)
	assert.NoError(t, err)
	assert.EqualValues(t, ".firstName,Alex,role,admin", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, dict)
	assert.NoError(t, err)
	assert.EqualValues(t, ".firstName=Alex.role=admin", result)

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, ".2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, ".2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, &timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, ".2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, &timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, ".2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, date)
	assert.NoError(t, err)
	assert.EqualValues(t, ".2020-01-01", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, date)
	assert.NoError(t, err)
	assert.EqualValues(t, ".2020-01-01", result)

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, &date)
	assert.NoError(t, err)
	assert.EqualValues(t, ".2020-01-01", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, &date)
	assert.NoError(t, err)
	assert.EqualValues(t, ".2020-01-01", result)

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, ".baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, ".baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("label", false, "id", ParamLocationQuery, &aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, ".baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("label", true, "id", ParamLocationQuery, &aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, ".baa07328-452e-40bd-aa2e-fa823ec13605", result)

	// ----------------------------- Matrix Style ------------------------------

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, primitive)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=5", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, primitive)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=5", result)

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=3,4,5", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=3;id=4;id=5", result)

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, object)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=firstName,Alex,role,admin", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, object)
	assert.NoError(t, err)
	assert.EqualValues(t, ";firstName=Alex;role=admin", result)

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, dict)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=firstName,Alex,role,admin", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, dict)
	assert.NoError(t, err)
	assert.EqualValues(t, ";firstName=Alex;role=admin", result)

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, &timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, &timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, date)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=2020-01-01", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, date)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=2020-01-01", result)

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, &date)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=2020-01-01", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, &date)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=2020-01-01", result)

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("matrix", false, "id", ParamLocationQuery, &aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("matrix", true, "id", ParamLocationQuery, &aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, ";id=baa07328-452e-40bd-aa2e-fa823ec13605", result)

	// ------------------------------ Form Style -------------------------------
	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, primitive)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=5", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, primitive)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=5", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, primitiveString)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=123", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, primitiveString)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=123", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, primitiveStringWithReservedChar)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=123%3B456", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, primitiveStringWithReservedChar)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=123%3B456", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=3,4,5", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=3&id=4&id=5", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, object)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=firstName,Alex,role,admin", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, object)
	assert.NoError(t, err)
	assert.EqualValues(t, "firstName=Alex&role=admin", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, dict)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=firstName,Alex,role,admin", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, dict)
	assert.NoError(t, err)
	assert.EqualValues(t, "firstName=Alex&role=admin", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, &timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, &timestamp)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=2020-01-01T22%3A00%3A00%2B02%3A00", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, date)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=2020-01-01", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, date)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=2020-01-01", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, &date)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=2020-01-01", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, &date)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=2020-01-01", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("form", false, "id", ParamLocationQuery, &aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=baa07328-452e-40bd-aa2e-fa823ec13605", result)

	result, err = StyleParamWithLocation("form", true, "id", ParamLocationQuery, &aUUID)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=baa07328-452e-40bd-aa2e-fa823ec13605", result)

	// ------------------------  spaceDelimited Style --------------------------

	_, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, primitive)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, primitive)
	assert.Error(t, err)

	result, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=3 4 5", result)

	result, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=3&id=4&id=5", result)

	_, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, object)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, object)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, dict)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, dict)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, &timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, &timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, &date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, &date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, aUUID)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, aUUID)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", false, "id", ParamLocationQuery, &aUUID)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("spaceDelimited", true, "id", ParamLocationQuery, &aUUID)
	assert.Error(t, err)

	// -------------------------  pipeDelimited Style --------------------------

	_, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, primitive)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, primitive)
	assert.Error(t, err)

	result, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=3|4|5", result)

	result, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, "id=3&id=4&id=5", result)

	_, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, object)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, object)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, dict)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, dict)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, &timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, &timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, &date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, &date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, aUUID)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, aUUID)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", false, "id", ParamLocationQuery, &aUUID)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("pipeDelimited", true, "id", ParamLocationQuery, &aUUID)
	assert.Error(t, err)

	// ---------------------------  deepObject Style ---------------------------
	_, err = StyleParamWithLocation("deepObject", false, "id", ParamLocationQuery, primitive)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, primitive)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", false, "id", ParamLocationQuery, array)
	assert.Error(t, err)

	result, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, array)
	assert.NoError(t, err)
	assert.EqualValues(t, "id[0]=3&id[1]=4&id[2]=5", result)

	_, err = StyleParamWithLocation("deepObject", false, "id", ParamLocationQuery, object)
	assert.Error(t, err)

	result, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, object)
	assert.NoError(t, err)
	assert.EqualValues(t, "id[firstName]=Alex&id[role]=admin", result)

	result, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, dict)
	assert.NoError(t, err)
	assert.EqualValues(t, "id[firstName]=Alex&id[role]=admin", result)

	_, err = StyleParamWithLocation("deepObject", false, "id", ParamLocationQuery, timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", false, "id", ParamLocationQuery, &timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, &timestamp)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", false, "id", ParamLocationQuery, date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", false, "id", ParamLocationQuery, &date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, &date)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", false, "id", ParamLocationQuery, aUUID)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, aUUID)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", false, "id", ParamLocationQuery, &aUUID)
	assert.Error(t, err)

	_, err = StyleParamWithLocation("deepObject", true, "id", ParamLocationQuery, &aUUID)
	assert.Error(t, err)

	// Misc tests
	// Test type aliases
	type StrType string
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, StrType("test"))
	assert.NoError(t, err)
	assert.EqualValues(t, "test", result)

	type IntType int32
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, IntType(7))
	assert.NoError(t, err)
	assert.EqualValues(t, "7", result)

	type UintType uint
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, UintType(9))
	assert.NoError(t, err)
	assert.EqualValues(t, "9", result)

	type Uint8Type uint8
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, Uint8Type(9))
	assert.NoError(t, err)
	assert.EqualValues(t, "9", result)

	type Uint16Type uint16
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, Uint16Type(9))
	assert.NoError(t, err)
	assert.EqualValues(t, "9", result)

	type Uint32Type uint32
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, Uint32Type(9))
	assert.NoError(t, err)
	assert.EqualValues(t, "9", result)

	type Uint64Type uint64
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, Uint64Type(9))
	assert.NoError(t, err)
	assert.EqualValues(t, "9", result)

	type FloatType64 float64
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, FloatType64(7.5))
	assert.NoError(t, err)
	assert.EqualValues(t, "7.5", result)

	type FloatType32 float32
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, FloatType32(1.05))
	assert.NoError(t, err)
	assert.EqualValues(t, "1.05", result)

	uuidValue := uuid.MustParse("c2d07ba4-5106-4eab-bcad-0bd6068dcb1a")
	result, err = StyleParamWithLocation("simple", false, "foo", ParamLocationQuery, types.UUID(uuidValue))
	assert.NoError(t, err)
	assert.EqualValues(t, "c2d07ba4-5106-4eab-bcad-0bd6068dcb1a", result)

	// Test that we handle optional fields
	type TestObject2 struct {
		FirstName *string `json:"firstName"`
		Role      *string `json:"role"`
	}
	name := "Alex"
	role := "admin"
	object2 := TestObject2{
		FirstName: &name,
		Role:      &role,
	}
	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, object2)
	assert.NoError(t, err)
	assert.EqualValues(t, "firstName,Alex,role,admin", result)

	// Nullable fields need to be excluded when null
	object2.Role = nil
	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, object2)
	assert.NoError(t, err)
	assert.EqualValues(t, "firstName,Alex", result)

	// Test handling of other known types inside objects
	type testObject3 struct {
		TimeField time.Time  `json:"time_field"`
		DateField types.Date `json:"date_field"`
		UUIDField types.UUID `json:"uuid_field"`
	}
	timeVal := time.Date(1996, time.March, 19, 0, 0, 0, 0, time.UTC)
	dateVal := types.Date{
		Time: timeVal,
	}
	uuidVal := uuid.MustParse("baa07328-452e-40bd-aa2e-fa823ec13605")

	object3 := testObject3{
		TimeField: timeVal,
		DateField: dateVal,
		UUIDField: uuidVal,
	}

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, object3)
	assert.NoError(t, err)
	assert.EqualValues(t, "date_field,1996-03-19,time_field,1996-03-19T00%3A00%3A00Z,uuid_field,baa07328-452e-40bd-aa2e-fa823ec13605", result)

	// Test handling of struct that implement encoding.TextMarshaler
	timeVal = time.Date(1996, time.March, 19, 0, 0, 0, 0, time.UTC)

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, timeVal)
	assert.NoError(t, err)
	assert.EqualValues(t, "1996-03-19T00%3A00%3A00Z", result)

	uuidD := uuid.MustParse("972beb41-e5ea-4b31-a79a-96f4999d8769")

	result, err = StyleParamWithLocation("simple", false, "id", ParamLocationQuery, uuidD)
	assert.NoError(t, err)
	assert.EqualValues(t, "972beb41-e5ea-4b31-a79a-96f4999d8769", result)

}

// TestStyleParam_ByteSlice tests that StyleParamWithLocation correctly handles
// []byte values by base64-encoding them as a single string, rather than treating
// them as a generic slice of uint8 values.
// See: https://github.com/oapi-codegen/runtime/issues/97
func TestStyleParam_ByteSlice(t *testing.T) {
	input := []byte("test")

	tests := []struct {
		name     string
		style    string
		explode  bool
		expected string
	}{
		{"simple/no-explode", "simple", false, "dGVzdA%3D%3D"},
		{"simple/explode", "simple", true, "dGVzdA%3D%3D"},
		{"label/no-explode", "label", false, ".dGVzdA%3D%3D"},
		{"label/explode", "label", true, ".dGVzdA%3D%3D"},
		{"matrix/no-explode", "matrix", false, ";data=dGVzdA%3D%3D"},
		{"matrix/explode", "matrix", true, ";data=dGVzdA%3D%3D"},
		{"form/no-explode", "form", false, "data=dGVzdA%3D%3D"},
		{"form/explode", "form", true, "data=dGVzdA%3D%3D"},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result, err := StyleParamWithOptions(tc.style, tc.explode, "data", input, StyleParamOptions{
				ParamLocation: ParamLocationQuery,
				Type:          "string",
				Format:        "byte",
			})
			assert.NoError(t, err)
			assert.EqualValues(t, tc.expected, result)
		})
	}
}

// Issue 37 - https://github.com/oapi-codegen/runtime/issues/37
func TestIssue37(t *testing.T) {
	styles := []string{
		"simple",
		"spaceDelimited",
		"pipeDelimited",
		"deepObject",
		"form",
		"matrix",
		"label",
	}
	values := []struct {
		name  string
		value interface{}
	}{
		{"int", map[string]int{"k1": 1, "k2": 2, "k3": 3}},
		{"string", map[string]string{"k1": "v1", "k2": "v2", "k3": "v3"}},
		{"any", map[string]any{"k1": "v1", "k2": 2, "k3": 3.5}},
	}
	for _, style := range styles {
		for _, value := range values {
			t.Run(fmt.Sprintf("%s %s", value.name, style), func(t *testing.T) {
				_, err := StyleParamWithLocation("form", true, "priority", ParamLocationQuery, value.value)
				assert.NoError(t, err)
			})
		}
	}
}

func TestStyleParamAllowReserved(t *testing.T) {
	opts := func(allowReserved bool) StyleParamOptions {
		return StyleParamOptions{
			ParamLocation: ParamLocationQuery,
			AllowReserved: allowReserved,
		}
	}

	t.Run("primitive with reserved chars", func(t *testing.T) {
		// Semicolons and colons are RFC 3986 reserved characters.
		value := "List(79988552,27056405)"

		result, err := StyleParamWithOptions("form", false, "ids", value, opts(false))
		assert.NoError(t, err)
		assert.EqualValues(t, "ids=List%2879988552%2C27056405%29", result, "reserved chars should be encoded when allowReserved=false")

		result, err = StyleParamWithOptions("form", false, "ids", value, opts(true))
		assert.NoError(t, err)
		assert.EqualValues(t, "ids=List(79988552,27056405)", result, "reserved chars should be preserved when allowReserved=true")
	})

	t.Run("primitive with colons and slashes", func(t *testing.T) {
		value := "2020-01-01T22:00:00+02:00"

		result, err := StyleParamWithOptions("form", false, "ts", value, opts(false))
		assert.NoError(t, err)
		assert.EqualValues(t, "ts=2020-01-01T22%3A00%3A00%2B02%3A00", result)

		result, err = StyleParamWithOptions("form", false, "ts", value, opts(true))
		assert.NoError(t, err)
		assert.EqualValues(t, "ts=2020-01-01T22:00:00+02:00", result)
	})

	t.Run("array with reserved chars in values", func(t *testing.T) {
		values := []string{"a;b", "c:d"}

		result, err := StyleParamWithOptions("form", false, "items", values, opts(false))
		assert.NoError(t, err)
		assert.EqualValues(t, "items=a%3Bb,c%3Ad", result)

		result, err = StyleParamWithOptions("form", false, "items", values, opts(true))
		assert.NoError(t, err)
		assert.EqualValues(t, "items=a;b,c:d", result)
	})

	t.Run("array exploded with reserved chars", func(t *testing.T) {
		values := []string{"a;b", "c:d"}

		result, err := StyleParamWithOptions("form", true, "items", values, opts(false))
		assert.NoError(t, err)
		assert.EqualValues(t, "items=a%3Bb&items=c%3Ad", result)

		result, err = StyleParamWithOptions("form", true, "items", values, opts(true))
		assert.NoError(t, err)
		assert.EqualValues(t, "items=a;b&items=c:d", result)
	})

	t.Run("spaces still encoded with allowReserved", func(t *testing.T) {
		value := "hello world"

		result, err := StyleParamWithOptions("form", false, "q", value, opts(true))
		assert.NoError(t, err)
		assert.EqualValues(t, "q=hello%20world", result, "spaces should still be encoded even with allowReserved=true")
	})

	t.Run("allowReserved has no effect on non-query locations", func(t *testing.T) {
		value := "a;b"

		// Path params should still encode regardless of allowReserved.
		result, err := StyleParamWithOptions("simple", false, "id", value, StyleParamOptions{
			ParamLocation: ParamLocationPath,
			AllowReserved: true,
		})
		assert.NoError(t, err)
		assert.EqualValues(t, "a%3Bb", result, "path params should always encode reserved chars")
	})

	t.Run("zero value preserves existing behavior", func(t *testing.T) {
		value := "123;456"

		// Default (AllowReserved: false) should match existing behavior.
		result, err := StyleParamWithOptions("form", false, "id", value, StyleParamOptions{
			ParamLocation: ParamLocationQuery,
		})
		assert.NoError(t, err)
		assert.EqualValues(t, "id=123%3B456", result)
	})
}

func TestStyleParamNameEncoding(t *testing.T) {
	opts := StyleParamOptions{ParamLocation: ParamLocationQuery}

	t.Run("brackets in param name are encoded for query", func(t *testing.T) {
		result, err := StyleParamWithOptions("form", true, "user_ids[]", []string{"1", "100"}, opts)
		assert.NoError(t, err)
		assert.EqualValues(t, "user_ids%5B%5D=1&user_ids%5B%5D=100", result)
	})

	t.Run("brackets in param name non-exploded", func(t *testing.T) {
		result, err := StyleParamWithOptions("form", false, "user_ids[]", []string{"1", "100"}, opts)
		assert.NoError(t, err)
		assert.EqualValues(t, "user_ids%5B%5D=1,100", result)
	})

	t.Run("brackets in primitive param name", func(t *testing.T) {
		result, err := StyleParamWithOptions("form", false, "filter[name]", "foo", opts)
		assert.NoError(t, err)
		assert.EqualValues(t, "filter%5Bname%5D=foo", result)
	})

	t.Run("simple alphanumeric name unchanged", func(t *testing.T) {
		result, err := StyleParamWithOptions("form", false, "color", "blue", opts)
		assert.NoError(t, err)
		assert.EqualValues(t, "color=blue", result)
	})

	t.Run("path param name not encoded", func(t *testing.T) {
		// Path params use the name in matrix style prefix
		result, err := StyleParamWithOptions("matrix", false, "id", "5", StyleParamOptions{
			ParamLocation: ParamLocationPath,
		})
		assert.NoError(t, err)
		assert.EqualValues(t, ";id=5", result)
	})

	t.Run("deepObject param name not yet encoded", func(t *testing.T) {
		// NOTE: MarshalDeepObject handles its own serialization and does not
		// currently encode param names. This documents the current behavior.
		type Obj struct {
			Name string `json:"name"`
		}
		result, err := StyleParamWithOptions("deepObject", true, "filter[]", Obj{Name: "foo"}, opts)
		assert.NoError(t, err)
		assert.EqualValues(t, "filter[][name]=foo", result)
	})
}