func Test_Redirect_CompleteFlowWithFlashMessages(t *testing.T) {
	t.Parallel()

	app := New()
	
	// Create a handler that sets flash messages and redirects
	app.Get("/source", func(c *Ctx) error {
		// Set multiple types of flash messages to test encoding/decoding
		c.Flash("string_message", "Hello, World!")
		c.Flash("number_message", 12345)
		c.Flash("bool_message", true)
		c.Flash("map_message", map[string]string{"key": "value"})
		c.Flash("slice_message", []string{"one", "two", "three"})
		
		// Redirect to the target handler
		return c.Redirect("/target", StatusFound)
	})
	
	// Create a handler that receives and processes flash messages
	app.Get("/target", func(c *Ctx) error {
		// Get all flash messages and return them as a JSON response
		flashMessages := make(map[string]interface{})
		flashMessages["string_message"] = c.Flash("string_message")
		flashMessages["number_message"] = c.Flash("number_message")
		flashMessages["bool_message"] = c.Flash("bool_message")
		flashMessages["map_message"] = c.Flash("map_message")
		flashMessages["slice_message"] = c.Flash("slice_message")
		
		return c.JSON(flashMessages)
	})
	
	// Step 1: Make the initial request to the source route
	req := httptest.NewRequest(MethodGet, "/source", nil)
	resp, err := app.Test(req)
	utils.AssertEqual(t, nil, err)
	utils.AssertEqual(t, StatusFound, resp.StatusCode)
	utils.AssertEqual(t, "/target", resp.Header.Get(HeaderLocation))
	
	// Get the cookie from the response
	cookies := resp.Cookies()
	var flashCookie *http.Cookie
	for _, cookie := range cookies {
		if cookie.Name == "fiber_flash" {
			flashCookie = cookie
			break
		}
	}
	utils.AssertEqual(t, true, flashCookie != nil, "Expected flash cookie to be set")
	
	// Step 2: Make the second request to the target route with the cookie
	req = httptest.NewRequest(MethodGet, "/target", nil)
	req.Header.Set("Cookie", flashCookie.Name+"="+flashCookie.Value)
	resp, err = app.Test(req)
	utils.AssertEqual(t, nil, err)
	utils.AssertEqual(t, StatusOK, resp.StatusCode)
	
	// Step 3: Parse the JSON response and verify flash messages
	body, err := io.ReadAll(resp.Body)
	utils.AssertEqual(t, nil, err)
	
	var result map[string]interface{}
	err = json.Unmarshal(body, &result)
	utils.AssertEqual(t, nil, err)
	
	// Verify all flash messages were received correctly
	utils.AssertEqual(t, "Hello, World!", result["string_message"])
	utils.AssertEqual(t, float64(12345), result["number_message"]) // JSON numbers are float64
	utils.AssertEqual(t, true, result["bool_message"])
	
	// Check map_message
	mapMsg, ok := result["map_message"].(map[string]interface{})
	utils.AssertEqual(t, true, ok)
	utils.AssertEqual(t, "value", mapMsg["key"])
	
	// Check slice_message
	sliceMsg, ok := result["slice_message"].([]interface{})
	utils.AssertEqual(t, true, ok)
	utils.AssertEqual(t, 3, len(sliceMsg))
	utils.AssertEqual(t, "one", sliceMsg[0])
	utils.AssertEqual(t, "two", sliceMsg[1])
	utils.AssertEqual(t, "three", sliceMsg[2])
}

func Test_Redirect_FlashMessagesWithSpecialChars(t *testing.T) {
	t.Parallel()

	app := New()
	
	// Create a handler that sets flash messages with special characters and redirects
	app.Get("/special-source", func(c *Ctx) error {
		// Test with messages containing special characters that could break headers
		c.Flash("null_bytes", "Contains\x00null\x00bytes")
		c.Flash("control_chars", "Contains\r\ncontrol\tcharacters")
		c.Flash("unicode", "Unicode: 你好世界")
		c.Flash("emoji", "Emoji: 🔥🚀😊")
		
		// Create a large message to test encoding of larger data
		largeMessage := strings.Repeat("abcdefghijklmnopqrstuvwxyz", 100)
		c.Flash("large_message", largeMessage)
		
		return c.Redirect("/special-target", StatusFound)
	})
	
	// Create a target handler
	app.Get("/special-target", func(c *Ctx) error {
		return c.JSON(fiber.Map{
			"null_bytes": c.Flash("null_bytes"),
			"control_chars": c.Flash("control_chars"),
			"unicode": c.Flash("unicode"),
			"emoji": c.Flash("emoji"),
			"large_message_correct": c.Flash("large_message") == strings.Repeat("abcdefghijklmnopqrstuvwxyz", 100),
			"large_message_length": len(c.Flash("large_message").(string)),
		})
	})
	
	// Step 1: Make the initial request
	req := httptest.NewRequest(MethodGet, "/special-source", nil)
	resp, err := app.Test(req)
	utils.AssertEqual(t, nil, err)
	utils.AssertEqual(t, StatusFound, resp.StatusCode)
	
	// Get the flash cookie
	var flashCookie *http.Cookie
	for _, cookie := range resp.Cookies() {
		if cookie.Name == "fiber_flash" {
			flashCookie = cookie
			break
		}
	}
	utils.AssertEqual(t, true, flashCookie != nil)
	
	// Step 2: Make the second request with the cookie
	req = httptest.NewRequest(MethodGet, "/special-target", nil)
	req.Header.Set("Cookie", flashCookie.Name+"="+flashCookie.Value)
	resp, err = app.Test(req)
	utils.AssertEqual(t, nil, err)
	utils.AssertEqual(t, StatusOK, resp.StatusCode)
	
	// Step 3: Parse and verify the response
	body, err := io.ReadAll(resp.Body)
	utils.AssertEqual(t, nil, err)
	
	var result map[string]interface{}
	err = json.Unmarshal(body, &result)
	utils.AssertEqual(t, nil, err)
	
	// Verify special character handling
	utils.AssertEqual(t, "Contains\x00null\x00bytes", result["null_bytes"])
	utils.AssertEqual(t, "Contains\r\ncontrol\tcharacters", result["control_chars"])
	utils.AssertEqual(t, "Unicode: 你好世界", result["unicode"])
	utils.AssertEqual(t, "Emoji: 🔥🚀😊", result["emoji"])
	utils.AssertEqual(t, true, result["large_message_correct"])
	utils.AssertEqual(t, 26*100, int(result["large_message_length"].(float64)))
}