mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-08-20 02:15:59 +07:00
247 lines
9.1 KiB
Kotlin
247 lines
9.1 KiB
Kotlin
/*
|
|
* Copyright 2000-2017 JetBrains s.r.o.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package com.intellij.execution.impl
|
|
|
|
import com.intellij.execution.application.ApplicationConfigurationType
|
|
import com.intellij.execution.impl.RunConfigurable.NodeKind.*
|
|
import com.intellij.execution.junit.JUnitConfigurationType
|
|
import com.intellij.openapi.util.Disposer
|
|
import com.intellij.openapi.util.Trinity
|
|
import com.intellij.testFramework.EdtRule
|
|
import com.intellij.testFramework.ProjectRule
|
|
import com.intellij.testFramework.RunsInEdt
|
|
import com.intellij.testFramework.assertions.Assertions.assertThat
|
|
import com.intellij.ui.RowsDnDSupport
|
|
import com.intellij.ui.RowsDnDSupport.RefinedDropSupport.Position.*
|
|
import com.intellij.ui.treeStructure.Tree
|
|
import com.intellij.util.loadElement
|
|
import org.jdom.Element
|
|
import org.junit.After
|
|
import org.junit.ClassRule
|
|
import org.junit.Rule
|
|
import org.junit.Test
|
|
import java.util.*
|
|
import javax.swing.tree.DefaultMutableTreeNode
|
|
import javax.swing.tree.TreePath
|
|
|
|
private val ORDER = arrayOf(CONFIGURATION_TYPE, //Application
|
|
FOLDER, //1
|
|
CONFIGURATION, CONFIGURATION, CONFIGURATION, CONFIGURATION, CONFIGURATION, TEMPORARY_CONFIGURATION, TEMPORARY_CONFIGURATION, FOLDER, //2
|
|
TEMPORARY_CONFIGURATION, FOLDER, //3
|
|
CONFIGURATION, TEMPORARY_CONFIGURATION, CONFIGURATION_TYPE, //JUnit
|
|
FOLDER, //4
|
|
CONFIGURATION, CONFIGURATION, FOLDER, //5
|
|
CONFIGURATION, CONFIGURATION, TEMPORARY_CONFIGURATION, UNKNOWN//Defaults
|
|
)
|
|
|
|
@RunsInEdt
|
|
class RunConfigurableTest {
|
|
companion object {
|
|
@JvmField
|
|
@ClassRule
|
|
val projectRule = ProjectRule()
|
|
|
|
private fun createRunManager(element: Element): RunManagerImpl {
|
|
val runManager = RunManagerImpl(projectRule.project)
|
|
runManager.initializeConfigurationTypes(arrayOf(ApplicationConfigurationType.getInstance(), JUnitConfigurationType.getInstance()))
|
|
runManager.loadState(element)
|
|
return runManager
|
|
}
|
|
|
|
private class MockRunConfigurable(private val testManager: RunManagerImpl) : RunConfigurable(projectRule.project) {
|
|
init {
|
|
createComponent()
|
|
}
|
|
|
|
internal override fun getRunManager() = testManager
|
|
}
|
|
}
|
|
|
|
@JvmField
|
|
@Rule
|
|
val edtRule = EdtRule()
|
|
|
|
private val disposable = Disposer.newDisposable()
|
|
|
|
private val configurable: RunConfigurable by lazy {
|
|
val result = MockRunConfigurable(createRunManager(loadElement(RunConfigurableTest::class.java.getResourceAsStream("folders.xml"))))
|
|
Disposer.register(disposable, result)
|
|
result
|
|
}
|
|
|
|
private val root: DefaultMutableTreeNode
|
|
get() = configurable.myRoot
|
|
|
|
private val tree: Tree
|
|
get() = configurable.myTree
|
|
|
|
private val model: RunConfigurable.MyTreeModel
|
|
get() = configurable.myTreeModel
|
|
|
|
@After
|
|
fun tearDown() {
|
|
Disposer.dispose(disposable)
|
|
}
|
|
|
|
@Test
|
|
fun testDND() {
|
|
doExpand()
|
|
val never = intArrayOf(-1, 0, 14, 22, 23, 999)
|
|
for (i in -1..16) {
|
|
for (j in never) {
|
|
if ((j == 14 || j == 21) && i == j) {
|
|
continue
|
|
}
|
|
assertCannot(j, i, ABOVE)
|
|
assertCannot(j, i, INTO)
|
|
assertCannot(j, i, BELOW)
|
|
}
|
|
}
|
|
assertCan(3, 3, BELOW)
|
|
assertCan(3, 3, ABOVE)
|
|
assertCannot(3, 2, BELOW)
|
|
assertCan(3, 2, ABOVE)
|
|
assertCannot(3, 1, BELOW)
|
|
assertCannot(3, 0, BELOW)
|
|
assertCan(2, 14, ABOVE)
|
|
assertCan(1, 14, ABOVE)
|
|
assertCan(1, 11, ABOVE)
|
|
assertCannot(1, 10, ABOVE)
|
|
assertCannot(1, 10, BELOW)
|
|
assertCannot(8, 6, ABOVE)
|
|
assertCan(8, 6, BELOW)
|
|
assertCannot(5, 7, BELOW)
|
|
assertCan(5, 7, ABOVE)
|
|
assertCannot(15, 11, INTO)
|
|
assertCannot(18, 21, ABOVE)
|
|
assertCan(15, 21, ABOVE)
|
|
|
|
assertThat(model.isDropInto(tree, 2, 9)).isTrue()
|
|
assertThat(model.isDropInto(tree, 2, 1)).isTrue()
|
|
assertThat(model.isDropInto(tree, 12, 9)).isTrue()
|
|
assertThat(model.isDropInto(tree, 12, 1)).isTrue()
|
|
assertThat(model.isDropInto(tree, 999, 9)).isFalse()
|
|
assertThat(model.isDropInto(tree, 999, 1)).isFalse()
|
|
assertThat(model.isDropInto(tree, 2, 999)).isFalse()
|
|
assertThat(model.isDropInto(tree, 2, -1)).isFalse()
|
|
}
|
|
|
|
private fun doExpand() {
|
|
val toExpand = ArrayList<DefaultMutableTreeNode>()
|
|
RunConfigurable.collectNodesRecursively(root, toExpand, FOLDER)
|
|
assertThat(toExpand).hasSize(5)
|
|
val toExpand2 = ArrayList<DefaultMutableTreeNode>()
|
|
RunConfigurable.collectNodesRecursively(root, toExpand2, CONFIGURATION_TYPE)
|
|
toExpand.addAll(toExpand2)
|
|
for (node in toExpand) {
|
|
tree.expandPath(TreePath(node.path))
|
|
}
|
|
|
|
assertThat(ORDER.mapIndexed { index, nodeKind -> RunConfigurable.getKind(tree.getPathForRow(index).lastPathComponent as DefaultMutableTreeNode) }).containsExactly(*ORDER)
|
|
}
|
|
|
|
private fun assertCan(oldIndex: Int, newIndex: Int, position: RowsDnDSupport.RefinedDropSupport.Position) {
|
|
assertDrop(oldIndex, newIndex, position, true)
|
|
}
|
|
|
|
private fun assertCannot(oldIndex: Int, newIndex: Int, position: RowsDnDSupport.RefinedDropSupport.Position) {
|
|
assertDrop(oldIndex, newIndex, position, false)
|
|
}
|
|
|
|
private fun assertDrop(oldIndex: Int, newIndex: Int, position: RowsDnDSupport.RefinedDropSupport.Position, canDrop: Boolean) {
|
|
val message = StringBuilder()
|
|
message.append("(").append(oldIndex).append(")").append(tree.getPathForRow(oldIndex)).append("->")
|
|
message.append("(").append(newIndex).append(")").append(tree.getPathForRow(newIndex)).append(position)
|
|
if (canDrop) {
|
|
// message.toString()
|
|
assertThat(model.canDrop(oldIndex, newIndex, position)).isTrue()
|
|
}
|
|
else {
|
|
// message.toString()
|
|
assertThat(model.canDrop(oldIndex, newIndex, position)).isFalse()
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun testMoveUpDown() {
|
|
doExpand()
|
|
checkPositionToMove(0, 1, null)
|
|
checkPositionToMove(2, 1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(2, 3, BELOW))
|
|
checkPositionToMove(2, -1, null)
|
|
checkPositionToMove(14, 1, null)
|
|
checkPositionToMove(14, -1, null)
|
|
checkPositionToMove(15, -1, null)
|
|
checkPositionToMove(16, -1, null)
|
|
checkPositionToMove(3, -1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(3, 2, ABOVE))
|
|
checkPositionToMove(6, 1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(6, 9, BELOW))
|
|
checkPositionToMove(7, 1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(7, 8, BELOW))
|
|
checkPositionToMove(10, -1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(10, 8, BELOW))
|
|
checkPositionToMove(8, 1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(8, 9, BELOW))
|
|
checkPositionToMove(21, -1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(21, 20, BELOW))
|
|
checkPositionToMove(21, 1, null)
|
|
checkPositionToMove(20, 1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(20, 21, ABOVE))
|
|
checkPositionToMove(20, -1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(20, 19, ABOVE))
|
|
checkPositionToMove(19, 1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(19, 20, BELOW))
|
|
checkPositionToMove(19, -1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(19, 17, BELOW))
|
|
checkPositionToMove(17, -1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(17, 16, ABOVE))
|
|
checkPositionToMove(17, 1, Trinity.create<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>(17, 18, BELOW))
|
|
}
|
|
|
|
private fun checkPositionToMove(selectedRow: Int, direction: Int, expected: Trinity<Int, Int, RowsDnDSupport.RefinedDropSupport.Position>?) {
|
|
tree.setSelectionRow(selectedRow)
|
|
assertThat(configurable.getAvailableDropPosition(direction)).isEqualTo(expected)
|
|
}
|
|
|
|
@Test
|
|
fun testSort() {
|
|
doExpand()
|
|
assertThat(configurable.isModified).isFalse()
|
|
model.drop(2, 0, ABOVE)
|
|
assertThat(configurable.isModified).isTrue()
|
|
configurable.apply()
|
|
assertThat(configurable.runManager.allSettings.map { it.name }).isEqualTo(listOf("Renamer",
|
|
"UI",
|
|
"AuTest",
|
|
"Simples",
|
|
"OutAndErr",
|
|
"C148C_TersePrincess",
|
|
"Periods",
|
|
"C148E_Porcelain",
|
|
"ErrAndOut",
|
|
"All in titled",
|
|
"All in titled2",
|
|
"All in titled3",
|
|
"All in titled4",
|
|
"All in titled5"))
|
|
assertThat(configurable.isModified).isFalse()
|
|
model.drop(4, 8, BELOW)
|
|
configurable.apply()
|
|
assertThat(configurable.runManager.allSettings.map { it.name }).isEqualTo(listOf("Renamer",
|
|
"AuTest",
|
|
"Simples",
|
|
"UI",
|
|
"OutAndErr",
|
|
"C148C_TersePrincess",
|
|
"Periods",
|
|
"C148E_Porcelain",
|
|
"ErrAndOut",
|
|
"All in titled",
|
|
"All in titled2",
|
|
"All in titled3",
|
|
"All in titled4",
|
|
"All in titled5"))
|
|
}
|
|
} |