From 134c68c705ccf00eca2d8ac2b8d8afafa7d64fb5 Mon Sep 17 00:00:00 2001 From: Alex Plate Date: Fri, 10 Dec 2021 11:18:19 +0300 Subject: [PATCH] Support new marks --- .teamcity/_Self/Constants.kt | 4 +- build.gradle.kts | 16 +-- gradle.properties | 2 +- .../com/maddyhome/idea/vim/common/Marks.kt | 19 ++-- .../maddyhome/idea/vim/group/MarkGroup.java | 102 +++++++----------- .../maddyhome/idea/vim/group/SystemMarks.kt | 90 ++++++++++++++++ .../META-INF/includes/VimListeners.xml | 4 +- src/main/resources/META-INF/plugin.xml | 2 +- .../jetbrains/plugins/ideavim/VimTestCase.kt | 10 +- .../motion/mark/MotionMarkActionTest.kt | 64 ++++------- .../commands/DeleteMarksCommandTest.kt | 14 ++- 11 files changed, 191 insertions(+), 136 deletions(-) create mode 100644 src/main/java/com/maddyhome/idea/vim/group/SystemMarks.kt diff --git a/.teamcity/_Self/Constants.kt b/.teamcity/_Self/Constants.kt index f6cd5bf940..d39897064f 100644 --- a/.teamcity/_Self/Constants.kt +++ b/.teamcity/_Self/Constants.kt @@ -5,7 +5,7 @@ object Constants { const val EAP_CHANNEL = "eap" const val DEV_CHANNEL = "Dev" - const val VERSION = "1.9.0" + const val VERSION = "1.9.1" const val DEV_VERSION = "1.10.0" const val GITHUB_TESTS = "LATEST-EAP-SNAPSHOT" @@ -14,7 +14,7 @@ object Constants { const val PROPERTY_TESTS = "LATEST-EAP-SNAPSHOT" const val LONG_RUNNING_TESTS = "LATEST-EAP-SNAPSHOT" const val QODANA_TESTS = "LATEST-EAP-SNAPSHOT" - const val RELEASE = "2021.2.2" + const val RELEASE = "2021.3" const val RELEASE_DEV = "LATEST-EAP-SNAPSHOT" const val RELEASE_EAP = "LATEST-EAP-SNAPSHOT" } diff --git a/build.gradle.kts b/build.gradle.kts index 9c9a1204ec..1ff69e2016 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -74,14 +74,14 @@ configurations { tasks { // Include tests for testing on LATEST-EAP-SNAPSHOT -// val test by getting(Test::class) { -// isScanForTestClasses = false -// // Only run tests from classes that end with "Test" -// include("**/*Test.class") -// include("**/*Tests.class") -// exclude("**/ParserTest.class") -// } -// + val test by getting(Test::class) { + isScanForTestClasses = false + // Only run tests from classes that end with "Test" + include("**/*Test.class") + include("**/*Tests.class") + exclude("**/ParserTest.class") + } + compileJava { sourceCompatibility = javaVersion targetCompatibility = javaVersion diff --git a/gradle.properties b/gradle.properties index c1acdc75ea..7df178b742 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,6 +1,6 @@ # suppress inspection "UnusedProperty" for whole file -ideaVersion=2021.2.2 +ideaVersion=LATEST-EAP-SNAPSHOT downloadIdeaSources=true instrumentPluginCode=true version=SNAPSHOT diff --git a/src/main/java/com/maddyhome/idea/vim/common/Marks.kt b/src/main/java/com/maddyhome/idea/vim/common/Marks.kt index 54cee0f728..c925ac7f52 100644 --- a/src/main/java/com/maddyhome/idea/vim/common/Marks.kt +++ b/src/main/java/com/maddyhome/idea/vim/common/Marks.kt @@ -18,8 +18,9 @@ package com.maddyhome.idea.vim.common -import com.intellij.ide.bookmarks.Bookmark -import com.intellij.ide.bookmarks.BookmarkManager +import com.intellij.ide.bookmark.BookmarkType +import com.intellij.ide.bookmark.BookmarksManager +import com.intellij.ide.bookmark.LineBookmark import com.intellij.openapi.editor.Editor import com.intellij.openapi.editor.LogicalPosition import com.intellij.openapi.project.Project @@ -79,11 +80,11 @@ data class VimMark( } } -class IntellijMark(bookmark: Bookmark, override val col: Int, project: Project?) : Mark { +class IntellijMark(bookmark: LineBookmark, override val col: Int, project: Project?) : Mark { private val project: WeakReference = WeakReference(project) - override val key = bookmark.mnemonic + override val key = BookmarksManager.getInstance(project)?.getType(bookmark)?.mnemonic!! override val logicalLine: Int get() = getMark()?.line ?: 0 override val filename: String @@ -91,14 +92,16 @@ class IntellijMark(bookmark: Bookmark, override val col: Int, project: Project?) override val protocol: String get() = getMark()?.file?.let { MarkGroup.extractProtocol(it) } ?: "" - override fun isClear(): Boolean = getMark()?.isValid?.not() ?: false + override fun isClear(): Boolean = getMark() == null override fun clear() { val mark = getMark() ?: return - getProject()?.let { project -> BookmarkManager.getInstance(project).removeBookmark(mark) } + getProject()?.let { project -> BookmarksManager.getInstance(project)?.remove(mark) } } - private fun getMark(): Bookmark? = - getProject()?.let { project -> BookmarkManager.getInstance(project).findBookmarkForMnemonic(key) } + private fun getMark(): LineBookmark? = + getProject()?.let { + project -> BookmarksManager.getInstance(project)?.getBookmark(BookmarkType.get(key)) as? LineBookmark + } private fun getProject(): Project? { val proj = project.get() ?: return null diff --git a/src/main/java/com/maddyhome/idea/vim/group/MarkGroup.java b/src/main/java/com/maddyhome/idea/vim/group/MarkGroup.java index f52fdfb26a..59ad22b2d6 100755 --- a/src/main/java/com/maddyhome/idea/vim/group/MarkGroup.java +++ b/src/main/java/com/maddyhome/idea/vim/group/MarkGroup.java @@ -18,9 +18,10 @@ package com.maddyhome.idea.vim.group; -import com.intellij.ide.bookmarks.Bookmark; -import com.intellij.ide.bookmarks.BookmarkManager; -import com.intellij.ide.bookmarks.BookmarksListener; +import com.intellij.ide.bookmark.BookmarkGroup; +import com.intellij.ide.bookmark.BookmarkType; +import com.intellij.ide.bookmark.BookmarksManager; +import com.intellij.ide.bookmark.LineBookmark; import com.intellij.openapi.components.PersistentStateComponent; import com.intellij.openapi.components.RoamingType; import com.intellij.openapi.components.State; @@ -47,7 +48,6 @@ import com.maddyhome.idea.vim.helper.SearchHelper; import com.maddyhome.idea.vim.vimscript.services.OptionService; import org.jdom.Element; -import org.jetbrains.annotations.Contract; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -221,7 +221,7 @@ else if (GLOBAL_MARKS.indexOf(ch) >= 0) { HashMap fmarks = getFileMarks(editor.getDocument()); if (fmarks == null) return false; - Bookmark systemMark = createOrGetSystemMark(ch, lp.line, editor); + @Nullable LineBookmark systemMark = SystemMarks.createOrGetSystemMark(ch, lp.line, editor); Mark mark; if (systemMark != null) { mark = new IntellijMark(systemMark, lp.column, editor.getProject()); @@ -238,22 +238,6 @@ else if (GLOBAL_MARKS.indexOf(ch) >= 0) { return true; } - private @Nullable Bookmark createOrGetSystemMark(char ch, int line, @NotNull Editor editor) { - if (!VimPlugin.getOptionService().isSet(new OptionService.Scope.LOCAL(editor), "ideamarks", "ideamarks")) return null; - final Project project = editor.getProject(); - if (project == null) return null; - final BookmarkManager bookmarkManager = BookmarkManager.getInstance(project); - - Bookmark bookmark = bookmarkManager.findBookmarkForMnemonic(ch); - if (bookmark != null && bookmark.getLine() == line) return bookmark; - - final VirtualFile virtualFile = EditorHelper.getVirtualFile(editor); - if (virtualFile == null) return null; - bookmark = bookmarkManager.addTextBookmark(virtualFile, line, ""); - bookmarkManager.setMnemonic(bookmark, ch); - return bookmark; - } - public static String extractProtocol(@NotNull VirtualFile vf) { return VirtualFileManager.extractProtocol(vf.getUrl()); } @@ -746,68 +730,56 @@ public void documentChanged(@NotNull DocumentEvent event) { } } - public static class MarkListener implements BookmarksListener { - - private final Project project; - private Bookmark bookmarkTemplate = null; + public static class VimBookmarksListener implements com.intellij.ide.bookmark.BookmarksListener { + private final Project myProject; - @Contract(pure = true) - public MarkListener(Project project) { - this.project = project; + public VimBookmarksListener(Project project) { + myProject = project; } - /** - * IJ has an interesting approach in mnemonic marks initialization. Firstly it creates an unnamed mark, - * then updates it. In general, it creates two events: one for creation and one for mnemonic set. - * However, when IJ starts and reads existing marks from caches, it creates marks with mnemonics already. - */ @Override - public void bookmarkAdded(@NotNull Bookmark b) { + public void bookmarkAdded(@NotNull BookmarkGroup group, com.intellij.ide.bookmark.@NotNull Bookmark bookmark) { if (!VimPlugin.isEnabled()) return; if (!VimPlugin.getOptionService().isSet(OptionService.Scope.GLOBAL.INSTANCE, "ideamarks", "ideamarks")) return; - if (b.getMnemonic() == '\u0000') { - bookmarkTemplate = b; - } else { - createVimMark(b); - } + + if (!(bookmark instanceof LineBookmark)) return; + BookmarksManager bookmarksManager = BookmarksManager.getInstance(myProject); + if (bookmarksManager == null) return; + BookmarkType type = bookmarksManager.getType(bookmark); + if (type == null) return; + + char mnemonic = type.getMnemonic(); + if (GLOBAL_MARKS.indexOf(mnemonic) == -1) return; + + createVimMark((LineBookmark)bookmark, mnemonic); } @Override - public void bookmarkRemoved(@NotNull Bookmark b) { + public void bookmarkRemoved(@NotNull BookmarkGroup group, com.intellij.ide.bookmark.@NotNull Bookmark bookmark) { if (!VimPlugin.isEnabled()) return; if (!VimPlugin.getOptionService().isSet(OptionService.Scope.GLOBAL.INSTANCE, "ideamarks", "ideamarks")) return; - char ch = b.getMnemonic(); + if (!(bookmark instanceof LineBookmark)) return; + BookmarksManager bookmarksManager = BookmarksManager.getInstance(myProject); + if (bookmarksManager == null) return; + BookmarkType type = bookmarksManager.getType(bookmark); + if (type == null) return; + char ch = type.getMnemonic(); if (GLOBAL_MARKS.indexOf(ch) != -1) { - FileMarks fmarks = VimPlugin.getMark().getFileMarks(b.getFile().getPath()); + FileMarks fmarks = VimPlugin.getMark().getFileMarks(((LineBookmark)bookmark).getFile().getPath()); fmarks.remove(ch); VimPlugin.getMark().globalMarks.remove(ch); - // No need to call mark.clear() } } - @Override - public void bookmarkChanged(@NotNull Bookmark b) { - if (!VimPlugin.isEnabled()) return; - /* IJ sets named marks in two steps. Firstly it creates an unnamed mark, then adds a mnemonic */ - if (!VimPlugin.getOptionService().isSet(OptionService.Scope.GLOBAL.INSTANCE, "ideamarks", "ideamarks")) return; - if (b != bookmarkTemplate) return; - bookmarkTemplate = null; - - createVimMark(b); - } - - private void createVimMark(@NotNull Bookmark b) { - char ch = b.getMnemonic(); - if (GLOBAL_MARKS.indexOf(ch) != -1) { - int col = 0; - Editor editor = EditorHelper.getEditor(b.getFile()); - if (editor != null) col = editor.getCaretModel().getCurrentCaret().getLogicalPosition().column; - IntellijMark mark = new IntellijMark(b, col, project); - FileMarks fmarks = VimPlugin.getMark().getFileMarks(b.getFile().getPath()); - fmarks.put(ch, mark); - VimPlugin.getMark().globalMarks.put(ch, mark); - } + private void createVimMark(@NotNull LineBookmark b, char mnemonic) { + int col = 0; + Editor editor = EditorHelper.getEditor(b.getFile()); + if (editor != null) col = editor.getCaretModel().getCurrentCaret().getLogicalPosition().column; + IntellijMark mark = new IntellijMark(b, col, myProject); + FileMarks fmarks = VimPlugin.getMark().getFileMarks(b.getFile().getPath()); + fmarks.put(mnemonic, mark); + VimPlugin.getMark().globalMarks.put(mnemonic, mark); } } diff --git a/src/main/java/com/maddyhome/idea/vim/group/SystemMarks.kt b/src/main/java/com/maddyhome/idea/vim/group/SystemMarks.kt new file mode 100644 index 0000000000..feaf85ba56 --- /dev/null +++ b/src/main/java/com/maddyhome/idea/vim/group/SystemMarks.kt @@ -0,0 +1,90 @@ +/* + * IdeaVim - Vim emulator for IDEs based on the IntelliJ platform + * Copyright (C) 2003-2021 The IdeaVim authors + * + * 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 2 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 . + */ + +/* + * IdeaVim - Vim emulator for IDEs based on the IntelliJ platform + * Copyright (C) 2003-2021 The IdeaVim authors + * + * 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 2 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 . + */ + +package com.maddyhome.idea.vim.group + +import com.intellij.ide.bookmark.Bookmark +import com.intellij.ide.bookmark.BookmarkType +import com.intellij.ide.bookmark.BookmarksManager +import com.intellij.ide.bookmark.LineBookmark +import com.intellij.ide.bookmark.providers.LineBookmarkProvider +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.project.Project +import com.maddyhome.idea.vim.VimPlugin +import com.maddyhome.idea.vim.vimscript.services.OptionService.Scope.LOCAL + +class SystemMarks { + companion object { + @JvmStatic + fun createOrGetSystemMark(ch: Char, line: Int, editor: Editor): LineBookmark? { + if (!VimPlugin.getOptionService().isSet(LOCAL(editor), "ideamarks", "ideamarks")) return null + + val project = editor.project ?: return null + val type = BookmarkType.get(ch) + if (type == BookmarkType.DEFAULT) return null + + val bookmarksManager = BookmarksManager.getInstance(project) ?: return null + val foundBookmark = bookmarksManager.getBookmark(type) + if (foundBookmark != null) { + if (foundBookmark is LineBookmark && foundBookmark.line == line) { + return foundBookmark + } + bookmarksManager.remove(foundBookmark) + } + + return project.createLineBookmark(editor, line, ch) + } + } +} + +internal fun Project.createLineBookmark(editor: Editor, line: Int, mnemonic: Char): LineBookmark? { + val bookmarksManager = BookmarksManager.getInstance(this) ?: return null + val lineBookmarkProvider = LineBookmarkProvider.find(this) ?: return null + val bookmark = lineBookmarkProvider.createBookmark(editor, line) as LineBookmark? ?: return null + val type = BookmarkType.get(mnemonic) + if (type == BookmarkType.DEFAULT) return null + + val group = bookmarksManager.defaultGroup ?: bookmarksManager.addGroup("IdeaVim", true) ?: return null + if (group.canAdd(bookmark)) { + group.add(bookmark, type) + return bookmark + } + return null +} + +internal fun Bookmark.mnemonic(project: Project?): Char { + return BookmarksManager.getInstance(project)?.getType(this)!!.mnemonic +} \ No newline at end of file diff --git a/src/main/resources/META-INF/includes/VimListeners.xml b/src/main/resources/META-INF/includes/VimListeners.xml index 287cf50d0d..915bbd38cf 100644 --- a/src/main/resources/META-INF/includes/VimListeners.xml +++ b/src/main/resources/META-INF/includes/VimListeners.xml @@ -18,8 +18,8 @@ - + diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml index 952dd178c7..e547110664 100644 --- a/src/main/resources/META-INF/plugin.xml +++ b/src/main/resources/META-INF/plugin.xml @@ -76,7 +76,7 @@ - + com.intellij.modules.platform diff --git a/src/test/java/org/jetbrains/plugins/ideavim/VimTestCase.kt b/src/test/java/org/jetbrains/plugins/ideavim/VimTestCase.kt index 20fda64969..6726c1616a 100644 --- a/src/test/java/org/jetbrains/plugins/ideavim/VimTestCase.kt +++ b/src/test/java/org/jetbrains/plugins/ideavim/VimTestCase.kt @@ -17,8 +17,7 @@ */ package org.jetbrains.plugins.ideavim -import com.intellij.ide.bookmarks.Bookmark -import com.intellij.ide.bookmarks.BookmarkManager +import com.intellij.ide.bookmark.BookmarksManager import com.intellij.ide.highlighter.JavaFileType import com.intellij.ide.highlighter.XmlFileType import com.intellij.json.JsonFileType @@ -78,7 +77,6 @@ import com.maddyhome.idea.vim.vimscript.services.OptionService import com.maddyhome.idea.vim.vimscript.services.VariableServiceImpl import org.assertj.core.api.Assertions import org.junit.Assert -import java.util.function.Consumer import javax.swing.KeyStroke /** @@ -129,8 +127,10 @@ abstract class VimTestCase : UsefulTestCase() { override fun tearDown() { val swingTimer = swingTimer swingTimer?.stop() - val bookmarkManager = BookmarkManager.getInstance(myFixture.project) - bookmarkManager.validBookmarks.forEach(Consumer { bookmark: Bookmark? -> bookmarkManager.removeBookmark(bookmark!!) }) + val bookmarksManager = BookmarksManager.getInstance(myFixture.project) + bookmarksManager?.bookmarks?.forEach { bookmark -> + bookmarksManager.remove(bookmark) + } SelectionVimListenerSuppressor.lock().use { myFixture.tearDown() } ExEntryPanel.getInstance().deactivate(false) (VimPlugin.getVariableService() as VariableServiceImpl).clear() diff --git a/src/test/java/org/jetbrains/plugins/ideavim/action/motion/mark/MotionMarkActionTest.kt b/src/test/java/org/jetbrains/plugins/ideavim/action/motion/mark/MotionMarkActionTest.kt index ccd600d77c..71e802e9f5 100644 --- a/src/test/java/org/jetbrains/plugins/ideavim/action/motion/mark/MotionMarkActionTest.kt +++ b/src/test/java/org/jetbrains/plugins/ideavim/action/motion/mark/MotionMarkActionTest.kt @@ -18,8 +18,12 @@ package org.jetbrains.plugins.ideavim.action.motion.mark -import com.intellij.ide.bookmarks.BookmarkManager +import com.intellij.ide.bookmark.BookmarksManager +import com.intellij.ide.bookmark.LineBookmark +import com.intellij.testFramework.PlatformTestUtil import com.maddyhome.idea.vim.VimPlugin +import com.maddyhome.idea.vim.group.createLineBookmark +import com.maddyhome.idea.vim.group.mnemonic import com.maddyhome.idea.vim.helper.StringHelper import com.maddyhome.idea.vim.option.IdeaMarksOptionsData import junit.framework.TestCase @@ -27,7 +31,6 @@ import org.jetbrains.plugins.ideavim.OptionValueType import org.jetbrains.plugins.ideavim.VimOptionTestCase import org.jetbrains.plugins.ideavim.VimOptionTestConfiguration import org.jetbrains.plugins.ideavim.VimTestOption -import org.junit.Ignore class MotionMarkActionTest : VimOptionTestCase(IdeaMarksOptionsData.name) { @VimOptionTestConfiguration(VimTestOption(IdeaMarksOptionsData.name, OptionValueType.NUMBER, "1")) @@ -75,7 +78,10 @@ class MotionMarkActionTest : VimOptionTestCase(IdeaMarksOptionsData.name) { """.trimIndent() configureByText(text) typeText(keys) - checkMarks('A' to 2, 'B' to 2, 'C' to 2) + checkMarks('A' to 2) + + // Previously it was like this, but now it's impossible to set multiple bookmarks on the same line. +// checkMarks('A' to 2, 'B' to 2, 'C' to 2) } @VimOptionTestConfiguration(VimTestOption(IdeaMarksOptionsData.name, OptionValueType.NUMBER, "1")) @@ -105,18 +111,15 @@ class MotionMarkActionTest : VimOptionTestCase(IdeaMarksOptionsData.name) { hard by the torrent of a mountain pass. """.trimIndent() configureByText(text) - val bookmarkManager = BookmarkManager.getInstance(myFixture.project) - bookmarkManager.addEditorBookmark(myFixture.editor, 2) - val bookmark = bookmarkManager.findEditorBookmark(myFixture.editor.document, 2) ?: kotlin.test.fail() - bookmarkManager.setMnemonic(bookmark, 'A') + myFixture.project.createLineBookmark(myFixture.editor, 2, 'A') + PlatformTestUtil.dispatchAllInvocationEventsInIdeEventQueue() val vimMarks = VimPlugin.getMark().getMarks(myFixture.editor) TestCase.assertEquals(1, vimMarks.size) TestCase.assertEquals('A', vimMarks[0].key) } @VimOptionTestConfiguration(VimTestOption(IdeaMarksOptionsData.name, OptionValueType.NUMBER, "1")) - @Ignore("Probably one day it would be possible to test it") - fun `ignoretest apply new state`() { + fun `test system mark move to another line`() { val text = """ A Discovery @@ -126,38 +129,12 @@ class MotionMarkActionTest : VimOptionTestCase(IdeaMarksOptionsData.name) { hard by the torrent of a mountain pass. """.trimIndent() configureByText(text) - val bookmarkManager = BookmarkManager.getInstance(myFixture.project) - bookmarkManager.addEditorBookmark(myFixture.editor, 2) - val bookmark = bookmarkManager.findEditorBookmark(myFixture.editor.document, 2) ?: kotlin.test.fail() - bookmark.mnemonic = 'A' - bookmarkManager.applyNewStateInTestMode(listOf(bookmark)) - - val vimMarks = VimPlugin.getMark().getMarks(myFixture.editor) - TestCase.assertEquals(1, vimMarks.size) - TestCase.assertEquals('A', vimMarks[0].key) - } + val bookmark = myFixture.project.createLineBookmark(myFixture.editor, 2, 'A') - @VimOptionTestConfiguration(VimTestOption(IdeaMarksOptionsData.name, OptionValueType.NUMBER, "1")) - fun `test system mark move to another line`() { - val text = """ - A Discovery - - I ${c}found it in a legendary land - all rocks and lavender and tufted grass, - where it was settled on some sodden sand - hard by the torrent of a mountain pass. - """.trimIndent() - configureByText(text) - var bookmarkManager = BookmarkManager.getInstance(myFixture.project) - bookmarkManager.addEditorBookmark(myFixture.editor, 2) - var bookmark = bookmarkManager.findEditorBookmark(myFixture.editor.document, 2) ?: kotlin.test.fail() - bookmarkManager.setMnemonic(bookmark, 'A') - - bookmarkManager = BookmarkManager.getInstance(myFixture.project) - bookmarkManager.addEditorBookmark(myFixture.editor, 4) - bookmark = bookmarkManager.findEditorBookmark(myFixture.editor.document, 4) ?: kotlin.test.fail() - bookmarkManager.setMnemonic(bookmark, 'A') + BookmarksManager.getInstance(myFixture.project)?.remove(bookmark!!) + myFixture.project.createLineBookmark(myFixture.editor, 4, 'A') + PlatformTestUtil.dispatchAllInvocationEventsInIdeEventQueue() val vimMarks = VimPlugin.getMark().getMarks(myFixture.editor) TestCase.assertEquals(1, vimMarks.size) TestCase.assertEquals('A', vimMarks[0].key) @@ -165,11 +142,12 @@ class MotionMarkActionTest : VimOptionTestCase(IdeaMarksOptionsData.name) { } private fun checkMarks(vararg marks: Pair) { - val validBookmarks = BookmarkManager.getInstance(myFixture.project).validBookmarks + val project = myFixture.project + val validBookmarks = BookmarksManager.getInstance(project)!!.bookmarks.sortedBy { it.mnemonic(project) } assertEquals(marks.size, validBookmarks.size) - marks.forEachIndexed { index, (mn, line) -> - assertEquals(mn, validBookmarks[marks.size - index - 1].mnemonic) - assertEquals(line, validBookmarks[marks.size - index - 1].line) + marks.sortedBy { it.first }.forEachIndexed { index, (mn, line) -> + assertEquals(mn, validBookmarks[index].mnemonic(project)) + assertEquals(line, (validBookmarks[index] as LineBookmark).line) } } } diff --git a/src/test/java/org/jetbrains/plugins/ideavim/ex/implementation/commands/DeleteMarksCommandTest.kt b/src/test/java/org/jetbrains/plugins/ideavim/ex/implementation/commands/DeleteMarksCommandTest.kt index baf38248a3..3e66fff4b5 100644 --- a/src/test/java/org/jetbrains/plugins/ideavim/ex/implementation/commands/DeleteMarksCommandTest.kt +++ b/src/test/java/org/jetbrains/plugins/ideavim/ex/implementation/commands/DeleteMarksCommandTest.kt @@ -18,6 +18,7 @@ package org.jetbrains.plugins.ideavim.ex.implementation.commands +import com.intellij.openapi.editor.LogicalPosition import com.maddyhome.idea.vim.VimPlugin import com.maddyhome.idea.vim.common.Mark import org.jetbrains.plugins.ideavim.VimTestCase @@ -34,11 +35,22 @@ class DeleteMarksCommandTest : VimTestCase() { all rocks and lavender and tufted grass, where it was settled on some sodden sand hard by the torrent of a mountain pass. + + The features it combines mark it as new + to science: shape and shade -- the special tinge, + akin to moonlight, tempering its blue, + the dingy underside, the checquered fringe. + + My needles have teased out its sculpted sex; + corroded tissues could no longer hide + that priceless mote now dimpling the convex + and limpid teardrop on a lighted slide. """.trimMargin() ) marks.forEachIndexed { index, c -> - VimPlugin.getMark().setMark(myFixture.editor, c, index * 10) + VimPlugin.getMark() + .setMark(myFixture.editor, c, myFixture.editor.logicalPositionToOffset(LogicalPosition(index, 0))) } }