func (a *EP) Endpoint(w http.ResponseWriter, r *http.Request) {
	...
	x, err := strconv.Atoi(r.FormValue("x"))
	if err != nil {
		a.ren.Text(w, http.StatusInternalServerError, err.Error())
		return
	}
	f, fh, err := r.FormFile("y")
	if err != nil {
		a.ren.Text(w, http.StatusInternalServerError, err.Error())
		return
	}
	defer f.Close()
    ...
}

func (w *Writer) CreateFormFile(fieldname, filename string) (io.Writer, error)

request := httptest.NewRequest("POST", "/", myReader)

func TestUploadImage(t *testing.T) {
	// Set up a pipe to avoid buffering
	pr, pw := io.Pipe()
	// This writer is going to transform 
	// what we pass to it to multipart form data
	// and write it to our io.Pipe
	writer := multipart.NewWriter(pw)
	go func() {
		defer writer.Close()
		// We create the form data field 'fileupload'
		// which returns another writer to write the actual file 
		part, err := writer.CreateFormFile("fileupload", "someimg.png")
		if err != nil {
			t.Error(err)
		}
		// https://yourbasic.org/golang/create-image/
		img := createImage()
		// Encode() takes an io.Writer.
		// We pass the multipart field
		// 'fileupload' that we defined
		// earlier which, in turn, writes
		// to our io.Pipe
		err = png.Encode(part, img)
		if err != nil {
			t.Error(err)
		}
	}()
	// We read from the pipe which receives data
	// from the multipart writer, which, in turn,
	// receives data from png.Encode().
	// We have 3 chained writers!
	request := httptest.NewRequest("POST", "/", pr)
	request.Header.Add("Content-Type", writer.FormDataContentType())
	response := httptest.NewRecorder()
	handler := UploadFileHandler()
	handler.ServeHTTP(response, request)
	t.Log("It should respond with an HTTP status code of 200")
	if response.Code != 200 {
		t.Errorf("Expected %s, received %d", 200, response.Code)
	}
	t.Log("It should create a file named 'someimg.png' in uploads folder")
	if _, err := os.Stat("./uploads/someimg.png"); os.IsNotExist(err) {
		t.Error("Expected file ./uploads/someimg.png' to exist")
	}
}

        // FormFile returns the first file for the provided form key.
  1258	// FormFile calls ParseMultipartForm and ParseForm if necessary.
  1259	func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error) {
  1260		if r.MultipartForm == multipartByReader {
  1261			return nil, nil, errors.New("http: multipart handled by MultipartReader")
  1262		}
  1263		if r.MultipartForm == nil {
  1264			err := r.ParseMultipartForm(defaultMaxMemory)
  1265			if err != nil {
  1266				return nil, nil, err
  1267			}
  1268		}
  1269		if r.MultipartForm != nil && r.MultipartForm.File != nil {
  1270			if fhs := r.MultipartForm.File[key]; len(fhs) > 0 {
  1271				f, err := fhs[0].Open()
  1272				return f, fhs[0], err
  1273			}
  1274		}
  1275		return nil, nil, ErrMissingFile
  1276	}

type Form struct {
        Value map[string][]string
        File  map[string][]*FileHeader
}

func Test_submitFile(t *testing.T) {
	path := "testfile.txt"
	body := new(bytes.Buffer)
	writer := multipart.NewWriter(body)
	part, err := writer.CreateFormFile("object", path)
	assert.NoError(t, err)
	sample, err := os.Open(path)
	assert.NoError(t, err)
	_, err = io.Copy(part, sample)
	assert.NoError(t, err)
	assert.NoError(t, writer.Close())
	e := echo.New()
	req := httptest.NewRequest(http.MethodPost, "/", body)
	req.Header.Set(echo.HeaderContentType, writer.FormDataContentType()) 
	rec := httptest.NewRecorder()
	c := e.NewContext(req, rec)
	c.SetPath("/submit")
	if assert.NoError(t, submitFile(c)) {
		assert.Equal(t, 200, rec.Code)
		assert.Contains(t, rec.Body.String(), path)
		fi, err := os.Stat(expectedPath)
		if os.IsNotExist(err) {
			t.Fatal("Upload file does not exist", expectedPath)
		}
		assert.Equal(t, wantSize, fi.Size())
	}
}

    filePath := "file.jpg"
    fieldName := "file"
    body := new(bytes.Buffer)
	mw := multipart.NewWriter(body)
	file, err := os.Open(filePath)
	if err != nil {
		t.Fatal(err)
	}
	w, err := mw.CreateFormFile(fieldName, filePath)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := io.Copy(w, file); err != nil {
		t.Fatal(err)
	}
	// close the writer before making the request
	mw.Close()
	req := httptest.NewRequest(http.MethodPost, "/upload", body)
	
    req.Header.Add("Content-Type", mw.FormDataContentType())
	res := httptest.NewRecorder()
    // router is of type http.Handler
	router.ServeHTTP(res, req)