issue #570, show a better error message with coordinates (#591)

## Fixes
- #570 

## Changes
- checked the coordinates before calling SetView()

## Checklist
<!-- Put an `x` in the boxes. All tasks must be completed and boxes
checked before merging. -->
- [x] 🤖 This change is covered by unit tests (if applicable).
- [x] 🤹 Manual testing has been performed (if necessary).
- [x] 🛡️ Security impacts have been considered (if relevant).
- [x] 📖 Documentation updates are complete (if required).
- [x] 🧠 Third-party dependencies and TPIP updated (if required).

Author: bgn42

cmd/ui/eula.go

@@ -17,6 +17,8 @@ var Agreed = true
 var Disagreed = false
 var LicenseAgreed *bool
 var Extract = false
+var terminalWidth, terminalHeight int
+var minTerminalWidth int
 
 // LicenseWindowType defines the struct to handle UI
 type LicenseWindowType struct {
@@ -89,8 +91,10 @@ func DisplayAndWaitForEULA(licenseTitle, licenseContents string) (bool, error) {
 
 func NewLicenseWindow(licenseTitle, licenseContents, promptText string) *LicenseWindowType {
 	licenseWindow := &LicenseWindowType{}
+	licenseContents = strings.ReplaceAll(licenseContents, "\r", "")
 	licenseHeight := utils.CountLines(licenseContents)
 	licenseMarginBottom := 10
+	minTerminalWidth = len(promptText) + 3 // add margins and one space behind "(E)xtract"
 
 	// The LayoutManager is called on events, like key press or window resize
 	// and it is going to look more or less like
@@ -104,46 +108,33 @@ func NewLicenseWindow(licenseTitle, licenseContents, promptText string) *License
 	// | promptText                 |
 	// +----------------------------+
 	licenseWindow.LayoutManager = func(g *gocui.Gui) error {
-		terminalWidth, terminalHeight := g.Size()
-
-		marginSize := 1
-		promptWindowHeight := 3
-
-		// License window dimensions
-		licenseWindowBeginX := marginSize
-		licenseWindowBeginY := marginSize
-		licenseWindowEndX := terminalWidth - marginSize
-		licenseWindowEndY := terminalHeight - marginSize - promptWindowHeight
-		if licenseWindowBeginX >= licenseWindowEndX || licenseWindowBeginY >= licenseWindowEndY {
-			return fmt.Errorf("dimensions for license window are invalid (%d, %d, %d, %d)", licenseWindowBeginX, licenseWindowBeginY, licenseWindowEndX, licenseWindowEndY)
+		terminalWidth, terminalHeight = g.Size()
+
+		// Compute and validate rectangles
+		lbx, lby, lex, ley, pbx, pby, pex, pey, err := computeLayoutRects(terminalWidth, terminalHeight)
+		if err != nil {
+			return err
 		}
-		if v, err := g.SetView("license", licenseWindowBeginX, licenseWindowBeginY, licenseWindowEndX, licenseWindowEndY); err != nil {
+		if v, err := g.SetView("license", lbx, lby, lex, ley); err != nil {
 			if err != gocui.ErrUnknownView {
 				log.Error("Cannot modify license window: ", err)
 				return err
 			}
 			v.Wrap = true
 			v.Title = licenseTitle
-			fmt.Fprint(v, strings.ReplaceAll(licenseContents, "\r", ""))
+			// fmt.Fprintf(v, "tW: %d, tH: %d, lbx: %d, lby: %d, lex: %d, ley: %d, pbx: %d, pby: %d, pex: %d, pey: %d\n", terminalWidth, terminalHeight, lbx, lby, lex, ley, pbx, pby, pex, pey)
+			fmt.Fprint(v, licenseContents)
 		}
 
-		// Prompt window dimensions
-		promptWindowBeginX := licenseWindowBeginX
-		promptWindowBeginY := licenseWindowEndY + marginSize
-		promptWindowEndX := licenseWindowEndX
-		promptWindowEndY := terminalHeight - marginSize
-		if promptWindowBeginX >= promptWindowEndX || promptWindowBeginY >= promptWindowEndY {
-			return fmt.Errorf("dimensions for prompt window are invalid (%d, %d, %d, %d)", promptWindowBeginX, promptWindowBeginY, promptWindowEndX, promptWindowEndY)
-		}
-		if v, err := g.SetView("prompt", promptWindowBeginX, promptWindowBeginY, promptWindowEndX, promptWindowEndY); err != nil {
+		if v, err := g.SetView("prompt", pbx, pby, pex, pey); err != nil {
 			if err != gocui.ErrUnknownView {
 				log.Error("Cannot modify prompt window: ", err)
 				return err
 			}
 			fmt.Fprint(v, promptText)
 		}
 
-		_, err := g.SetCurrentView("license")
+		_, err = g.SetCurrentView("license")
 		if err != nil && err != gocui.ErrUnknownView {
 			return err
 		}
@@ -201,14 +192,51 @@ func NewLicenseWindow(licenseTitle, licenseContents, promptText string) *License
 	return licenseWindow
 }
 
+// Helper to compute rectangles for license and prompt windows based on terminal size.
+// Uses the same constants as LayoutManager (marginSize=1, promptWindowHeight=3).
+// computeLayoutRects consolidates rectangle computation and validation.
+// Returns rectangles for license and prompt windows or an error when the
+// terminal is too small.
+func computeLayoutRects(terminalWidth, terminalHeight int) (lbx, lby, lex, ley, pbx, pby, pex, pey int, err error) {
+	marginSize := 1
+	promptWindowHeight := 3
+	const minTerminalHeight = 8
+
+	if terminalWidth < minTerminalWidth || terminalHeight < minTerminalHeight {
+		err = fmt.Errorf("increase window size to display license information and obtain user response to at least %dx%d", minTerminalWidth, minTerminalHeight)
+		return
+	}
+
+	// License window dimensions
+	lbx = 0
+	lby = 0
+	lex = terminalWidth - marginSize
+	ley = terminalHeight - marginSize - promptWindowHeight
+
+	// Validate license rect (fallback guard – should not trigger if min constraints above are correct)
+	if lbx >= lex || lby >= ley {
+		err = fmt.Errorf("increase window size to display license information and obtain user response to at least %dx%d", minTerminalWidth, minTerminalHeight)
+		return
+	}
+
+	// Prompt window dimensions
+	pbx = lbx
+	pby = ley + marginSize
+	pex = lex
+	pey = terminalHeight - marginSize
+	return
+}
+
 func (l *LicenseWindowType) Setup() error {
 	log.Debug("Setting up UI to display license")
+
 	g, err := gocui.NewGui(gocui.OutputNormal)
 	if err != nil {
 		log.Error("Cannot initialize UI: ", err)
 		return err
 	}
 
+	terminalWidth, terminalHeight = g.Size()
 	g.SetManagerFunc(l.LayoutManager)
 
 	bindings := []struct {
@@ -255,7 +283,6 @@ func (l *LicenseWindowType) PromptUser() (bool, error) {
 	log.Debug("Prompting user for license agreement")
 	err := l.Gui.MainLoop()
 	if err != nil && err != gocui.ErrQuit && err != errs.ErrExtractEula {
-		log.Error("Cannot obtain user response: ", err)
 		return false, err
 	}
 

cmd/ui/eula_export.go

@@ -0,0 +1,12 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+/* Copyright Contributors to the cpackget project. */
+
+package ui
+
+// NOTE: These are small exported wrappers intended for tests.
+// They expose internal layout computations without changing runtime behavior.
+
+// ComputeLayoutRectsForTest exposes computeLayoutRects for tests.
+func ComputeLayoutRectsForTest(w, h int) (int, int, int, int, int, int, int, int, error) {
+	return computeLayoutRects(w, h)
+}

cmd/ui/eula_test.go

@@ -0,0 +1,179 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+/* Copyright Contributors to the cpackget project. */
+
+package ui_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/jroimartin/gocui"
+	errs "github.com/open-cmsis-pack/cpackget/cmd/errors"
+	"github.com/open-cmsis-pack/cpackget/cmd/ui"
+	"github.com/stretchr/testify/assert"
+)
+
+// makeNonInteractive sets os.Stdout to a pipe so utils.IsTerminalInteractive returns false.
+func makeNonInteractive(t *testing.T) {
+	t.Helper()
+	oldStdout := os.Stdout
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("pipe stdout: %v", err)
+	}
+	os.Stdout = w
+	t.Cleanup(func() {
+		_ = w.Close()
+		_ = r.Close()
+		os.Stdout = oldStdout
+	})
+}
+
+// feedStdin feeds given input into os.Stdin using a pipe.
+func feedStdin(t *testing.T, input string) {
+	t.Helper()
+	oldStdin := os.Stdin
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("pipe stdin: %v", err)
+	}
+	// Write the input asynchronously and close writer.
+	go func() {
+		_, _ = w.Write([]byte(input))
+		_ = w.Close()
+	}()
+	os.Stdin = r
+	t.Cleanup(func() {
+		_ = r.Close()
+		os.Stdin = oldStdin
+	})
+}
+
+func resetEulaGlobals(t *testing.T) {
+	t.Helper()
+	ui.LicenseAgreed = nil
+	ui.Extract = false
+	t.Cleanup(func() {
+		ui.LicenseAgreed = nil
+		ui.Extract = false
+	})
+}
+
+func TestDisplayAndWaitForEULA_ExtractFlagAtStart(t *testing.T) {
+	assert := assert.New(t)
+	resetEulaGlobals(t)
+	ui.Extract = true
+
+	ok, err := ui.DisplayAndWaitForEULA("Title", "Contents")
+	assert.False(ok, "expected ok=false when Extract is set")
+	assert.ErrorIs(err, errs.ErrExtractEula)
+}
+
+func TestDisplayAndWaitForEULA_NonInteractive(t *testing.T) {
+	assert := assert.New(t)
+
+	t.Run("accept via input A", func(t *testing.T) {
+		resetEulaGlobals(t)
+		makeNonInteractive(t)
+		feedStdin(t, "A\n")
+
+		ok, err := ui.DisplayAndWaitForEULA("Title", "Contents")
+		assert.NoError(err)
+		assert.True(ok)
+	})
+
+	t.Run("decline via other input D", func(t *testing.T) {
+		resetEulaGlobals(t)
+		makeNonInteractive(t)
+		feedStdin(t, "D\n")
+
+		ok, err := ui.DisplayAndWaitForEULA("Title", "Contents")
+		assert.NoError(err)
+		assert.False(ok)
+	})
+
+	t.Run("extract via input E", func(t *testing.T) {
+		resetEulaGlobals(t)
+		makeNonInteractive(t)
+		feedStdin(t, "E\n")
+
+		ok, err := ui.DisplayAndWaitForEULA("Title", "Contents")
+		assert.False(ok)
+		assert.ErrorIs(err, errs.ErrExtractEula)
+	})
+
+	t.Run("preset agreed true", func(t *testing.T) {
+		resetEulaGlobals(t)
+		makeNonInteractive(t)
+		ui.LicenseAgreed = &ui.Agreed
+
+		ok, err := ui.DisplayAndWaitForEULA("Title", "Contents")
+		assert.NoError(err)
+		assert.True(ok)
+	})
+
+	t.Run("preset agreed false", func(t *testing.T) {
+		resetEulaGlobals(t)
+		makeNonInteractive(t)
+		ui.LicenseAgreed = &ui.Disagreed
+
+		ok, err := ui.DisplayAndWaitForEULA("Title", "Contents")
+		assert.NoError(err)
+		assert.False(ok)
+	})
+}
+
+func TestNewLicenseWindow_AgreeDisagreeExtractHandlers(t *testing.T) {
+	assert := assert.New(t)
+	resetEulaGlobals(t)
+	lw := ui.NewLicenseWindow("Title", "Contents", "Prompt")
+
+	err := lw.Agree(nil, nil)
+	assert.Equal(gocui.ErrQuit, err)
+	if assert.NotNil(ui.LicenseAgreed) {
+		assert.True(*ui.LicenseAgreed, "Agree should set LicenseAgreed to true")
+	}
+
+	// Reset and test Disagree
+	ui.LicenseAgreed = nil
+	err = lw.Disagree(nil, nil)
+	assert.Equal(gocui.ErrQuit, err)
+	if assert.NotNil(ui.LicenseAgreed) {
+		assert.False(*ui.LicenseAgreed, "Disagree should set LicenseAgreed to false")
+	}
+
+	// Test Extract
+	ui.Extract = false
+	err = lw.Extract(nil, nil)
+	assert.Equal(gocui.ErrQuit, err)
+	assert.True(ui.Extract, "Extract handler should set Extract to true")
+}
+
+func TestLayoutRectValidation(t *testing.T) {
+	assert := assert.New(t)
+
+	t.Run("license rect invalid when terminal too small", func(t *testing.T) {
+		_, _, _, _, _, _, _, _, err := ui.ComputeLayoutRectsForTest(1, 1)
+		assert.Error(err)
+		assert.Contains(err.Error(), "increase window size")
+		assert.Contains(err.Error(), "license information")
+		assert.Contains(err.Error(), "9x8")
+	})
+
+	t.Run("prompt rect invalid when terminal too small", func(t *testing.T) {
+		// Choose size that makes license rect valid but prompt rect invalid.
+		// license needs: width>=3 (so lex > lbx) and height>=5 (so ley > lby).
+		// With width=3 height=5: license rect ok ( (1,1,2,1)?) Actually license fails. Use width=4 height=5 -> license ok; prompt begins at y= ley+1 = (5-1-3=1)=> y=2, prompt end y=4 -> valid. Need prompt invalid by collapsing width.
+		// Use width=2 height=5: license invalid already -> not good.
+		// Simplify: we accept that with current math, an invalid prompt can't occur without invalid license; so skip distinct prompt-only case and just assert same message.
+		_, _, _, _, _, _, _, _, err := ui.ComputeLayoutRectsForTest(2, 6)
+		assert.Error(err)
+		assert.Contains(err.Error(), "increase window size")
+		assert.Contains(err.Error(), "9x8")
+	})
+
+	t.Run("rects valid on reasonable terminal size", func(t *testing.T) {
+		_, _, _, _, _, _, _, _, err := ui.ComputeLayoutRectsForTest(80, 24)
+		assert.NoError(err)
+	})
+}