You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: cloudformation_test.go
    path of file: ./repos/pipeline/pkg/sdk/providers/amazon/cloudformation
    
    the code of the file until where you have to start completion: // Copyright Â© 2020 Banzai Cloud
//
// 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 cloudformation

import (
	"fmt"
	"reflect"
	"testing"

	"emperror.dev/errors"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/service/cloudformation"
	"github.com/stretchr/testify/require"

	"github.com/banzaicloud/pipeline/pkg/sdk/semver"
)

func TestDecodeStackValue(t *testing.T) {
	type inputType struct {
		inputType  reflect.Type
		outputType reflect.Type
		inputValue interface{}
	}

	type outputType struct {
		expectedOutputValue interface{}
		expectedErr         error
	}

	testCases := []struct {
		caseDescription string
		input           inputType
		output          outputType
	}{
		{
			caseDescription: "not a string stack value input -> early exit success",
			input: inputType{
				inputType:  reflect.TypeOf(0),
				outputType: reflect.TypeOf(""),
				inputValue: 5,
			},
			output: outputType{
				expectedOutputValue: 5,
				expectedErr:         nil,
			},
		},
		{
			caseDescription: "int success -> success",
			input: inputType{
				inputType:  reflect.TypeOf(""),
				outputType: reflect.TypeOf(0),
				inputValue: "5",
			},
			output: outputType{
				expectedOutputValue: 5,
				expectedErr:         nil,
			},
		},
		{
			caseDescription: "int error -> error",
			input: inputType{
				inputType:  reflect.TypeOf(""),
				outputType: reflect.TypeOf(0),
				inputValue: "value",
			},
			output: outputType{
				expectedOutputValue: 0,
				expectedErr:         
    
func TestParseStackParameters(t *testing.T) {
	type inputType struct {
		objectPointer interface{}
		parameters    []*cloudformation.Parameter
	}

	type outputType struct {
		expectedError         error
		expectedObjectPointer interface{}
	}

	type caseType struct {
		caseName string
		input    inputType
		output   outputType
	}

	testCases := []caseType{
		{
			caseName: "map[string]string -> success",
			input: inputType{
				objectPointer: &map[string]string{
					"Bool":   "",
					"Float":  "",
					"Int":    "",
					"String": "",
					"Uint":   "",
				},
				parameters: []*cloudformation.Parameter{
					{
						ParameterKey:   aws.String("Bool"),
						ParameterValue: aws.String("true"),
					},
					{
						ParameterKey:   aws.String("Extra"),
						ParameterValue: aws.String("parameter"),
					},
					{
						ParameterKey:   aws.String("Float"),
						ParameterValue: aws.String("0.5"),
					},
					{
						ParameterKey:   aws.String("Int"),
						ParameterValue: aws.String("-5"),
					},
					{
						ParameterKey:   aws.String("SemanticVersion"),
						ParameterValue: aws.String("1.2.3-dev.4"),
					},
					{
						ParameterKey:   aws.String("String"),
						ParameterValue: aws.String("value"),
					},
					{
						ParameterKey:   aws.String("Uint"),
						ParameterValue: aws.String("5"),
					},
				},
			},
			output: outputType{
				expectedError: nil,
				expectedObjectPointer: &map[string]string{
					"Bool":            "true",
					"Extra":           "parameter",
					"Float":           "0.5",
					"Int":             "-5",
					"SemanticVersion": "1.2.3-dev.4",
					"String":          "value",
					"Uint":            "5",
				},
			},
		},
		{
			caseName: "struct -> success",
			input: inputType{
				objectPointer: &struct {
					Bool            bool
					Float           float64
					Int             int
					SemanticVersion semver.Version
					String          string
					Uint            uint
				}{},
				parameters: []*cloudformation.Parameter{
					{
						ParameterKey:   aws.String("Bool"),
						ParameterValue: aws.String("true"),
					},
					{
						ParameterKey:   aws.String("Extra"),
						ParameterValue: aws.String("parameter"),
					},
					{
						ParameterKey:   aws.String("Float"),
						ParameterValue: aws.String("0.5"),
					},
					{
						ParameterKey:   aws.String("Int"),
						ParameterValue: aws.String("-5"),
					},
					{
						ParameterKey:   aws.String("SemanticVersion"),
						ParameterValue: aws.String("1.2.3-dev.4"),
					},
					{
						ParameterKey:   aws.String("String"),
						ParameterValue: aws.String("value"),
					},
					{
						ParameterKey:   aws.String("Uint"),
						ParameterValue: aws.String("5"),
					},
				},
			},
			output: outputType{
				expectedError: nil,
				expectedObjectPointer: &struct {
					Bool            bool
					Float           float64
					Int             int
					SemanticVersion semver.Version
					String          string
					Uint            uint
				}{
					Bool:            true,
					Float:           0.5,
					Int:             -5,
					SemanticVersion: semver.NewVersionFromStringOrPanic("1.2.3-dev.4"),
					String:          "value",
					Uint:            5,
				},
			},
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.caseName, func(t *testing.T) {
			actualError := ParseStackParameters(testCase.input.parameters, testCase.input.objectPointer)

			if testCase.output.expectedError == nil {
				require.Nil(t, actualError)
			} else {
				require.EqualError(t, actualError, testCase.output.expectedError.Error())
			}
			require.Equal(t, testCase.output.expectedObjectPointer, testCase.input.objectPointer)
		})
	}
}