# Copyright 2017-2023 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# This file is part of the gdb testsuite.

load_lib completion-support.exp
load_lib data-structures.exp

standard_testfile cpls.cc cpls2.cc cpls-hyphen.cc

if {[prepare_for_testing "failed to prepare" $testfile \
	 [list $srcfile $srcfile2 $srcfile3] {debug}]} {
    return -1
}

# Tests below are about tab-completion, which doesn't work if readline
# library isn't used.  Check it first.

if { ![readline_is_used] } {
    untested "no tab completion support without readline"
    return -1
}

#
# Some convenience procedures for testing template parameter list
# completion.
#

# For the variable named ARGLISTVAR, which should be the name of an
# argument list in the calling frame, "consume" the top-most token.
# [See comments for makefoo for description of arglist format.]

proc consume {arglistvar} {
  upvar $arglistvar arglist

  # ARGLIST is a string -- simply strip off the first character.
  set arglist [string range $arglist 1 end]
}

# Create a function template named NAME, using the given stack ID to grab
# NUM template parameters.  The result is pushed back onto the
# stack.  NUM may be "all," in which case we use the entire stack
# to create the function template, including function arguments.
# The resulting template function's arguments are taken from the test
# source code for the function "foo" and is not generalized.

proc maket {sid name {num 1}} {

  # Set up a temporary stack of parameters.  This will reverse
  # the order in SID so that when they are popped again below,
  # we get them in the correct order.  This also takes into account
  # how many levels of the result stack we want to consider.

  set paramstack [::Stack::new]
  if {[string equal $num "all"]} {
    while {![stack empty $sid]} {
      stack push $paramstack [stack pop $sid]
    }
  } else {
    for {set i 0} {$i < $num} {incr i} {
      stack push $paramstack [stack pop $sid]
    }
  }

  # Construct the function template and push it back to the
  # top of the stack given by SID.
  set result ""
  set first true
  while {![stack empty $paramstack]} {
    set top [stack pop $paramstack]
    if {$first} {
      set first false
    } else {
      append result ", "
    }
    append result $top
  }

  # Save argument list.
  set args $result

  # GDB outputs "> >" instead of ">>".
  if {[string index $top end] == ">"} {
      append result " "
  }
  set result "$name<$result>"
  if {[string equal $num "all"]} {
    append result "($args)"
  }
  stack push $sid $result
  stack delete $paramstack
}

# Given the stack SID and the name of a variable of the desired template
# parameters, construct the actual template parameter and push it to the
# top of the stack.

proc makearg {sid arglistvar} {
    upvar $arglistvar arglist

  set c [string index $arglist 0]
  consume arglist
  switch $c {
    A -
    B {
      makearg $sid arglist
      makearg $sid arglist
      maket $sid $c 2
    }

    a -
    b -
    c -
    d {
      makearg $sid arglist
      maket $sid $c
    }

    i {
      stack push $sid "int"
    }

    n {
      # These are not templates.
      set c [string index $arglist 0]
      stack push $sid "n::n$c"
      consume arglist
    }

    N {
      set c [string index $arglist 0]
      makearg $sid arglist
      set top [stack pop $sid]
      stack push $sid "n::N$top"
    }

    default { error "unhandled arglist identifier: '$c'" }
  }
}

# Given ARGLIST, construct a class template for the type and return
# it as a string.

proc maketype {arglist} {
    set s [Stack::new]
    makearg $s arglist
    set result [stack pop $s]
    stack delete $s
    return $result
}

# Returns a function template declaration for the function "foo" in the
# corresponding test source code.  ARGLIST specifies the exact instantiation
# that is desired.
#
# Generically, this procedure returns a string of the form,
# "foo<parameter-list> (arg-list)", where ARGLIST describes the parameter(s).
#
# Valid specifiers for ARGLIST (must be kept in sync with source code):
#
# i: Creates an "int" type.
# a, b, c, d: Creates the struct template of the same name, taking a single
#    template parameter.
# A, B: Creates the struct template of the same name, taking two template
#    parameters.
# na, nb: Creates the non-template structs n::na and n::nb, respectively.
# NA, NB: Creates the struct templates n::NA and n::NB, respectively, which
#    take two template parameters.
#
# Examples:
# makefoo i
# --> foo<int> (int)
# makefoo ii
# --> foo<int, int> (int, int)
# makefoo Aiabi
# --> foo<A<int, a<b<int> > > > (A<int, a<b<int> > >)
# makefoo NANAiaiNBbiabi
# --> foo<n::NA<n::NA<int, a<int> >, n::NB<b<int>, a<b<int> > > > >
#          (n::NA<n::NA<int, a<int> >, n::NB<b<int>, a<b<int> > > >)

proc makefoo {arglist} {
    set s [::Stack::new]
    while {[string length $arglist] > 0} {
	makearg $s arglist
    }

  maket $s "foo" all
  set result [stack pop $s]
  stack delete $s
  return $result
}

# Test wrapper for a single "makefoo" unit test.

proc test_makefoo_1 {arglist expected} {
  set exp "foo<$expected"
  if {[string index $exp end] == ">"} {
    append exp " "
  }
  append exp ">"
  append exp "($expected)"

  set calc [makefoo $arglist]
  send_log "makefoo $arglist = $calc\n"
  send_log "expecting: $exp\n"
  if {[string equal $exp $calc]} {
    pass "makefoo unit test: $arglist"
  } else {
      fail "makefoo unit test: $arglist"
  }
}

# Test whether the procedure "makefoo" is functioning as expected.

proc test_makefoo {} {
  test_makefoo_1 "i" "int"
  test_makefoo_1 "ai" "a<int>"
  test_makefoo_1 "aai" "a<a<int> >"
  test_makefoo_1 "ii" "int, int"
  test_makefoo_1 "aaibi" "a<a<int> >, b<int>"
    test_makefoo_1 \
      "ababiibababai" "a<b<a<b<int> > > >, int, b<a<b<a<b<a<int> > > > > >"
  test_makefoo_1 "Aii" "A<int, int>"
  test_makefoo_1 "ABaibibi" "A<B<a<int>, b<int> >, b<int> >"
  test_makefoo_1 "na" "n::na"
  test_makefoo_1 "nana" "n::na, n::na"
  test_makefoo_1 "NAii" "n::NA<int, int>"
  test_makefoo_1 "NANAiiNAii" "n::NA<n::NA<int, int>, n::NA<int, int> >"
}

#
# Tests start here.
#

# Disable the completion limit for the whole testcase.
gdb_test_no_output "set max-completions unlimited"

# Start of tests.

# Test completion of all parameter prefixes, crossing "(" and ")",
# with and without whitespace.

proc_with_prefix all-param-prefixes {} {

    # Test both linespecs and explicit locations.
    foreach cmd_prefix {"b" "b -function"} {
	set line "$cmd_prefix param_prefixes_test_long(long)"
	set start [index_after "test_long" $line]
	test_complete_prefix_range $line $start

	# Same, but with extra spaces.  Note that the original spaces in
	# the input line are preserved after completion.
	test_gdb_complete_unique \
	    "$cmd_prefix param_prefixes_test_long(long "   \
	    "$cmd_prefix param_prefixes_test_long(long )"
	test_gdb_complete_unique \
	    "$cmd_prefix param_prefixes_test_long( long "  \
	    "$cmd_prefix param_prefixes_test_long( long )"
	test_gdb_complete_unique \
	    "$cmd_prefix param_prefixes_test_long ( long " \
	    "$cmd_prefix param_prefixes_test_long ( long )"

	# Complete all parameter prefixes between "(i" and "(int*, int&)".
	# Note that this exercises completing when the point is at the
	# space in "param_prefixes_test_intp_intr(int*, ".
	set line "$cmd_prefix param_prefixes_test_intp_intr(int*, int&)"
	set start [index_after "intp_intr" $line]
	test_complete_prefix_range $line $start

	# Similar, but with extra spaces.
	test_gdb_complete_unique \
	    "$cmd_prefix param_prefixes_test_intp_intr (  int* " \
	    "$cmd_prefix param_prefixes_test_intp_intr (  int* , int&)"

	test_gdb_complete_unique \
	    "$cmd_prefix param_prefixes_test_intp_intr (  int *" \
	    "$cmd_prefix param_prefixes_test_intp_intr (  int *, int&)"

	test_gdb_complete_unique \
	    "$cmd_prefix param_prefixes_test_intp_intr (  int *, int " \
	    "$cmd_prefix param_prefixes_test_intp_intr (  int *, int &)"

	test_gdb_complete_unique \
	    "$cmd_prefix param_prefixes_test_intp_intr (  int *,  int & " \
	    "$cmd_prefix param_prefixes_test_intp_intr (  int *,  int & )"
    }
}

# Test completion of an overloaded function.

proc_with_prefix overload {} {
    set completion_list {
	"overload_ambiguous_test(int, int)"
	"overload_ambiguous_test(int, long)"
	"overload_ambiguous_test(long)"
    }

    foreach cmd_prefix {"b" "b -function"} {
	test_gdb_complete_multiple \
	    "$cmd_prefix " "overload_ambiguous_" "test(" \
	    $completion_list
	check_bp_locations_match_list \
	    "$cmd_prefix overload_ambiguous_test" \
	    $completion_list

	# Test disambiguating by typing enough to pick the "int" as
	# first parameter type.  This then tests handling ambiguity in
	# the second parameter, which checks that tab completion when
	# the point is at the whitespace behaves naturally, by showing
	# the remaining matching overloads to the user.
	test_gdb_complete_multiple \
	    "$cmd_prefix " "overload_ambiguous_test(i" "nt, " {
	    "overload_ambiguous_test(int, int)"
	    "overload_ambiguous_test(int, long)"
	}

	# Add a few more characters to make the completion
	# unambiguous.
	test_gdb_complete_unique \
	    "$cmd_prefix overload_ambiguous_test(int, i" \
	    "$cmd_prefix overload_ambiguous_test(int, int)"
	check_bp_locations_match_list \
	    "$cmd_prefix overload_ambiguous_test(int, int)" {
		"overload_ambiguous_test(int, int)"
	    }
    }
}

# Test completion of a function that is defined in different scopes
# with different parameters.

proc_with_prefix overload-2 {} {
    with_test_prefix "all" {
	set completion_list {
	    "(anonymous namespace)::overload2_function(overload2_arg3)"
	    "(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg4)"
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)"
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)"
	    "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)"
	    "ns_overload2_test::(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg8)"
	    "ns_overload2_test::overload2_function(overload2_arg5)"
	    "ns_overload2_test::struct_overload2_test::overload2_function(overload2_arg6)"
	    "overload2_function(overload2_arg1)"
	    "struct_overload2_test::overload2_function(overload2_arg2)"
	}
	foreach cmd_prefix {"b" "b -function"} {
	    test_gdb_complete_multiple \
		"$cmd_prefix " "overload2_func" "tion(overload2_arg" $completion_list
	    check_bp_locations_match_list \
		"$cmd_prefix overload2_function" $completion_list
	}
    }

    # Same, but restrict to functions/methods in some scope.
    with_test_prefix "restrict scope" {
	set completion_list {
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)"
	    "ns_overload2_test::overload2_function(overload2_arg5)"
	}
	foreach cmd_prefix {"b" "b -function"} {
	    test_gdb_complete_multiple \
		"$cmd_prefix " "ns_overload2_test::overload2_func" "tion(overload2_arg" $completion_list
	    check_bp_locations_match_list \
		"$cmd_prefix ns_overload2_test::overload2_function" $completion_list
	}
    }

    # Restrict to anonymous namespace scopes.
    with_test_prefix "restrict scope 2" {
	set completion_list {
	    "(anonymous namespace)::overload2_function(overload2_arg3)"
	    "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)"
	}
	foreach cmd_prefix {"b" "b -function"} {
	    test_gdb_complete_multiple \
		"$cmd_prefix " "(anonymous namespace)::overload2_func" "tion(overload2_arg" $completion_list
	    check_bp_locations_match_list \
		"$cmd_prefix (anonymous namespace)::overload2_function" $completion_list
	}
    }

    # Add enough scopes, and we get a unique completion.
    with_test_prefix "unique completion" {
	foreach cmd_prefix {"b" "b -function"} {
	    test_gdb_complete_unique \
		"$cmd_prefix ns_overload2_test::(anonymous namespace)::overload2_func" \
		"$cmd_prefix ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)"
	    check_setting_bp_fails "$cmd_prefix ns_overload2_test::(anonymous namespace)::overload2_func"
	    check_bp_locations_match_list \
		"$cmd_prefix ns_overload2_test::(anonymous namespace)::overload2_function" \
		{"ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)"}
	}
    }
}

# Test linespecs / locations using fully-qualified names.

proc_with_prefix fqn {} {

    # "-qualified" works with both explicit locations and linespecs.
    # Also test that combining a source file with a function name
    # still results in a full match, with both linespecs and explicit
    # locations.
    foreach cmd_prefix {
	"b -qualified "
	"b -qualified -function "
	"b -qualified cpls.cc:"
	"b -qualified -source cpls.cc -function "
	"b -source cpls.cc -qualified -function "
    } {
	test_gdb_complete_unique \
	    "${cmd_prefix}overload2_func" \
	    "${cmd_prefix}overload2_function(overload2_arg1)"

	# Drill down until we find a unique completion.
	test_gdb_complete_multiple "${cmd_prefix}" "ns_overload2_test::" "" {
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)"
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)"
	    "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)"
	    "ns_overload2_test::(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg8)"
	    "ns_overload2_test::overload2_function(overload2_arg5)"
	    "ns_overload2_test::struct_overload2_test::overload2_function(overload2_arg6)"
	}

	test_gdb_complete_multiple "${cmd_prefix}" "ns_overload2_test::(anonymous namespace)::" "" {
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)"
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)"
	    "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)"
	    "ns_overload2_test::(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg8)"
	}

	test_gdb_complete_multiple "${cmd_prefix}" "ns_overload2_test::(anonymous namespace)::ns_overload2_test::" "" {
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)"
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)"
	}

	test_gdb_complete_unique \
	    "${cmd_prefix}ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_func" \
	    "${cmd_prefix}ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)"

    }
}

# Check that a fully-qualified lookup name doesn't match symbols in
# nested scopes.

proc_with_prefix fqn-2 {} {
    set linespec "struct_overload2_test::overload2_function(overload2_arg6)"
    set cmd_prefix "b -qualified"
    check_setting_bp_fails "$cmd_prefix $linespec"
    test_gdb_complete_none "$cmd_prefix $linespec"

    # Check that using the same name, but not fully-qualifying it,
    # would find something, just to make sure the test above is
    # testing what we intend to test.
    set cmd_prefix "b -function"
    test_gdb_complete_unique "$cmd_prefix $linespec" "$cmd_prefix $linespec"
    check_bp_locations_match_list \
	"$cmd_prefix $linespec" \
	{"ns_overload2_test::struct_overload2_test::overload2_function(overload2_arg6)"}
}

# Test completion of functions in different scopes that have the same
# name and parameters.  Restricting the scopes should find fewer and
# fewer matches.

proc_with_prefix overload-3 {} {
    with_test_prefix "all overloads" {
	set completion_list {
	    "(anonymous namespace)::overload3_function(int)"
	    "(anonymous namespace)::overload3_function(long)"
	    "(anonymous namespace)::struct_overload3_test::overload3_function(int)"
	    "(anonymous namespace)::struct_overload3_test::overload3_function(long)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(long)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(long)"
	    "ns_overload3_test::(anonymous namespace)::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::overload3_function(long)"
	    "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(long)"
	    "ns_overload3_test::overload3_function(int)"
	    "ns_overload3_test::overload3_function(long)"
	    "ns_overload3_test::struct_overload3_test::overload3_function(int)"
	    "ns_overload3_test::struct_overload3_test::overload3_function(long)"
	    "overload3_function(int)"
	    "overload3_function(long)"
	    "struct_overload3_test::overload3_function(int)"
	    "struct_overload3_test::overload3_function(long)"
	}
	foreach cmd_prefix {"b" "b -function"} {
	    test_gdb_complete_multiple "$cmd_prefix " "overload3_func" "tion(" $completion_list
	    check_bp_locations_match_list "$cmd_prefix overload3_function" $completion_list
	}
    }

    with_test_prefix "restrict overload" {
	foreach cmd_prefix {"b" "b -function"} {
	    test_gdb_complete_unique \
		"$cmd_prefix overload3_function(int)" \
		"$cmd_prefix overload3_function(int)"
	    check_bp_locations_match_list "$cmd_prefix overload3_function(int)" {
		"(anonymous namespace)::overload3_function(int)"
		"(anonymous namespace)::struct_overload3_test::overload3_function(int)"
		"ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(int)"
		"ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(int)"
		"ns_overload3_test::(anonymous namespace)::overload3_function(int)"
		"ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(int)"
		"ns_overload3_test::overload3_function(int)"
		"ns_overload3_test::struct_overload3_test::overload3_function(int)"
		"overload3_function(int)"
		"struct_overload3_test::overload3_function(int)"
	    }
	}
    }

    with_test_prefix "restrict scope" {
	set completion_list {
	    "(anonymous namespace)::struct_overload3_test::overload3_function(int)"
	    "(anonymous namespace)::struct_overload3_test::overload3_function(long)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(long)"
	    "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(long)"
	    "ns_overload3_test::struct_overload3_test::overload3_function(int)"
	    "ns_overload3_test::struct_overload3_test::overload3_function(long)"
	    "struct_overload3_test::overload3_function(int)"
	    "struct_overload3_test::overload3_function(long)"
	}
	foreach cmd_prefix {"b" "b -function"} {
	    test_gdb_complete_multiple \
		"$cmd_prefix " "struct_overload3_test::overload3_func" "tion(" \
		$completion_list
	    check_bp_locations_match_list \
		"$cmd_prefix struct_overload3_test::overload3_function" \
		$completion_list
	}
    }
}

# Test completing an overloaded template method.

proc_with_prefix template-overload {} {
    set completion_list {
	"template_struct<int>::template_overload_fn(int)"
	"template_struct<long>::template_overload_fn(long)"
    }
    foreach cmd_prefix {"b" "b -function"} {
	test_gdb_complete_multiple "$cmd_prefix " "template_overload_fn" "(" $completion_list
	check_bp_locations_match_list "$cmd_prefix template_overload_fn" $completion_list
	check_bp_locations_match_list \
	    "$cmd_prefix template_struct<int>::template_overload_fn" \
	    "template_struct<int>::template_overload_fn(int)"
    }
}

# Test completing template methods with non-void return type.

proc_with_prefix template-ret-type {} {
    set method_name "template2_fn<int, int>"
    set param_list "(template2_ret_type<int>, int, int)"
    set struct_type "template2_struct<template2_ret_type<int> >"
    set ret_type "template2_ret_type<int>"

    # Templates are listed both with and without return type, making
    # "template2_<tab>" ambiguous.
    foreach cmd_prefix {"b" "b -function"} {
	set completion_list \
	    [list \
		 "${ret_type} ${struct_type}::${method_name}${param_list}" \
		 "${struct_type}::${method_name}${param_list}"]
	test_gdb_complete_multiple "$cmd_prefix " "template2_" "" $completion_list

	# Add one character more after "2_", and the linespec becomes
	# unambiguous.  Test completing the whole prefix range after that,
	# thus testing completing either with or without return type.
	foreach {s t} [list \
			   "template2_r" \
			   "${ret_type} ${struct_type}::${method_name}${param_list}" \
			   "template2_s" \
			   "${struct_type}::${method_name}${param_list}"] {
	    set linespec $t
	    set complete_line "$cmd_prefix $linespec"
	    set start [index_after $s $complete_line]
	    test_complete_prefix_range $complete_line $start
	}

	# Setting a breakpoint with or without template params and without
	# the method params works, just like with non-template functions.
	#  It also works with or without return type.
	foreach linespec [list \
			      "template2_fn" \
			      "${method_name}" \
			      "${method_name}${param_list}" \
			      "${struct_type}::${method_name}" \
			      "${struct_type}::${method_name}${param_list}" \
			      "${ret_type} ${struct_type}::${method_name}" \
			      "${ret_type} ${struct_type}::${method_name}${param_list}"] {
	    check_bp_locations_match_list \
		"$cmd_prefix $linespec" \
		[list "${struct_type}::${method_name}${param_list}"]
	}
    }
}

# Test completion of function template foo.

proc_with_prefix template-function-foo {} {

    foreach cmd_prefix {"b" "b -function"} {
	# "foo" is ambiguous, this will set many different breakpoints.
	set completion_list \
	    [list \
		 [makefoo Aabiaai] \
		 [makefoo Aabiabi] \
		 [makefoo Aabicdi] \
		 [makefoo AabicdiAabiaai] \
		 [makefoo AabicdiAabiabi] \
		 [makefoo AabicdiBabicdi] \
		 [makefoo Babicdi] \
		 [makefoo aai] \
		 [makefoo aaiabi] \
		 [makefoo aaicci] \
		 [makefoo aaicdi] \
		 [makefoo abi] \
		 [makefoo anabnb] \
		 [makefoo cci] \
		 [makefoo cdi] \
		 [makefoo NAnanbNBnanb] \
		 [makefoo nanb]]
	test_gdb_complete_multiple "$cmd_prefix " "foo" "<" $completion_list
	check_bp_locations_match_list "$cmd_prefix foo" $completion_list

	# "foo<" should give the same result, but it should not set any
	# breakpoints.
	test_gdb_complete_multiple "$cmd_prefix " "foo<" "" $completion_list
	check_setting_bp_fails "$cmd_prefix foo<"

	# "foo<A" should only give completions in COMPLETION_LIST that
	# start with "A" but should set no breakpoints.
	set completion_list \
	    [list \
		 [makefoo Aabiaai] \
		 [makefoo Aabiabi] \
		 [makefoo Aabicdi] \
		 [makefoo AabicdiAabiaai] \
		 [makefoo AabicdiAabiabi] \
		 [makefoo AabicdiBabicdi]]
	test_gdb_complete_multiple "$cmd_prefix " "foo<A" "<a<b<int> >, " \
	    $completion_list
	check_setting_bp_fails "$cmd_prefix foo<A"

	# "foo<A>" should give any function with one parameter of any type
	# of A.  While the parameter list in the template should be ignored,
	# the function's argument list should not be ignored.
	set completion_list \
	    [list \
		 [makefoo Aabiaai] \
		 [makefoo Aabiabi] \
		 [makefoo Aabicdi]]
	test_gdb_complete_multiple "$cmd_prefix " "foo<A>" \
	    "(A<a<b<int> >, " $completion_list
	check_bp_locations_match_list "$cmd_prefix foo<A>" $completion_list

	# "foo<A," should complete to any function with more than one
	# parameter where the first parameter is any type of A.  Insufficient
	# location to set breakpoints.
	set completion_list \
	    [list \
		 [makefoo AabicdiAabiaai] \
		 [makefoo AabicdiAabiabi] \
		 [makefoo AabicdiBabicdi]]
	test_gdb_complete_multiple "$cmd_prefix " "foo<A," " " \
	    $completion_list
	check_setting_bp_fails "$cmd_prefix foo<A,"

	# "foo<A<a<b<int>, a" should give all completions starting with
	# "Aabia" but it is insufficient to set breakpoints.
	set completion_list \
	    [list \
		 [makefoo Aabiaai] \
		 [makefoo Aabiabi]]
	test_gdb_complete_multiple "$cmd_prefix " "foo<A<a<b<int> >, a" \
	    "<" $completion_list
	check_setting_bp_fails "$cmd_prefix foo<A<a<b<int> >, a"

	# "foo<A<a<b<int>, a<" should yield the same results as above.
	test_gdb_complete_multiple "$cmd_prefix " "foo<A<a<b<int> >, a<" \
	    "" $completion_list
	check_setting_bp_fails "$cmd_prefix foo<A<a<b<int> >, a<"

	# "foo<A<a<b<int>, a<a" is unique but insufficient to set a
	# breakpoint.  This has an ignored template parameter list, so
	# the completion will contain an ignored list ("a<a>")
	test_gdb_complete_unique "$cmd_prefix foo<A<a<b<int> >, a<a" \
	    "$cmd_prefix [makefoo Aabiaai]"
	check_setting_bp_fails "$cmd_prefix foo<A<b<int> >, a<a"

	# "foo<A<a<b<int>, a<b" is also unique.  Same parameter ignoring
	# happens here, too (except "a<b>").
	test_gdb_complete_unique "$cmd_prefix foo<A<a<b<int> >, a<b" \
	    "$cmd_prefix [makefoo Aabiabi]"
	check_setting_bp_fails "$cmd_prefix foo<A<a<b<int> >, a<b"

	# "foo<B" is unique but insufficient to set a breakpoint.
	test_gdb_complete_unique "$cmd_prefix foo<B" \
	    "$cmd_prefix [makefoo Babicdi]"
	check_setting_bp_fails "$cmd_prefix foo<B"

	# "foo<B>" yields the same unique result and sets a breakpoint.
	# Since the input skips the parameter list, so does the completion.
	test_gdb_complete_unique "$cmd_prefix foo<B>" \
	    "$cmd_prefix foo<B>(B<a<b<int> >, c<d<int> > >)"
	check_bp_locations_match_list "$cmd_prefix foo<B>" \
	    [list [makefoo Babicdi]]

	# "foo<B," should return no completions and no breakpoints.
	test_gdb_complete_none "$cmd_prefix foo<B,"
	check_setting_bp_fails "$cmd_prefix foo<B,"

	# "foo<n::" should yield only the functions starting with
	# "n" and "N" and no breakpoints.
	set completion_list \
	    [list \
		 [makefoo NAnanbNBnanb] \
		 [makefoo nanb]]
	test_gdb_complete_multiple "$cmd_prefix " "foo<n::" "" \
	    $completion_list
	check_setting_bp_fails "$cmd_prefix foo<n::"

	# "foo<A<a, c> >" is unique and sets a breakpoint.
	# Multiple template parameter lists are skipped, so GDB will ignore
	# them in the completion.
	test_gdb_complete_unique "$cmd_prefix foo<A<a, c> >" \
	    "$cmd_prefix foo<A<a, c> >(A<a<b<int> >, c<d<int> > >)"
	check_bp_locations_match_list "$cmd_prefix foo<A<a, c> >" \
	    [list [makefoo Aabicdi]]
    }
}

# Helper for template-class-with-method to build completion lists.

proc makem {arglist_list} {
    set completion_list {}
    foreach arglist $arglist_list {
	lappend completion_list "[maketype $arglist]::method()"
    }
    return $completion_list
}

# Returns a list of elements that look like
#   void TYPE::method()
# where TYPE is derived from each arglist in ARGLIST_LIST.

proc test_makem_1 {arglist_list expected_list} {
    set result [makem $arglist_list]
    send_log "makem $arglist = $result\n"
    send_log "expecting $expected_list\n"

    # Do list equality via canonical strings.
    if {[expr {[list {*}$expected_list] eq [list {*}$result]}]} {
	pass "makem unit test: $arglist"
    } else {
	fail "makem unit test: $arglist"
    }
}

# Unit tests for makem.

proc test_makem {} {
    test_makem_1 ai {"a<int>::method()"}
    test_makem_1 bi {"b<int>::method()"}
    test_makem_1 {ai bi} {"a<int>::method()" "b<int>::method()"}
    test_makem_1 {Aaiaai Bbibbi abi cdi} {
	"A<a<int>, a<a<int> > >::method()"
	"B<b<int>, b<b<int> > >::method()"
	"a<b<int> >::method()"
	"c<d<int> >::method()"
    }
}

# Test class template containing a (non-templated) method called "method."

proc_with_prefix template-class-with-method {} {

    foreach {type type_list} \
	[list \
	     "" {aai abi cci cdi Aabicdi Aabiaai Aabiabi Babicdi} \
	     "a" {aai abi} \
	     "b" {} \
	     "c" {cci cdi} \
	     "A" {Aabicdi Aabiaai Aabiabi} \
	     "B" {Babicdi} \
	     "A<a, a>" {Aabiaai Aabiabi} \
	     "A<a<b>, c>" {Aabicdi}\
	     "A<a, d>" {} \
	     "B<a, a>" {} \
	     "B<a, b>" {} \
	     "B<a, c>" {Babicdi}] \
	{
	    foreach cmd_prefix {"b" "b -function"} {
		set c "$cmd_prefix "
		if {$type != ""} {
		    append c "${type}::"
		}
		append c "method"

		if {[llength $type_list] > 0} {
		    test_gdb_complete_unique $c "${c}()"
		    check_bp_locations_match_list $c [makem $type_list]
		} else {
		    test_gdb_complete_none $c
		}
	    }
	}
}

# Test completion of a const-overloaded funtion (const-overload).
# Note that "const" appears after the function/method parameters.

proc_with_prefix const-overload {} {
    set completion_list {
	"struct_with_const_overload::const_overload_fn()"
	"struct_with_const_overload::const_overload_fn() const"
    }
    foreach cmd_prefix {"b" "b -function"} {
	test_gdb_complete_multiple \
	    "$cmd_prefix " "const_overload_fn" "()" \
	    $completion_list
	test_gdb_complete_multiple \
	    "$cmd_prefix " "const_overload_fn ( " ")" \
	    $completion_list
	test_gdb_complete_multiple \
	    "$cmd_prefix " "const_overload_fn()" "" \
	    $completion_list

	check_bp_locations_match_list \
	    "$cmd_prefix const_overload_fn" \
	    {"struct_with_const_overload::const_overload_fn()"
		"struct_with_const_overload::const_overload_fn() const"}

	check_setting_bp_fails "$cmd_prefix const_overload_fn("
	check_bp_locations_match_list \
	    "$cmd_prefix const_overload_fn()" \
	    {"struct_with_const_overload::const_overload_fn()"}
	check_bp_locations_match_list \
	    "$cmd_prefix const_overload_fn() const" \
	    {"struct_with_const_overload::const_overload_fn() const"}
    }
}

# Same but quote-enclose the function name.  This makes the overload
# no longer be ambiguous.

proc_with_prefix const-overload-quoted {} {
    foreach cmd_prefix {"b" "b -function"} {
	set linespec "'const_overload_fn()'"
	test_gdb_complete_unique "$cmd_prefix $linespec" "$cmd_prefix $linespec"
	check_bp_locations_match_list \
	    "$cmd_prefix $linespec" {
		"struct_with_const_overload::const_overload_fn()"
	    }

	set linespec "'const_overload_fn() const'"
	test_gdb_complete_unique "$cmd_prefix $linespec" "$cmd_prefix $linespec"
	check_bp_locations_match_list \
	    "$cmd_prefix $linespec" {
		"struct_with_const_overload::const_overload_fn() const"
	    }
    }
}

# Test that when the function is unambiguous, linespec completion
# appends the end quote char automatically, both ' and ".

proc_with_prefix append-end-quote-char-when-unambiguous {} {
    foreach cmd_prefix {"b" "b -function"} {
	foreach qc $completion::all_quotes_list {
	    set linespec "${qc}not_overloaded_fn()${qc}"
	    foreach cmd [list "$cmd_prefix ${qc}not_overloaded_fn()" \
			      "$cmd_prefix ${qc}not_overloaded_fn" \
			      "$cmd_prefix ${qc}not_overloaded_"] {
		test_gdb_complete_unique $cmd "$cmd_prefix $linespec"
	    }
	    check_bp_locations_match_list \
		"$cmd_prefix $linespec" {"not_overloaded_fn()"}
	}
    }
}

# Test completing symbols of source files.

proc_with_prefix in-source-file-unconstrained {} {
    # First test that unconstrained matching picks up functions from
    # multiple files.
    test_gdb_complete_multiple "b " "file_constrained_test" "_cpls" {
	"file_constrained_test_cpls2_function(int)"
	"file_constrained_test_cpls_function(int)"
    }
    check_setting_bp_fails "b file_constrained_test_cpls"
}

# Test an unambiguous completion that would be ambiguous if it weren't
# for the source file component, due to
# "file_constrained_test_cpls_function" in cpls.cc.  Test with
# different components quoted, and with whitespace before the function
# name.

proc_with_prefix in-source-file-unambiguous {} {
    foreach sqc $completion::maybe_quoted_list {
	foreach fqc $completion::maybe_quoted_list {
	    # Linespec.
	    foreach sep {":" ": "} {
		set linespec \
		    "${sqc}cpls2.cc${sqc}${sep}${fqc}file_constrained_test_cpls2_function(int)${fqc}"
		set complete_line "b $linespec"
		set start [index_after "constrained_test" $complete_line]
		set input_line [string range $complete_line 0 $start]
		test_gdb_complete_unique $input_line ${complete_line}
		check_bp_locations_match_list "b $linespec" {
		    "file_constrained_test_cpls2_function(int)"
		}
	    }

	    # Explicit location.
	    set source_opt "-source ${sqc}cpls2.cc${sqc}"
	    set function_opt "-function ${fqc}file_constrained_test_cpls2_function(int)${fqc}"
	    set complete_line "b $source_opt $function_opt"
	    set start [index_after "cpls2_functio" $complete_line]
	    set input_line [string range $complete_line 0 $start]
	    test_gdb_complete_unique $input_line ${complete_line}
	    check_bp_locations_match_list "$complete_line" {
		    "file_constrained_test_cpls2_function(int)"
	    }
	}
    }
}

# Test an ambiguous completion constrained by a source file.  Test
# with different components quoted, and with whitespace before the
# function name.

proc_with_prefix in-source-file-ambiguous {} {
    foreach sqc $completion::maybe_quoted_list {
	foreach fqc $completion::maybe_quoted_list {
	    # Linespec.
	    foreach sep {":" ": "} {
		set cmd_prefix "b ${sqc}cpls2.cc${sqc}${sep}"
		test_gdb_complete_multiple "${cmd_prefix}" ${fqc} "" {
		    "another_file_constrained_test_cpls2_function(int)"
		    "file_constrained_test_cpls2_function(int)"
		} ${fqc} ${fqc}
	    }

	    # Explicit location.
	    test_gdb_complete_multiple \
		"b -source ${sqc}cpls2.cc${sqc} -function " ${fqc} "" {
		"another_file_constrained_test_cpls2_function(int)"
		"file_constrained_test_cpls2_function(int)"
	    } ${fqc} ${fqc}
	}
    }
}

# Check that completing a file name in a linespec auto-appends a colon
# instead of a whitespace character.

proc_with_prefix source-complete-appends-colon {} {
    # Test with quotes to make sure the end quote char is put at the
    # right place.
    foreach qc $completion::maybe_quoted_list {
	test_gdb_complete_unique \
	    "b ${qc}cpls2." \
	    "b ${qc}cpls2.cc${qc}" ":"
	test_gdb_complete_unique \
	    "b ${qc}cpls2.c" \
	    "b ${qc}cpls2.cc${qc}" ":"
	test_gdb_complete_unique \
	    "b ${qc}cpls2.cc" \
	    "b ${qc}cpls2.cc${qc}" ":"

	# Same, but with a filename with an hyphen (which is normally
	# a language word break char).
	test_gdb_complete_unique \
	    "b ${qc}cpls-" \
	    "b ${qc}cpls-hyphen.cc${qc}" ":"
	test_gdb_complete_unique \
	    "b ${qc}cpls-hyphen" \
	    "b ${qc}cpls-hyphen.cc${qc}" ":"
    }

    # Test the same, but with the name of a nonexisting file.

    # Cursor at the end of the string.
    test_gdb_complete_none "b nonexistingfilename.cc"
    # Cursor past the end of the string.
    test_gdb_complete_multiple "b nonexistingfilename.cc " "" "" \
	$completion::keyword_list
    foreach qc $completion::all_quotes_list {
	# Unterminated quote.
	test_gdb_complete_none "b ${qc}nonexistingfilename.cc"
	test_gdb_complete_none "b ${qc}nonexistingfilename.cc "
	# Terminated quote, cursor at the quote.
	test_gdb_complete_unique \
	    "b ${qc}nonexistingfilename.cc${qc}" \
	    "b ${qc}nonexistingfilename.cc${qc}"
	# Terminated quote, cursor past the quote.
	test_gdb_complete_multiple \
	    "b ${qc}nonexistingfilename.cc${qc} " "" "" \
	    $completion::keyword_list
    }
}

####################################################################

# Test that a colon at the end of the linespec is understood as an
# incomplete scope operator (incomplete-scope-colon), instead of a
# source/function separator.

proc_with_prefix incomplete-scope-colon {} {

    # Helper for the loop below to simplify it.  Tests completion of
    # the range defined by the RANGE_SS found in the constructed line.
    #
    # E.g., with:
    #
    #   source="source.cc"
    #   fqc="'"
    #   prototype="ns::function()"
    #   range_ss="s::f"
    #
    # we'd try completing with the cursor set in each of the
    # underlined range's positions of:
    #
    #   b source.cc:'ns::function()'"
    #                 ^^^^
    #
    # Also test that setting a breakpoint at the constructed line
    # finds the same breakpoint location as completion does.
    #
    proc incomplete_scope_colon_helper {prototype range_ss {skip_check_bp 0}} {
	foreach source {"" "cpls.cc"} {
	    # Test with and without source quoting.
	    foreach sqc $completion::maybe_quoted_list {
		if {$source == "" && $sqc != ""} {
		    # Invalid combination.
		    continue
		}

		# Test with and without function quoting.
		foreach fqc $completion::maybe_quoted_list {
		    if {$source == ""} {
			set linespec_source ""
			set explicit_source ""
		    } else {
			set linespec_source "${sqc}${source}${sqc}:"
			set explicit_source "-source ${sqc}${source}${sqc}"
		    }

		    # Even though this use case is trickier with
		    # linespecs due to the ":" as separator, test both
		    # linespecs and explicit locations for
		    # completeness.
		    foreach location [list \
					  "${linespec_source}${fqc}$prototype${fqc}" \
					  "${explicit_source} -function ${fqc}$prototype${fqc}"] {
			set complete_line "b $location"
			set start [string first $range_ss $complete_line]
			set end [expr ($start + [string length $range_ss])]
			test_complete_prefix_range $complete_line $start $end
			if {!$skip_check_bp} {
			    check_bp_locations_match_list "b $location" [list "$prototype"]
			}
		    }
		}
	    }
	}
    }

    incomplete_scope_colon_helper \
	"struct_incomplete_scope_colon_test::incomplete_scope_colon_test()" \
	"t::i"

    incomplete_scope_colon_helper \
	"ns_incomplete_scope_colon_test::incomplete_scope_colon_test()" \
	"t::i"

    # Test completing around both "::"s.
    foreach range_ss {"t::s" "t::i"} skip_check_bp {0 1} {
	incomplete_scope_colon_helper \
	    "ns2_incomplete_scope_colon_test::struct_in_ns2_incomplete_scope_colon_test::incomplete_scope_colon_test()" \
	    $range_ss $skip_check_bp
    }
}

# Test completing functions/methods in anonymous namespaces.

proc_with_prefix anon-ns {} {
    foreach cmd_prefix {"b" "b -function"} {
	foreach qc $completion::maybe_quoted_list {
	    test_gdb_complete_unique \
		"$cmd_prefix ${qc}anon_ns_function" \
		"$cmd_prefix ${qc}anon_ns_function()${qc}"
	    check_bp_locations_match_list "$cmd_prefix ${qc}anon_ns_function()${qc}" {
		"(anonymous namespace)::anon_ns_function()"
		"(anonymous namespace)::anon_ns_struct::anon_ns_function()"
		"the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_function()"
		"the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_struct::anon_ns_function()"
	    }
	}

	# A "(" finds all anonymous namespace functions/methods in all
	# scopes.
	test_gdb_complete_multiple "$cmd_prefix " "(" "anonymous namespace)::" {
	    "(anonymous namespace)::anon_ns_function()"
	    "(anonymous namespace)::anon_ns_struct::anon_ns_function()"
	    "(anonymous namespace)::overload2_function(overload2_arg3)"
	    "(anonymous namespace)::overload3_function(int)"
	    "(anonymous namespace)::overload3_function(long)"
	    "(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg4)"
	    "(anonymous namespace)::struct_overload3_test::overload3_function(int)"
	    "(anonymous namespace)::struct_overload3_test::overload3_function(long)"
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)"
	    "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)"
	    "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)"
	    "ns_overload2_test::(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg8)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(long)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(long)"
	    "ns_overload3_test::(anonymous namespace)::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::overload3_function(long)"
	    "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(int)"
	    "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(long)"
	    "the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_function()"
	    "the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_struct::anon_ns_function()"
	}

	set function "the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_function()"
	test_gdb_complete_unique "$cmd_prefix $function" "$cmd_prefix $function"
	check_bp_locations_match_list "$cmd_prefix $function" [list $function]

	# Test completing after the "(anonymous namespace)" part.
	test_gdb_complete_unique \
	    "$cmd_prefix the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_fu" \
	    "$cmd_prefix $function"

	# Test whitespace in the "(anonymous namespace)" component.

	test_gdb_complete_unique \
	    "$cmd_prefix the_anon_ns_wrapper_ns::( anonymous   namespace )::anon_ns_fu" \
	    "$cmd_prefix the_anon_ns_wrapper_ns::( anonymous   namespace )::anon_ns_function()"
	check_setting_bp_fails \
	    "$cmd_prefix the_anon_ns_wrapper_ns::( anonymous   namespace )::anon_ns_fu"

	set function_ws \
	    "the_anon_ns_wrapper_ns::( anonymous   namespace )::anon_ns_function ( )"
	test_gdb_complete_unique "$cmd_prefix $function_ws" "$cmd_prefix $function_ws"
	check_bp_locations_match_list "$cmd_prefix $function_ws" [list $function]
    }
}

# Basic test for completing "operator<".  More extensive C++ operator
# tests in cpls-op.exp.

proc_with_prefix operator< {} {
    # Complete all prefixes between "oper" and the whole prototype.
    set function "operator<(foo_enum, foo_enum)"
    foreach cmd_prefix {"b" "b -function"} {
	set line "$cmd_prefix $function"
	set start [index_after "oper" $line]
	test_complete_prefix_range $line $start
    }

    # There's a label in the function; try completing it.  (Exhaustive
    # label completion tests further below.)
    foreach location [list \
		     "$function:label1" \
		     "-function $function -label label1"] {

	set cmd "b $location"
	set input_line [string range $cmd 0 [expr [string length $cmd] - 3]]

	test_gdb_complete_unique $input_line $cmd
	test_gdb_complete_unique $cmd $cmd
	check_bp_locations_match_list $cmd [list "$location"]
    }
}

# Test completion of scopes with an ambiguous prefix.

proc_with_prefix ambiguous-prefix {} {
    foreach cmd_prefix {"b" "b -function"} {
	test_gdb_complete_multiple "$cmd_prefix " "ambiguous_pre" "fix_" {
	    "ambiguous_prefix_global_func()"
	    "the_ambiguous_prefix_ns::ambiguous_prefix_ns_func()"
	    "the_ambiguous_prefix_struct::ambiguous_prefix_method()"
	}
	check_setting_bp_fails "$cmd_prefix ambiguous_prefix_"
    }
}

# Test completion of function labels.

proc_with_prefix function-labels {} {
    # Test with and without a source file component.
    foreach_location_functions \
	{ "" "cpls.cc" } \
	{ "function_with_labels(int)" } \
	{
	    # Linespec version.  Test various spacing around the label
	    # colon separator.
	    foreach label_sep {":" " :" ": " " : "} {
		set linespec "${location}${label_sep}"
		test_gdb_complete_multiple "b $linespec" "l" "abel" {
		    "label1"
		    "label2"
		}
		check_setting_bp_fails "b ${linespec}label"

		set tsep [string trim ${source_sep}]
		check_bp_locations_match_list \
		    "b ${linespec}label1" [list "${source}${tsep}${function}:label1"]
		check_bp_locations_match_list \
		    "b ${linespec}label2" [list "${source}${tsep}${function}:label2"]
	    }
	} \
	{
	    # Explicit locations version.
	    append location " -label"
	    test_gdb_complete_multiple "b $location " "l" "abel" {
		"label1"
		"label2"
	    }
	    check_setting_bp_fails "b $location label"

	    if {$source != ""} {
		set bp_loc_src "-source ${source} "
	    } else {
		set bp_loc_src ""
	    }
	    check_bp_locations_match_list \
		"b ${location} label1" [list "${bp_loc_src}-function $function -label label1"]
	    check_bp_locations_match_list \
		"b ${location} label2" [list "${bp_loc_src}-function $function -label label2"]
	}
}

# Test that completion after a function name offers keyword
# (if/task/thread/-force-condition) matches in linespec mode, and also
# the explicit location options in explicit locations mode.

proc_with_prefix keywords-after-function {} {
    set explicit_list \
	[lsort [concat \
		    $completion::explicit_opts_list \
		    $completion::keyword_list]]

    # Test without a source file, with a known source file, and with
    # and unknown source file.
    # Test a known and an unknown function.
    foreach_location_functions \
	{ "" "cpls.cc" "unknown_file.cc" } \
	{ "function_with_labels(int)" "unknown_function(int)" } \
	{
	    # Linespec version.
	    test_gdb_complete_multiple "b ${location} " "" "" \
		$completion::keyword_list
	} \
	{
	    # Explicit locations version.
	    test_gdb_complete_multiple "b ${location} " "" "" \
		$explicit_list
	}
}

# Same, but after a label.

proc_with_prefix keywords-after-label {} {
    set explicit_list \
	[lsort [concat \
		    $completion::explicit_opts_list \
		    $completion::keyword_list]]

    foreach_location_labels \
	{ "" "cpls.cc" } \
	{ "function_with_labels(int)" "unknown_function(int)" } \
	{ "label1" "non_existing_label" } \
	{
	    # Linespec version.
	    test_gdb_complete_multiple "b ${location} " "" "" \
		$completion::keyword_list
	} \
	{
	    # Explicit locations version.
	    test_gdb_complete_multiple "b ${location} " "" "" \
		$explicit_list
	}
}

# Similar, but after an unknown file, and in linespec mode only.

proc_with_prefix keywords-after-unknown-file {} {
    # Test with and without quoting.
    foreach qc $completion::maybe_quoted_list {
	set line "b ${qc}unknown_file.cc${qc}: "
	test_gdb_complete_multiple $line "" "" $completion::keyword_list
    }
}

# Test that linespec / function completion does not match data
# symbols, only functions/methods.

proc_with_prefix no-data-symbols {} {
    foreach cmd_prefix {"b" "b -function"} {
	test_gdb_complete_unique "$cmd_prefix code_" "$cmd_prefix code_function()"
    }
}


# After "if", we expect an expression, which has a different completer
# that matches data symbols as well.  Check that that works.

proc_with_prefix if-expression {} {
    foreach cmd_prefix {"b" "b -function"} {
	test_gdb_complete_multiple "$cmd_prefix function() if " "code_" "" {
	    "code_data"
	    "code_function()"
	}

	test_gdb_complete_unique \
	    "$cmd_prefix function() if code_data + another_da" \
	    "$cmd_prefix function() if code_data + another_data"

	test_gdb_complete_unique \
	    "$cmd_prefix non_existing_function() if code_data + another_da" \
	    "$cmd_prefix non_existing_function() if code_data + another_data"

	# FIXME: For now, thread and task also use the expression
	# completer.
	test_gdb_complete_unique \
	    "$cmd_prefix function() thread code_data + another_da" \
	    "$cmd_prefix function() thread code_data + another_data"
	test_gdb_complete_unique \
	    "$cmd_prefix function() task code_data + another_da" \
	    "$cmd_prefix function() task code_data + another_data"
    }
}

# The testcase driver.  Calls all test procedures.

proc test_driver {} {
    all-param-prefixes
    overload
    overload-2
    fqn
    fqn-2
    overload-3
    template-overload
    template-ret-type
    #test_makefoo
    template-function-foo
    #test_makem
    template-class-with-method
    const-overload
    const-overload-quoted
    append-end-quote-char-when-unambiguous
    in-source-file-unconstrained
    in-source-file-unambiguous
    in-source-file-ambiguous
    source-complete-appends-colon
    incomplete-scope-colon
    anon-ns
    operator<
    ambiguous-prefix
    function-labels
    keywords-after-function
    keywords-after-label
    keywords-after-unknown-file
    no-data-symbols
    if-expression
}

test_driver