def run_test(): # Set an editor read only b1 = GPS.EditorBuffer.get(GPS.File("foo.adb")) b1.set_read_only(True) expected1 = b1.get_chars() # Do a renaming on a second editor b2 = GPS.EditorBuffer.get(GPS.File("bar.adb")) b2.current_view().goto(b2.at(7, 16)) expected2 = b2.get_chars() yield idle_modal_dialog(lambda: GPS.execute_action("rename entity")) new_name_ent = get_widget_by_name("new_name") new_name_ent.set_text("Bye") dialog = get_window_by_title("Renaming entity") # Don't allow the permission to change check = get_button_from_label("Make files writable", dialog) check.set_active(False) get_stock_button(dialog, Gtk.STOCK_OK).clicked() yield timeout(500) # A dialog reporting an error should be opened, reply no to it error_dialog = get_window_by_title( "Refactoring - rename Hello to Bye raises errors") GPS.Console().write(str(error_dialog)) get_button_from_label("Undo", error_dialog).clicked() yield wait_idle() gps_assert(b1.get_chars(), expected1, "The read only buffer should not be modified") gps_assert(b2.get_chars(), expected2, "The writable buffer should be restored")
def run_test(): # Open main.adb and check that 'copy_base_file_name' works buf = GPS.EditorBuffer.get(GPS.File("main.adb")) GPS.execute_action("copy_base_file_name") clipboard_contents = GPS.Clipboard().contents() gps_assert(clipboard_contents[GPS.Clipboard().current()], "main.adb", "copy_base_file_name not working on focused editors") # Close the editor and select main.adb in the Project view # and check that 'copy_file_name' works explorer = get_widget_by_name("Project Explorer Tree") windows = Gtk.Window.list_toplevels() explorer.grab_focus() select_in_tree(explorer, column=1, key="main.adb") GPS.execute_action("copy_file_name") clipboard_contents = GPS.Clipboard().contents() gps_assert(clipboard_contents[GPS.Clipboard().current()], GPS.File(os.path.join(GPS.pwd(), "main.adb")).path, "copy_file_name not working on files in the Project view") # Check that 'copy_file_name' works on directories from the # Project view select_in_tree(explorer, column=1, key=".") GPS.execute_action("copy_file_name") clipboard_contents = GPS.Clipboard().contents() gps_assert(clipboard_contents[GPS.Clipboard().current()], GPS.File(os.path.join(GPS.pwd())).path, "copy_file_name not working on dirs in the Project view")
def run_test(): buf = GPS.EditorBuffer.get(GPS.File('main.adb')) buf.current_view().goto(buf.at(5, 10)) GPS.execute_action('goto declaration') yield hook("language_server_response_processed") current_buf = GPS.EditorBuffer.get() gps_assert(current_buf.file(), GPS.File('hello_world.ads'), "'goto declaration' did not open the right file") current_loc = current_buf.main_cursor().location() gps_assert(current_loc, current_buf.at(3, 33), "'goto declaration' did not jump to right location") GPS.execute_action('goto body') yield hook("language_server_response_processed") current_buf = GPS.EditorBuffer.get() gps_assert(current_buf.file(), GPS.File('hello_world.adb'), "'goto body' did not open the right file") current_loc = current_buf.main_cursor().location() gps_assert(current_loc, current_buf.at(5, 33), "'goto body' did not jump to right location")
def run_test(): buf_1 = GPS.EditorBuffer.get(GPS.File("main.adb")) yield wait_tasks() # Add a special line buf_1.add_special_line(3, "Special line") # Fold the main procedure in main.adb buf_1.at(3, 2).block_fold() # Rename the Print method buf_2 = GPS.EditorBuffer.get(GPS.File("a.ads")) buf_2.current_view().goto(buf_2.at(7, 16)) yield wait_idle() yield idle_modal_dialog(lambda: GPS.execute_action("rename entity")) new_name_ent = get_widget_by_name("new_name") new_name_ent.set_text("Pri") dialog = get_window_by_title("Renaming entity") yield idle_modal_dialog( lambda: get_stock_button(dialog, Gtk.STOCK_OK).clicked()) yield timeout(500) gps_assert( buf_1.get_chars(buf_1.at(6, 1), buf_1.at(6, 1).end_of_line()).strip(), "Pri (ObjA);", "Renaming dit not work correctly in folded block", )
def edit_dg(dg, source_filename, line, for_subprogram, in_external_editor): global highlighting, expanded_code_marks # If we are showing the dg in an external editor, simply open this editor # and jump to the line if in_external_editor: buf = GPS.EditorBuffer.get(GPS.File(dg)) loc = buf.at(1, 1) try: (frm, to) = loc.search("^-- " + repr(line) + ":", regexp=True) if frm: buf.current_view().goto(frm.forward_line(1)) except Exception: pass return clear_dg(source_filename) srcbuf = GPS.EditorBuffer.get(GPS.File(source_filename)) if for_subprogram: (block_first, block_last) = subprogram_bounds(srcbuf.current_view().cursor()) else: (block_first, block_last) = (0, 0) # Read the text of the dg file f = open(dg) txt = f.read() f.close() current_code = [] current_line = 1 lines = 0 for line in txt.split("\n"): if line.startswith("-- "): if current_code: if (block_first == 0 or (block_first < current_line < block_last)): mark = srcbuf.add_special_line(current_line + 1, "\n".join(current_code), highlighting) # Add mark to the list of marks mark_num = (mark, len(current_code)) if source_filename in expanded_code_marks: expanded_code_marks[source_filename] += [mark_num] else: expanded_code_marks[source_filename] = [mark_num] current_line = int(line[3:line.find(":")]) current_code = [] else: if line != "": lines += 1 current_code.append(line)
def run_test(): buf = GPS.EditorBuffer.get(GPS.File('main.adb')) buf.current_view().goto(buf.at(5, 10)) # wait LSP responses has been processed to have folding information if GPS.LanguageServer.is_enabled_for_language_name("Ada"): yield wait_tasks(other_than=known_tasks) GPS.execute_action('goto declaration') yield wait_language_server('textDocument/declaration') current_buf = GPS.EditorBuffer.get() gps_assert(current_buf.file(), GPS.File('hello_world.ads'), "'goto declaration' did not open the right file") current_loc = current_buf.main_cursor().location() gps_assert(current_loc, current_buf.at(3, 33), "'goto declaration' did not jump to right location") # wait LSP responses has been processed to have folding information if GPS.LanguageServer.is_enabled_for_language_name("Ada"): yield wait_tasks(other_than=known_tasks) GPS.execute_action('goto body') yield wait_language_server('textDocument/implementation') current_buf = GPS.EditorBuffer.get() gps_assert(current_buf.file(), GPS.File('hello_world.adb'), "'goto body' did not open the right file") current_loc = current_buf.main_cursor().location() gps_assert(current_loc, current_buf.at(5, 33), "'goto body' did not jump to right location")
def run_test(): GPS.Preference("LSP-Limit-Formatting").set(True) buf = GPS.EditorBuffer.get(GPS.File("main.cpp")) init_buf = buf.get_chars(include_hidden_chars=False) buf.current_view().goto(buf.at(2, 1)) send_key_event(GDK_TAB) yield wait_idle() gps_assert(different_lines(buf.get_chars(include_hidden_chars=False), init_buf), 1, "Too many different lines without selection") gps_assert(buf.get_chars(include_hidden_chars=False), MAIN_EXPECTED, "Wrong formatting without selection") buf = GPS.EditorBuffer.get(GPS.File("foo.cpp")) init_buf = buf.get_chars(include_hidden_chars=False) buf.select(buf.at(2, 3), buf.at(4, 8)) send_key_event(GDK_TAB) yield wait_idle() gps_assert(different_lines(buf.get_chars(include_hidden_chars=False), init_buf), 3, "Too many different lines with selection") gps_assert(buf.get_chars(include_hidden_chars=False), FOO_EXPECTED, "Wrong formatting with selection")
def remove_ce(ce): for file in ce: if GPS.File(file).language() == "ada": buf = GPS.EditorBuffer.get(GPS.File(file)) remove_ce_special_lines(buf) overlay = get_trace_overlay(buf) buf.remove_overlay(overlay)
def test_driver(): GPS.Preference("Debugger-Pending-Breakpoints").set(True) # Set a breakpoint in the Ada library buf = GPS.EditorBuffer.get(GPS.File("p.adb")) buf.current_view().goto(buf.at(8, 1)) yield wait_idle() GPS.execute_action("debug set line breakpoint") yield wait_tasks() # Build and debug the C main: the Ada library is not loaded # at this stage so the breakpoint should be marked as pending GPS.execute_action("Build & Debug Number 1") yield hook('debugger_started') yield wait_idle() # Run the debugger and verify that we reach the breakpoint debug = GPS.Debugger.get() debug.send("run") yield timeout(300) gps_assert(debug.current_file, GPS.File("p.adb"), "The pending breakpoint has not been reached") gps_assert(debug.current_line, 8, "The pending breakpoint has not been reached")
def test_driver(): adb_file = GPS.File("main.adb") ads_file = GPS.File("main.ads") # Open ADB file, do modifications, check for diagnostics. adb_buffer = GPS.EditorBuffer.get(adb_file) location = GPS.EditorLocation(adb_buffer, 3, 16) adb_buffer.insert(location, " ") yield timeout(diagnosticTimeout) gps_assert(GPS.Locations.list_locations("Diagnostics", adb_file.path), [GPS.FileLocation(adb_file, 3, 17), "Missing ';'"], "Unexpected diagnostics (assertion 1)") # Save and close ADB file. adb_buffer.save() adb_buffer.close() # Reopen ADB file and check for diagnostics adb_buffer = GPS.EditorBuffer.get(adb_file) yield timeout(diagnosticTimeout) if diagnosticOnDidOpen: gps_assert(GPS.Locations.list_locations("Diagnostics", adb_file.path), [GPS.FileLocation(adb_file, 3, 17), "Missing ';'"], "Unexpected diagnostics (assertion 2)") # Undo changes, check for diagnostics location = GPS.EditorLocation(adb_buffer, 3, 16) adb_buffer.delete(location, location) yield timeout(diagnosticTimeout) gps_assert(GPS.Locations.list_locations("Diagnostics", adb_file.path), [], "Unexpected diagnostics (assertion 3)") # Create new file, fill it, save as ADS and check for diagnostics ads_buffer = GPS.EditorBuffer.get_new() location = ads_buffer.at(1, 1) ads_buffer.insert(location, "procedure Main") ads_buffer.save(False, ads_file) yield timeout(diagnosticTimeout) if diagnosticOnDidOpen: gps_assert(GPS.Locations.list_locations("Diagnostics", ads_file.path), [GPS.FileLocation(adb_file, 1, 16), "Missing ';'"], "Unexpected diagnostics (assertion 4)") # Fix error in ADS file and check for diagnostics location = ads_buffer.at(1, 16) ads_buffer.insert(location, ";") yield timeout(diagnosticOnDidOpen) gps_assert(GPS.Locations.list_locations("Diagnostics", adb_file.path), [], "Unexpected diagnostics (assertion 5)")
def build_and_debug(main_name): """ Generator to debug a program launched in the emulator. """ # STEP 1.0 get main name if main_name is None: GNATemulator.__error_exit(msg="Main not specified.") return # STEP 1.5 Build it try: yield GNATemulator.build(main_name) except RuntimeError: # Build error, we stop there return binary = GPS.File(main_name).executable_path.path # STEP 2 Switch to the "Debug" perspective To have GNATemu console in # the debugger perspective. GPS.MDI.load_perspective("Debug") # STEP 2 load with Emulator debug_port = GPS.Project.root().get_attribute_as_string( package="Emulator", attribute="Debug_Port") # TODO: remove this fall-back once GNATemulator supports the # new 'Debug_Port' attribute (Fabien's task) if debug_port == "": debug_port = "1234" yield GNATemulator.run_gnatemu( ["--freeze-on-startup", "--gdb=%s" % debug_port, binary]) log("... done.") # STEP 3 launch the debugger try: debugger_promise = promises.DebuggerWrapper( GPS.File(binary), remote_target="localhost:" + debug_port, remote_protocol="remote") except Exception: GNATemulator.__error_exit("Could not initialize the debugger.") return # block execution until debugger is free r3 = yield debugger_promise.wait_and_send(block=True) if not r3: GNATemulator.__error_exit("Could not initialize the debugger.") return log("... done.")
def test_driver(): GPS.EditorBuffer.get(GPS.File("main.adb")) GPS.execute_action("gnatcheck file") yield wait_tasks(other_than=known_tasks) # If GNATcheck succeed to run, we should have a message in the # Locations view complaining about the comments style msgs = GPS.Message.list(file=GPS.File("main.adb"), category="Coding Standard violations") gps_assert(len(msgs), 1, "No gnatcheck messages in the Locations")
def run_test(): test_buf = GPS.EditorBuffer.get(GPS.File("test.ads")) GPS.execute_action("Lock or unlock current editor") test_buf.current_view().goto(test_buf.at(3, 1).end_of_line()) GPS.execute_action("backward delete") gps_assert(test_buf.is_modified(), True, "Locked editors should still be editable") GPS.execute_action("undo") main_buf = GPS.EditorBuffer.get(GPS.File("main.adb")) main_buf.current_view().goto(main_buf.at(5, 10)) GPS.execute_action("goto declaration") yield wait_language_server("textDocument/declaration", "Ada") gps_assert( len(test_buf.views()), 2, "Opened view for test.ads is locked: another view should have " + "been opened") test_buf.views()[0].destroy() GPS.MDI.get("test.ads").raise_window() yield wait_idle() GPS.execute_action("backward delete") GPS.execute_action("Compile File") yield wait_tasks(other_than=known_tasks) msgs = GPS.Message.list(category="Builder results") gps_assert(len(msgs), 1, "We should have an error after compiling") gps_assert( len(test_buf.views()), 2, "Opened view for test.ads is locked: another view should have " + "been opened after appearance of compilation error in " + "Locations") test_buf.views()[0].destroy() GPS.execute_action("Global Search in context: file names") yield wait_idle() field = get_widget_by_name("global_search") field.set_text("test.ads") yield timeout(1000) send_key_event(GDK_DOWN) send_key_event(GDK_RETURN) yield wait_idle() gps_assert( len(test_buf.views()), 2, "Opened view for test.ads is locked: another view should have " + "been opened when selecting test.ads via the omnisearch")
def on_gps_start(hook): # Disable launching of browser on exit GPS.Preference("Doc-Spawn-Browser").set(False) GPS.Docgen.register_tag_handler(ScreenshotTagHandler()) GPS.Docgen.register_tag_handler(ExampleTagHandler()) GPS.Docgen.register_css(GPS.File("gtkada.css")) GPS.Docgen.register_main_index(GPS.File("gtkada_rm/groups.html")) GPS.Project.root().generate_doc(True) GPS.Timeout(500, wait_doc)
def test_driver(): # Add recognized breakpoints main = GPS.File(MAIN) buf1 = GPS.EditorBuffer.get(main) add_breakpoint(buf1, 7) # At line 8 when the debugger starts add_breakpoint(buf1, 11) add_breakpoint(buf1, 12) # Add a unrecognized breakpoint buf2 = GPS.EditorBuffer.get(GPS.File(ALONE)) add_breakpoint(buf2, 3) # Open the Breakpoints view and check that the breakpoints has been set GPS.execute_action("open breakpoints editor") yield wait_for_mdi_child('Breakpoints') view = GPS.MDI.get("Breakpoints") tree = get_widgets_by_type(Gtk.TreeView, view.pywidget())[0] model = tree.get_model() check_breakpoints(model, [MAIN, MAIN, MAIN, ALONE], [7, 11, 12, 3], "adding breakpoints via the editors") # Launch the debugger, modify the breakpoints list and quit GPS.execute_action("Build & Debug Number 1") yield hook('debugger_started') debug = GPS.Debugger.get() debug.break_at_location(main, 4) yield wait_until_not_busy(debug) debug.send("run") yield wait_until_not_busy(debug) check_breakpoints(model, [MAIN, MAIN, MAIN, MAIN], [8, 11, 12, 4], "starting the debugger") gps_assert(debug.current_line, 4, "The debugger should stop at the newly created breakpoint") # Deleting breakpoints should update the list debug.send("delete 2 3") yield wait_until_not_busy(debug) check_breakpoints(model, [MAIN, MAIN], [8, 4], "deleting breakpoints via the debugger") # Closing the debugger should add the unrecognized breakpoint debug.close() check_breakpoints(model, [MAIN, MAIN, ALONE], [8, 4, 3], "closing the debugger")
def run_test(): ls_pid = get_language_server_pid() gps_assert(ls_pid is not None, True, "couldn't get the language server PID") # Kill the language server os.kill(ls_pid, signal.SIGKILL) # Wait for the language server to relaunch yield hook("language_server_started") # Give the language server the time to process all the events # (init, didChangeConfiguration, didOpenFile, etc) # because otherwise the call to "lanugage_server_response_processed" # below will catch one of those. yield timeout(1000) # Get the new language server PID new_ls_pid = get_language_server_pid() gps_assert(new_ls_pid is not None, True, "couldn't get the new language server PID after kill") gps_assert(ls_pid != new_ls_pid, True, "the language server wasn't killed") # Verify the functionality of the new language server buf = GPS.EditorBuffer.get(GPS.File('main.adb')) buf.current_view().goto(buf.at(5, 10)) # wait LSP responses has been processed to have folding information if GPS.LanguageServer.is_enabled_for_language_name("Ada"): yield wait_tasks(other_than=known_tasks) GPS.execute_action('goto declaration') yield hook("language_server_response_processed") current_buf = GPS.EditorBuffer.get() gps_assert(current_buf.file(), GPS.File('hello_world.ads'), "'goto declaration' did not open the right file") # Verify that there isn't the error message in the console gps_assert("had to be restarted more than" in GPS.Console().get_text(), False, "the error message about language server showed unexpectedly") # Now try to kill the language server too many times for j in range(5): ls_pid = get_language_server_pid() if ls_pid: os.kill(ls_pid, signal.SIGKILL) yield timeout(200) # Verify that there is the error message in the console gps_assert("had to be restarted more than" in GPS.Console().get_text(), True, "the error message about language server showed unexpectedly")
def __emu_debug_wf(self, main_name): """ Workflow to debug a program under the emulator. """ # STEP 1.0 get main name if main_name is None: self.__error_exit(msg="Main not specified.") return # STEP 1.5 Build it log("Building Main %s..." % main_name) builder = promises.TargetWrapper("Build Main") r0 = yield builder.wait_on_execute(main_name) if r0 is not 0: self.__error_exit(msg="Build error.") return binary = GPS.File(main_name).executable_path.path log("... done.") # STEP 2 Switch to the "Debug" perspective To have GNATemu console in # the debugger perspective. GPS.MDI.load_perspective("Debug") # STEP 2 load with Emulator debug_port = GPS.Project.root().get_attribute_as_string( package="Emulator", attribute="Debug_Port") # TODO: remove this fall-back once GNATemulator supports the # new 'Debug_Port' attribute (Fabien's task) if debug_port == "": debug_port = "1234" self.run_gnatemu( ["--freeze-on-startup", "--gdb=%s" % debug_port, binary]) log("... done.") # STEP 3 launch the debugger debugger_promise = promises.DebuggerWrapper( GPS.File(binary), remote_target="localhost:" + debug_port, remote_protocol="remote") # block execution until debugger is free r3 = yield debugger_promise.wait_and_send(block=True) if not r3: self.__error_exit("Could not initialize the debugger.") return log("... done.")
def test_driver(): GPS.EditorBuffer.get(GPS.File(FOO)) GPS.EditorBuffer.get(GPS.File(BAR)) cur = GPS.MDI.current() gps_assert(BAR in cur.name(), True, "Wrong focused MDI initially") # Button 9 is bounded to "move to previous tab" GPS.send_button_event(window=cur.pywidget().get_window(), type=Gdk.EventType.BUTTON_PRESS, button=9) GPS.process_all_events() gps_assert(FOO in GPS.MDI.current().name(), True, "The action was not triggered")
def run_test(): buf = GPS.EditorBuffer.get(GPS.File("main.adb")) buf.current_view().goto(buf.at(3, 32)) GPS.execute_action("goto declaration or body") yield wait_language_server("textDocument/definition", "Ada") current_buf = GPS.EditorBuffer.get() current_loc = current_buf.current_view().cursor() gps_assert(current_buf.file(), GPS.File("test.ads"), "Wrong file opened") gps_assert(current_loc.line(), 3, "Wrong location after 'goto declaration'")
def interactive_dependency_path(): """ Explains one of the reasons why a file depends on another one (through a chain of with clauses or #include statements). """ try: (file1, file2) = GPS.MDI.input_dialog("Show file dependency path", "From File", "To File") except: return print_dependency_path(GPS.File(file1), GPS.File(file2))
def on_gps_started(): buf_bb = GPS.EditorBuffer.get(GPS.File("bb.adb")) buf_a = GPS.EditorBuffer.get(GPS.File("a.adb")) yield wait_tasks(other_than=known_tasks) # Retrieve the "Window" menu items for all the displayed # views menu = get_widget_by_name("gtkada-mdi-children-menu") dump = [get_widgets_by_type(Gtk.Label, x)[0].get_label() \ for x in WidgetTree(menu) if \ isinstance(x, Gtk.MenuItem) and x.get_label() is None] gps_assert(dump, EXPECTED, "The 'Window' menu items are not correctly sorted")
def run_test(): b1 = GPS.EditorBuffer.get(GPS.File("my_class.hh")) buf = GPS.EditorBuffer.get(GPS.File("main.cpp")) yield wait_tasks() # timeout to let clangd indexing the files yield timeout(200) buf.current_view().goto(buf.at(7, 17)) yield wait_idle() GPS.execute_action("find all references") yield hook("language_server_response_processed") yield wait_idle() gps_assert(dump_locations_tree(), expected)
def test_driver(): GPS.Preference("LSP-Ada-Diagnostics").set(True) GPS.execute_action("Restart ada language server") yield hook('language_server_started') yield wait_tasks() f = GPS.File('to_be_called.adb') sf = GPS.File('second.adb') b = GPS.EditorBuffer.get(f) b.find_all_refs(b.at(1, 17), True) yield hook("language_server_response_processed") yield wait_tasks() gps_assert( GPS.Locations.list_locations( "References for To_Be_Called (to_be_called.adb:1)", sf.path), [GPS.FileLocation(sf, 1, 6), '[reference] with To_Be_Called;', GPS.FileLocation(sf, 4, 4), '[call] To_Be_Called;'], "wrong list of locations (1)") GPS.Locations.remove_category( "References for To_Be_Called (to_be_called.adb:1)") yield wait_tasks() # Reopen project GPS.execute_action('/File/Open Recent Projects/test.gpr') yield wait_tasks() b = GPS.EditorBuffer.get(f) b.find_all_refs(b.at(1, 17), True) yield hook("language_server_response_processed") yield wait_tasks() gps_assert( GPS.Locations.list_locations( "References for To_Be_Called (to_be_called.adb:1)", sf.path), [GPS.FileLocation(sf, 1, 6), '[reference] with To_Be_Called;', GPS.FileLocation(sf, 4, 4), '[call] To_Be_Called;'], "wrong list of locations (2)") l = GPS.EditorLocation(b, 1, 16) b.insert (l, " ") yield timeout(1000) gps_assert(GPS.Locations.list_locations("Diagnostics", f.path), [GPS.FileLocation(f, 1, 17), 'Invalid token, ignored', GPS.FileLocation(f, 1, 18), "Missing ';'"], "Unexpected diagnostics")
def run_test(): GPS.EditorBuffer.get(GPS.File("a.ads")) buf = GPS.EditorBuffer.get(GPS.File("main.adb")) buf.current_view().goto(buf.at(4, 14)) yield wait_idle() yield idle_modal_dialog(lambda: GPS.execute_action("rename entity")) new_name_ent = get_widget_by_name("new_name") new_name_ent.set_text("Object_Type_Aa") dialog = get_window_by_title("Renaming entity") yield idle_modal_dialog( lambda: get_stock_button(dialog, Gtk.STOCK_OK).clicked()) yield wait_idle()
def run_test(): buf = GPS.EditorBuffer.get(GPS.File("hello.h")) yield wait_idle() buf.current_view().goto(buf.at(12, 13)) yield hook('location_changed', debounced=True) yield timeout(1000) # Verify that navigation from 'hello.h' works fine and that # it correctly jumps to the corresponding c++ implementation # file. GPS.execute_action("goto declaration") yield wait_language_server("textDocument/declaration", "C") yield wait_until_true(lambda: GPS.EditorBuffer.get().file() == GPS.File("hello.cpp")) current_buf = GPS.EditorBuffer.get() current_loc = current_buf.current_view().cursor() gps_assert(current_buf.file(), GPS.File('hello.cpp'), "'goto declaration' did not open the right file") gps_assert(current_loc.line(), 12, "'goto declaration' did not got the right line") gps_assert(current_loc.column(), 24, "'goto declaration' did not got the right column") buf = GPS.EditorBuffer.get(GPS.File("hi.h")) buf.current_view().goto(buf.at(3, 8)) yield hook('location_changed', debounced=True) yield timeout(1000) # Verify that navigation from 'hi.h' works fine and that # it correctly jumps to the corresponding C implementation # file. GPS.execute_action("goto declaration") yield wait_language_server("textDocument/declaration", "C") yield timeout(1000) current_buf = GPS.EditorBuffer.get() current_loc = current_buf.current_view().cursor() gps_assert(current_buf.file(), GPS.File('hi.c'), "'goto declaration' did not open the right file") gps_assert(current_loc.line(), 4, "'goto declaration' did not got the right line") gps_assert(current_loc.column(), 17, "'goto declaration' did not got the right column")
def show_ce(ce): for file in ce: if GPS.File(file).language() == "ada": first = next(iter(ce[file]), None) if first: first_sloc = GPS.FileLocation(GPS.File(file), int(first), 1) buf = GPS.EditorBuffer.get(first_sloc.file()) goto_location(first_sloc) overlay = get_trace_overlay(buf) for line in ce[file]: text = get_str_indent(buf, int(line)) + "-- " + \ get_ce_text_for_line(ce[file][line]) add_ce_special_line(buf, int(line), text) buf.apply_overlay(overlay, buf.at(int(line), 1), buf.at(int(line), 1))
def test_driver(): GPS.Preference("Src-Editor-Fold-With-Use-Blocks").set(2) GPS.Preference("Src-Editor-Fold-Comment-reg1").set("testing") buf = GPS.EditorBuffer.get(GPS.File("main.adb")) yield wait_idle() gps_assert(buf.debug_dump_all_lines(), ['[0] el:1 (2)', '[1] el:2', '[1] el:3', '[0] el:4', '[0] el:5', '[0] el:6', '[0] el:7', '[0] el:8', '[0] el:9', '[0] el:10', '[0] el:11', '[0] el:12', '[0] el:13', '[0] el:14', '[0] el:15', '[0] el:16 (2)', '[1] el:17', '[1] el:18', '[0] el:19'], "line contents wrong after folding")
def run_test(): yield wait_tasks() GPS.Preference("Smart-Completion-Mode").set("3") GPS.Preference("Completion-Filter-Mode").set("Strict") buf = GPS.EditorBuffer.get(GPS.File("main.adb")) view = buf.current_view() view.goto(buf.at(5, 1).end_of_line()) yield wait_idle() for ch in ".Te": send_key_event(ord(ch)) yield timeout(100) # Verify that the completion window is there pop_tree = get_widget_by_name("completion-view") model = pop_tree.get_model() yield wait_until_true( lambda: model.get_value(model.get_iter_first(), 0) != "Computing...") gps_assert(pop_tree is not None, True, "The completion window should be open at that point") # Verify that the invisible 'Do_Nothing' subprogram is listed after # the visible one gps_assert(dump_tree_model(pop_tree.get_model(), LABEL_COLUMN), ['Text_IO'], "We should only match Text_IO in strict mode.")
def edit(self): if self.ruleseditor: # Already opened return prev_cmd = self.gnatCmd self.updateGnatCmd() if self.gnatCmd == "": return # gnat check command changed: we reinitialize the rules list if prev_cmd != self.gnatCmd or self.rules is None: self.rules = get_supported_rules(self.gnatCmd) # we retrieve the coding standard file from the project for opt in GPS.Project.root().get_attribute_as_list( "default_switches", package="check", index="ada" ): res = re.split("^\-from\=(.*)$", opt) if len(res) > 1: self.rules_file = GPS.File(res[1]) self.ruleseditor = rulesEditor(self.rules, self.rules_file) self.ruleseditor.connect('response', self.onResponse)
def async_fetch_status_for_all_files(self): _re = re.compile( '(?P<file>[^@@]+)(?P<sep>@@)?(?P<rev>[^\s]*)(\n|$)') with self.set_status_for_all_files() as s: p = self._cleartool(['ls', '-short', '.']) while True: line = yield p.wait_line() if line is None: break GPS.Logger("CLEARCASE").log(line) m = _re.search(line) if m: # ??? These are just (bad) guesses for now status = GPS.VCS2.Status.UNMODIFIED rev = m.group('rev') if rev.contains('CHECKEDOUT'): status = GPS.VCS2.Status.MODIFIED elif m.group('sep') == '': status = GPS.VCS2.Status.UNTRACKED elif rev == '': status = GPS.VCS2.Status.IGNORED s.set_status( GPS.File(m.group('file')), 0, rev, '') # repo revision