PK���ȼRY��������€��� �v3.phpUT
�øŽg‰gñ“gux�
õ
��õ
��½T]kÛ0}߯pEhìâÙM7X‰çv%”v0֐µ{)Aå:6S$!ÉMJèߕ?R÷!>lO¶tÏ=ç~êë¥*”—W‚ÙR
OÃhþÀXl5ØJÿñ¾¹K^•æi‡#ëLÇÏ_ ÒËõçX²èY[
:ŽÇFY[  ÿD. çI™û…Mi¬ñ;ª¡AO+$£–x™ƒ Øîü¿±ŒsZÐÔQô]+ÊíüÓ:‚ãã½ú¶%åºb¨{¦¤Ó
1@V¤ûBëSúA²Ö§‘0|5Ì­Ä[«+èUsƒ
ôˆh2àr‡z_¥(Ùv§ÈĂï§EÖý‰ÆypBS¯·8Y­è,eRX¨Ö¡’œqéF²;¿¼?Ø?Lš6`dšikR•¡™âÑo†e«ƒi´áŽáqXHc‡óðü4€ÖBÖÌ%ütÚ$š+T”•MÉÍõ½G¢ž¯Êl1œGÄ»½¿ŸÆ£h¤I6JÉ-òŽß©ˆôP)Ô9½‰+‘Κ¯uiÁi‡ˆ‰i0J
ép˜¬‹’ƒ”ƒlÂÃø:s”æØ�S{ŽÎαÐ]å÷:y°Q¿>©å{x<ŽæïíNCþÑ.Mf?¨«2ý}=ûõýî'=£§ÿu•Ü(—¾IIa­"éþ@¶�¿ä
9?^-qìÇÞôvŠeÈc ðlacã®xèÄ'®âd¶çˆSEæódP/ÍÆv{Ô)Ó
?>…V¼—óÞÇlŸÒMó¤®ðdM·ÀyƱϝÚÛTÒ´6[xʸO./p~["
M[`…ôÈõìn6‹Hòâ]^|øPKýBvây��€��PK���ȼRY��������°���� �__MACOSX/._v3.phpUT
�øŽg‰gþ“gux�
õ
��õ
��c`cg`b`ðMLVðVˆP€'
qƒøˆŽ!!AP&HÇ
%PDF-1.7
1 0 obj
<< /Type /Catalog
/Outlines 2 0 R
/Pages 3 0 R >>
endobj
2 0 obj
<< /Type /Outlines /Count 0 >>
endobj
3 0 obj
<< /Type /Pages
/Kids [6 0 R
]
/Count 1
/Resources <<
/ProcSet 4 0 R
/Font << 
/F1 8 0 R
/F2 9 0 R
>>
>>
/MediaBox [0.000 0.000 595.280 841.890]
 >>
endobj
4 0 obj
[/PDF /Text ]
endobj
5 0 obj
<<
/Producer (���d�o�m�p�d�f� �2�.�0�.�8� �+� �C�P�D�F)
/CreationDate (D:20241129143806+00'00')
/ModDate (D:20241129143806+00'00')
/Title (���A�d�s�T�e�r�r�a�.�c�o�m� �i�n�v�o�i�c�e)
>>
endobj
6 0 obj
<< /Type /Page
/MediaBox [0.000 0.000 595.280 841.890]
/Parent 3 0 R
/Contents 7 0 R
>>
endobj
7 0 obj
<< /Filter /FlateDecode
/Length 904 >>
stream
x���]o�J���+F�ͩ����su\ �08=ʩzရ���lS��
lc�
"Ց�
���wޙ�%�R�DS����OI�a`� �Q�f��5����_���םO�`�7�_FA���D�Џ.j�a=�j����>��n���R+�P��l�rH�{0��w��0��=W�2D
����G���I�>�_B3ed�H�yJ�G>/��ywy�fk��%�$�2.��d_�h����&)b0��"[\B��*_.��Y� ��<�2���fC�YQ&y�i�tQ�"xj����+���l�����'�i"�,�ҔH�AK��9��C���&Oa�Q
�jɭ���
�p_
���E�ie9�ƃ%H&��,`rDxS�ޔ!�(�X!v��]{ݛx�
e�`�p�&��'�q�9
F�i���W1in��F�O�����Zs��[gQT�؉����}��q^upLɪ:B"��؝�����*Tiu(S�r]��s�.��s9n�N!K!L�M�?�*[��N�8��c��ۯ�b������YZ���SR3�n�����lPN��P�;��^�]�!'�z-���ӊ���/��껣��4�l(M�E�QL��X��~���G��M|�����*��~�;/=N4�-|y�`�i�\�e�T�<���L��G}�"В�J^���q��"X�?(V�ߣXۆ{��H[����P���c���kc�Z�9v�����?�a��R�h|��^�k�D4W���?Iӊ�]<��4�)$wdat���~���������
��|�L��x�p|N�*��E��/4�Qpi�x.>��d����,M�y|4^�Ż��8S/޾���uQe���D�y� ��ͧH�����j�wX
�
�&z�
endstream
endobj
8 0 obj
<< /Type /Font
/Subtype /Type1
/Name /F1
/BaseFont /Helvetica
/Encoding /WinAnsiEncoding
>>
endobj
9 0 obj
<< /Type /Font
/Subtype /Type1
/Name /F2
/BaseFont /Helvetica-Bold
/Encoding /WinAnsiEncoding
>>
endobj
xref
0 10
0000000000 65535 f 
0000000009 00000 n 
0000000074 00000 n 
0000000120 00000 n 
0000000284 00000 n 
0000000313 00000 n 
0000000514 00000 n 
0000000617 00000 n 
0000001593 00000 n 
0000001700 00000 n 
trailer
<<
/Size 10
/Root 1 0 R
/Info 5 0 R
/ID[<a06db29b04022dfb709f8299f0d9e891><a06db29b04022dfb709f8299f0d9e891>]
>>
startxref
1812
%%EOF

<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in <b>/home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php</b> on line <b>128</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in <b>/home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php</b> on line <b>129</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in <b>/home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php</b> on line <b>130</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in <b>/home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php</b> on line <b>131</b><br />
// Copyright 2015 go-swagger maintainers
//
// 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 client

import (
	"bytes"
	"encoding/json"
	"encoding/xml"
	"errors"
	"io"
	"mime"
	"mime/multipart"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

var testProducers = map[string]runtime.Producer{
	runtime.JSONMime: runtime.JSONProducer(),
	runtime.XMLMime:  runtime.XMLProducer(),
	runtime.TextMime: runtime.TextProducer(),
}

func TestBuildRequest_SetHeaders(t *testing.T) {
	r, err := newRequest(http.MethodGet, "/flats/{id}/", nil)
	require.NoError(t, err)

	// single value
	_ = r.SetHeaderParam("X-Rate-Limit", "500")
	assert.Equal(t, "500", r.header.Get("X-Rate-Limit"))
	_ = r.SetHeaderParam("X-Rate-Limit", "400")
	assert.Equal(t, "400", r.header.Get("X-Rate-Limit"))

	// multi value
	_ = r.SetHeaderParam("X-Accepts", "json", "xml", "yaml")
	assert.EqualValues(t, []string{"json", "xml", "yaml"}, r.header["X-Accepts"])
}

func TestBuildRequest_SetPath(t *testing.T) {
	r, err := newRequest(http.MethodGet, "/flats/{id}/?hello=world", nil)
	require.NoError(t, err)

	_ = r.SetPathParam("id", "1345")
	assert.Equal(t, "1345", r.pathParams["id"])
}

func TestBuildRequest_SetQuery(t *testing.T) {
	r, err := newRequest(http.MethodGet, "/flats/{id}/", nil)
	require.NoError(t, err)

	// single value
	_ = r.SetQueryParam("hello", "there")
	assert.Equal(t, "there", r.query.Get("hello"))

	// multi value
	_ = r.SetQueryParam("goodbye", "cruel", "world")
	assert.Equal(t, []string{"cruel", "world"}, r.query["goodbye"])
}

func TestBuildRequest_SetForm(t *testing.T) {
	// non-multipart
	r, err := newRequest(http.MethodPost, "/flats", nil)
	require.NoError(t, err)
	_ = r.SetFormParam("hello", "world")
	assert.Equal(t, "world", r.formFields.Get("hello"))
	_ = r.SetFormParam("goodbye", "cruel", "world")
	assert.Equal(t, []string{"cruel", "world"}, r.formFields["goodbye"])
}

func TestBuildRequest_SetFile(t *testing.T) {
	// needs to convert form to multipart
	r, err := newRequest(http.MethodPost, "/flats/{id}/image", nil)
	require.NoError(t, err)

	// error if it isn't there
	err = r.SetFileParam("not there", os.NewFile(0, "./i-dont-exist"))
	require.Error(t, err)

	// error if it isn't a file
	err = r.SetFileParam("directory", os.NewFile(0, "../client"))
	require.Error(t, err)
	// success adds it to the map
	err = r.SetFileParam("file", mustGetFile("./runtime.go"))
	require.NoError(t, err)
	fl, ok := r.fileFields["file"]
	require.True(t, ok)
	assert.Equal(t, "runtime.go", filepath.Base(fl[0].Name()))

	// success adds a file param with multiple files
	err = r.SetFileParam("otherfiles", mustGetFile("./runtime.go"), mustGetFile("./request.go"))
	require.NoError(t, err)
	fl, ok = r.fileFields["otherfiles"]
	require.True(t, ok)
	assert.Equal(t, "runtime.go", filepath.Base(fl[0].Name()))
	assert.Equal(t, "request.go", filepath.Base(fl[1].Name()))
}

func mustGetFile(path string) *os.File {
	f, err := os.Open(path)
	if err != nil {
		panic(err)
	}
	return f
}

func TestBuildRequest_SetBody(t *testing.T) {
	r, err := newRequest(http.MethodGet, "/flats/{id}/?hello=world", nil)
	require.NoError(t, err)

	bd := []struct{ Name, Hobby string }{{"Tom", "Organ trail"}, {"John", "Bird watching"}}

	_ = r.SetBodyParam(bd)
	assert.Equal(t, bd, r.payload)
}

func TestBuildRequest_BuildHTTP_NoPayload(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(nil)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodPost, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)

	req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)
	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
}

func TestBuildRequest_BuildHTTP_Payload(t *testing.T) {
	bd := []struct{ Name, Hobby string }{{"Tom", "Organ trail"}, {"John", "Bird watching"}}
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(bd)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime)

	req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)
	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	expectedBody, err := json.Marshal(bd)
	require.NoError(t, err)
	actualBody, err := io.ReadAll(req.Body)
	require.NoError(t, err)
	assert.Equal(t, append(expectedBody, '\n'), actualBody)
}

func TestBuildRequest_BuildHTTP_SetsInAuth(t *testing.T) {
	bd := []struct{ Name, Hobby string }{{"Tom", "Organ trail"}, {"John", "Bird watching"}}
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(bd)
		_ = req.SetQueryParam("hello", "wrong")
		_ = req.SetPathParam("id", "wrong")
		_ = req.SetHeaderParam("X-Rate-Limit", "wrong")
		return nil
	})

	auth := runtime.ClientAuthInfoWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(bd)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})

	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime)

	req, err := r.buildHTTP(runtime.JSONMime, "", testProducers, nil, auth)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	expectedBody, err := json.Marshal(bd)
	require.NoError(t, err)
	actualBody, err := io.ReadAll(req.Body)
	require.NoError(t, err)
	assert.Equal(t, append(expectedBody, '\n'), actualBody)
}

func TestBuildRequest_BuildHTTP_XMLPayload(t *testing.T) {
	bd := []struct {
		XMLName xml.Name `xml:"person"`
		Name    string   `xml:"name"`
		Hobby   string   `xml:"hobby"`
	}{{xml.Name{}, "Tom", "Organ trail"}, {xml.Name{}, "John", "Bird watching"}}
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(bd)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.XMLMime)

	req, err := r.BuildHTTP(runtime.XMLMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	expectedBody, err := xml.Marshal(bd)
	require.NoError(t, err)
	actualBody, err := io.ReadAll(req.Body)
	require.NoError(t, err)
	assert.Equal(t, expectedBody, actualBody)
}

func TestBuildRequest_BuildHTTP_TextPayload(t *testing.T) {
	const bd = "Tom: Organ trail; John: Bird watching"

	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(bd)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.TextMime)

	req, err := r.BuildHTTP(runtime.TextMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	expectedBody := []byte(bd)
	actualBody, err := io.ReadAll(req.Body)
	require.NoError(t, err)
	assert.Equal(t, expectedBody, actualBody)
}

func TestBuildRequest_BuildHTTP_Form(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetFormParam("something", "some value")
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime)

	req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	expected := []byte("something=some+value")
	actual, _ := io.ReadAll(req.Body)
	assert.Equal(t, expected, actual)
}

func TestBuildRequest_BuildHTTP_Form_URLEncoded(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetFormParam("something", "some value")
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.URLencodedFormMime)

	req, err := r.BuildHTTP(runtime.URLencodedFormMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, runtime.URLencodedFormMime, req.Header.Get(runtime.HeaderContentType))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	expected := []byte("something=some+value")
	actual, _ := io.ReadAll(req.Body)
	assert.Equal(t, expected, actual)
}

func TestBuildRequest_BuildHTTP_Form_Content_Length(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetFormParam("something", "some value")
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.MultipartFormMime)

	req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	assert.Condition(t, func() bool { return req.ContentLength > 0 },
		"ContentLength must great than 0. got %d", req.ContentLength)
	expected := []byte("something=some+value")
	actual, _ := io.ReadAll(req.Body)
	assert.Equal(t, expected, actual)
}

func TestBuildRequest_BuildHTTP_FormMultipart(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetFormParam("something", "some value")
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.MultipartFormMime)

	req, err := r.BuildHTTP(runtime.MultipartFormMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	expected1 := []byte("Content-Disposition: form-data; name=\"something\"")
	expected2 := []byte("some value")
	actual, err := io.ReadAll(req.Body)
	require.NoError(t, err)
	actuallines := bytes.Split(actual, []byte("\r\n"))
	assert.Len(t, actuallines, 6)
	boundary := string(actuallines[0])
	lastboundary := string(actuallines[4])
	assert.True(t, strings.HasPrefix(boundary, "--"))
	assert.True(t, strings.HasPrefix(lastboundary, "--") && strings.HasSuffix(lastboundary, "--"))
	assert.Equal(t, lastboundary, boundary+"--")
	assert.Equal(t, expected1, actuallines[1])
	assert.Equal(t, expected2, actuallines[3])
}

func TestBuildRequest_BuildHTTP_FormMultiples(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetFormParam("something", "some value", "another value")
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.MultipartFormMime)

	req, err := r.BuildHTTP(runtime.MultipartFormMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	expected1 := []byte("Content-Disposition: form-data; name=\"something\"")
	expected2 := []byte("some value")
	expected3 := []byte("another value")
	actual, err := io.ReadAll(req.Body)
	require.NoError(t, err)
	actuallines := bytes.Split(actual, []byte("\r\n"))
	assert.Len(t, actuallines, 10)
	boundary := string(actuallines[0])
	lastboundary := string(actuallines[8])
	assert.True(t, strings.HasPrefix(boundary, "--"))
	assert.True(t, strings.HasPrefix(lastboundary, "--") && strings.HasSuffix(lastboundary, "--"))
	assert.Equal(t, lastboundary, boundary+"--")
	assert.Equal(t, expected1, actuallines[1])
	assert.Equal(t, expected2, actuallines[3])
	assert.Equal(t, actuallines[0], actuallines[4])
	assert.Equal(t, expected1, actuallines[5])
	assert.Equal(t, expected3, actuallines[7])
}

func TestBuildRequest_BuildHTTP_Files(t *testing.T) {
	cont, err := os.ReadFile("./runtime.go")
	require.NoError(t, err)
	cont2, err := os.ReadFile("./request.go")
	require.NoError(t, err)
	emptyFile, err := os.CreateTemp("", "empty")
	require.NoError(t, err)

	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, reg strfmt.Registry) error {
		_ = req.SetFormParam("something", "some value")
		_ = req.SetFileParam("file", mustGetFile("./runtime.go"))
		_ = req.SetFileParam("otherfiles", mustGetFile("./runtime.go"), mustGetFile("./request.go"))
		_ = req.SetFileParam("empty", emptyFile)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime)
	req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)

	mediaType, params, err := mime.ParseMediaType(req.Header.Get(runtime.HeaderContentType))
	require.NoError(t, err)

	assert.Equal(t, runtime.MultipartFormMime, mediaType)
	boundary := params["boundary"]
	mr := multipart.NewReader(req.Body, boundary)
	defer req.Body.Close()
	frm, err := mr.ReadForm(1 << 20)
	require.NoError(t, err)

	assert.Equal(t, "some value", frm.Value["something"][0])
	fileverifier := func(name string, index int, filename string, content []byte) {
		mpff := frm.File[name][index]
		mpf, e := mpff.Open()
		require.NoError(t, e)
		defer mpf.Close()
		assert.Equal(t, filename, mpff.Filename)
		actual, e := io.ReadAll(mpf)
		require.NoError(t, e)
		assert.Equal(t, content, actual)
	}
	fileverifier("file", 0, "runtime.go", cont)

	fileverifier("otherfiles", 0, "runtime.go", cont)
	fileverifier("otherfiles", 1, "request.go", cont2)
	fileverifier("empty", 0, filepath.Base(emptyFile.Name()), []byte{})
}

func TestBuildRequest_BuildHTTP_Files_URLEncoded(t *testing.T) {
	cont, err := os.ReadFile("./runtime.go")
	require.NoError(t, err)
	cont2, err := os.ReadFile("./request.go")
	require.NoError(t, err)

	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetFormParam("something", "some value")
		_ = req.SetFileParam("file", mustGetFile("./runtime.go"))
		_ = req.SetFileParam("otherfiles", mustGetFile("./runtime.go"), mustGetFile("./request.go"))
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.URLencodedFormMime)
	req, err := r.BuildHTTP(runtime.URLencodedFormMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/flats/1234/", req.URL.Path)
	mediaType, params, err := mime.ParseMediaType(req.Header.Get(runtime.HeaderContentType))
	require.NoError(t, err)

	assert.Equal(t, runtime.URLencodedFormMime, mediaType)
	boundary := params["boundary"]
	mr := multipart.NewReader(req.Body, boundary)
	defer req.Body.Close()
	frm, err := mr.ReadForm(1 << 20)
	require.NoError(t, err)

	assert.Equal(t, "some value", frm.Value["something"][0])
	fileverifier := func(name string, index int, filename string, content []byte) {
		mpff := frm.File[name][index]
		mpf, e := mpff.Open()
		require.NoError(t, e)
		defer mpf.Close()
		assert.Equal(t, filename, mpff.Filename)
		actual, e := io.ReadAll(mpf)
		require.NoError(t, e)
		assert.Equal(t, content, actual)
	}
	fileverifier("file", 0, "runtime.go", cont)

	fileverifier("otherfiles", 0, "runtime.go", cont)
	fileverifier("otherfiles", 1, "request.go", cont2)
}

type contentTypeProvider struct {
	runtime.NamedReadCloser
	contentType string
}

func (p contentTypeProvider) ContentType() string {
	return p.contentType
}

func TestBuildRequest_BuildHTTP_File_ContentType(t *testing.T) {
	cont, err := os.ReadFile("./runtime.go")
	require.NoError(t, err)
	cont2, err := os.ReadFile("./request.go")
	require.NoError(t, err)

	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetPathParam("id", "1234")
		_ = req.SetFileParam("file1", contentTypeProvider{
			NamedReadCloser: mustGetFile("./runtime.go"),
			contentType:     "application/octet-stream",
		})
		_ = req.SetFileParam("file2", mustGetFile("./request.go"))

		return nil
	})
	r, err := newRequest(http.MethodGet, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)
	_ = r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime)
	req, err := r.BuildHTTP(runtime.JSONMime, "", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "/flats/1234/", req.URL.Path)
	mediaType, params, err := mime.ParseMediaType(req.Header.Get(runtime.HeaderContentType))
	require.NoError(t, err)
	assert.Equal(t, runtime.MultipartFormMime, mediaType)
	boundary := params["boundary"]
	mr := multipart.NewReader(req.Body, boundary)
	defer req.Body.Close()
	frm, err := mr.ReadForm(1 << 20)
	require.NoError(t, err)

	fileverifier := func(name string, index int, filename string, content []byte, contentType string) {
		mpff := frm.File[name][index]
		mpf, e := mpff.Open()
		require.NoError(t, e)
		defer mpf.Close()
		assert.Equal(t, filename, mpff.Filename)
		actual, e := io.ReadAll(mpf)
		require.NoError(t, e)
		assert.Equal(t, content, actual)
		assert.Equal(t, mpff.Header.Get("Content-Type"), contentType)
	}
	fileverifier("file1", 0, "runtime.go", cont, "application/octet-stream")
	fileverifier("file2", 0, "request.go", cont2, "text/plain; charset=utf-8")
}

func TestBuildRequest_BuildHTTP_BasePath(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(nil)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodPost, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)

	req, err := r.BuildHTTP(runtime.JSONMime, "/basepath", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)
	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/basepath/flats/1234/", req.URL.Path)
}

func TestBuildRequest_BuildHTTP_EscapedPath(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(nil)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234/?*&^%")
		_ = req.SetHeaderParam("X-Rate-Limit", "200")
		return nil
	})
	r, err := newRequest(http.MethodPost, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)

	req, err := r.BuildHTTP(runtime.JSONMime, "/basepath", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "200", req.Header.Get("x-rate-limit"))
	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/basepath/flats/1234/?*&^%/", req.URL.Path)
	assert.Equal(t, "/basepath/flats/1234%2F%3F%2A&%5E%25/", req.URL.RawPath)
	assert.Equal(t, req.URL.RawPath, req.URL.EscapedPath())
}

func TestBuildRequest_BuildHTTP_BasePathWithQueryParameters(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(nil)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		return nil
	})
	r, err := newRequest(http.MethodPost, "/flats/{id}/", reqWrtr)
	require.NoError(t, err)

	req, err := r.BuildHTTP(runtime.JSONMime, "/basepath?foo=bar", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "bar", req.URL.Query().Get("foo"))
	assert.Equal(t, "/basepath/flats/1234/", req.URL.Path)
}

func TestBuildRequest_BuildHTTP_PathPatternWithQueryParameters(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(nil)
		_ = req.SetQueryParam("hello", "world")
		_ = req.SetPathParam("id", "1234")
		return nil
	})
	r, err := newRequest(http.MethodPost, "/flats/{id}/?foo=bar", reqWrtr)
	require.NoError(t, err)

	req, err := r.BuildHTTP(runtime.JSONMime, "/basepath", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "bar", req.URL.Query().Get("foo"))
	assert.Equal(t, "/basepath/flats/1234/", req.URL.Path)
}

func TestBuildRequest_BuildHTTP_StaticParametersPathPatternPrevails(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(nil)
		_ = req.SetPathParam("id", "1234")
		return nil
	})
	r, err := newRequest(http.MethodPost, "/flats/{id}/?hello=world", reqWrtr)
	require.NoError(t, err)

	req, err := r.BuildHTTP(runtime.JSONMime, "/basepath?hello=kitty", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "world", req.URL.Query().Get("hello"))
	assert.Equal(t, "/basepath/flats/1234/", req.URL.Path)
}

func TestBuildRequest_BuildHTTP_StaticParametersConflictClientPrevails(t *testing.T) {
	reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		_ = req.SetBodyParam(nil)
		_ = req.SetQueryParam("hello", "there")
		_ = req.SetPathParam("id", "1234")
		return nil
	})
	r, err := newRequest(http.MethodPost, "/flats/{id}/?hello=world", reqWrtr)
	require.NoError(t, err)

	req, err := r.BuildHTTP(runtime.JSONMime, "/basepath?hello=kitty", testProducers, nil)
	require.NoError(t, err)
	require.NotNil(t, req)

	assert.Equal(t, "there", req.URL.Query().Get("hello"))
	assert.Equal(t, "/basepath/flats/1234/", req.URL.Path)
}

type testReqFn func(*testing.T, *http.Request)

type testRoundTripper struct {
	tr          http.RoundTripper
	testFn      testReqFn
	testHarness *testing.T
}

func (t *testRoundTripper) RoundTrip(req *http.Request) (resp *http.Response, err error) {
	t.testFn(t.testHarness, req)
	return t.tr.RoundTrip(req)
}

func TestGetBodyCallsBeforeRoundTrip(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, _ *http.Request) {
		rw.WriteHeader(http.StatusCreated)
		_, err := rw.Write([]byte("test result"))
		require.NoError(t, err)
	}))
	defer server.Close()
	hu, err := url.Parse(server.URL)
	require.NoError(t, err)

	client := http.DefaultClient
	transport := http.DefaultTransport

	client.Transport = &testRoundTripper{
		tr:          transport,
		testHarness: t,
		testFn: func(t *testing.T, req *http.Request) {
			// Read the body once before sending the request
			body, e := req.GetBody()
			require.NoError(t, e)
			bodyContent, e := io.ReadAll(io.Reader(body))
			require.NoError(t, e)

			require.EqualValues(t, req.ContentLength, len(bodyContent))
			require.EqualValues(t, "\"test body\"\n", string(bodyContent))

			// Read the body a second time before sending the request
			body, e = req.GetBody()
			require.NoError(t, e)
			bodyContent, e = io.ReadAll(io.Reader(body))
			require.NoError(t, e)
			require.Len(t, bodyContent, int(req.ContentLength))
			require.EqualValues(t, "\"test body\"\n", string(bodyContent))
		},
	}

	rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error {
		return req.SetBodyParam("test body")
	})

	operation := &runtime.ClientOperation{
		ID:          "getSites",
		Method:      http.MethodPost,
		PathPattern: "/",
		Params:      rwrtr,
		Client:      client,
		Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
			if response.Code() == http.StatusCreated {
				var res string
				if e := consumer.Consume(response.Body(), &res); e != nil {
					return nil, e
				}
				return res, nil
			}
			return nil, errors.New("unexpected error code")
		}),
	}

	openAPIClient := New(hu.Host, "/", []string{schemeHTTP})
	res, err := openAPIClient.Submit(operation)
	require.NoError(t, err)

	actual := res.(string)
	require.EqualValues(t, "test result", actual)
}