From d11add3c55b67a6ca542a872f703cd8c129460a1 Mon Sep 17 00:00:00 2001 From: spo Date: Wed, 2 Dec 2015 15:47:14 +0300 Subject: [PATCH] Fix suite_FEATURE_CONSTRUCTION/tst_construction_001 --- test.squish/shared/scripts/common.py | 278 +++++++++--------- .../tst_construction_001/test.py | 67 +++-- .../verificationPoints/AXIS | 12 + .../verificationPoints/INIT | 6 + .../verificationPoints/PLANE | 11 + .../verificationPoints/POINTS | 12 + .../verificationPoints/VP1 | 1 - .../verificationPoints/VP2 | 11 - test_squish.sh | 12 +- 9 files changed, 227 insertions(+), 183 deletions(-) create mode 100644 test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/AXIS create mode 100644 test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/INIT create mode 100644 test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/PLANE create mode 100644 test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/POINTS delete mode 100644 test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/VP1 delete mode 100644 test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/VP2 diff --git a/test.squish/shared/scripts/common.py b/test.squish/shared/scripts/common.py index 48a2469f0..2c06c5eed 100644 --- a/test.squish/shared/scripts/common.py +++ b/test.squish/shared/scripts/common.py @@ -2,19 +2,19 @@ import os testSettings.logScreenshotOnError = True testSettings.logScreenshotOnFail = True -#RESULTS_PATH = "/dn48/newgeom/eso/sources/test.squish/shared/testresults/" +# RESULTS_PATH = "/dn48/newgeom/eso/sources/test.squish/shared/testresults/" DATA_PATH = os.getenv('TEST_DATA_DIR') -g_points = {"XY_plane": (332, 250), "XZ_plane": (355, 207)} # one of the construction planes +g_points = {"XY_plane": (332, 250), "XZ_plane": (355, 207)} # one of the construction planes def help_points(name): - return g_points[name] + return g_points[name] #--------------------------------------------------------------------------------------------- # Tools def findMenuItem(menuObject, item): for child in object.children(menuObject): if child.text == item: - return child + return child return None #--------------------------------------------------------------------------------------------- @@ -28,11 +28,11 @@ def getSpinBoxRealName(name): #--------------------------------------------------------------------------------------------- def set_defaults(): waitForObject(":SALOME*_STD_TabDesktop").resize(1024, 768) - + def activate_newgeom(): clickButton(waitForObject(":SALOME*.NewGeom_QToolButton")) clickButton(waitForObject(":Activate module.New_QPushButton")) - + def close_application(): sendEvent("QCloseEvent", waitForObject(":SALOME*_STD_TabDesktop")) clickButton(waitForObject(":Exit.Ok_QPushButton")) @@ -43,35 +43,35 @@ def close_application_wo_saving(): sendEvent("QCloseEvent", waitForObject(":SALOME*_STD_TabDesktop")) clickButton(waitForObject(":Exit.Ok_QPushButton")) clickButton(waitForObject(":Close active study.Close w/o saving_QPushButton")) - + def part_create(): activateItem(waitForObjectItem(":SALOME*_QMenuBar", "Part")) activateItem(waitForObjectItem(":Part_QMenu", "New part")) - + def sketch_create(point, actions): clickButton(waitForObject(":SALOME*.Sketch_QToolButton")) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) activateItem(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) - + actions() - + clickButton(waitForObject(":Sketch.property_panel_ok_QToolButton")) - + def point_create_in_view(point, aux=0): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Point")) - - if aux==1: + + if aux == 1: clickButton(waitForObject(":Point.Auxiliary_QCheckBox")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) clickButton(waitForObject(":Point.property_panel_cancel_QToolButton")) - + def point_create(point, aux=0): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) - mouseClick(waitForObjectItem(":Sketch_QMenu", "Point")) - - if aux==1: + mouseClick(waitForObjectItem(":Sketch_QMenu", "Point")) + + if aux == 1: clickButton(waitForObject(":Point.Auxiliary_QCheckBox")) type(waitForObject(":Point.X _ModuleBase_ParamSpinBox"), "") @@ -81,82 +81,82 @@ def point_create(point, aux=0): type(waitForObject(":Point.Y _ModuleBase_ParamSpinBox"), point[1]) clickButton(waitForObject(":Point.property_panel_ok_QToolButton")) - + def line_create_in_view(start_point, end_point, aux=0): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Line")) - - if aux==1: + + if aux == 1: clickButton(waitForObject(":Line.Auxiliary_QCheckBox")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), start_point[0], start_point[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), end_point[0], end_point[1], 0, Qt.LeftButton) - + clickButton(waitForObject(":Line.property_panel_cancel_QToolButton")) def closing_line_create_in_view(start_point, end_point, aux=0): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Line")) - - if aux==1: + + if aux == 1: clickButton(waitForObject(":Line.Auxiliary_QCheckBox")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), start_point[0], start_point[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), end_point[0], end_point[1], 0, Qt.LeftButton) - + def lines_create_in_view(points, aux=0): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Line")) - - if aux==1: + + if aux == 1: clickButton(waitForObject(":Line.Auxiliary_QCheckBox")) - + for point in points: mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) def lines_close(): - clickButton(waitForObject(":Line.property_panel_cancel_QToolButton")) - -def line_create(start_point, end_point, aux=0): #Set aux=1 to create auxiliary line + clickButton(waitForObject(":Line.property_panel_cancel_QToolButton")) + +def line_create(start_point, end_point, aux=0): # Set aux=1 to create auxiliary line mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Line")) - - if aux==1: - clickButton(waitForObject(":Line.Auxiliary_QCheckBox")) - + + if aux == 1: + clickButton(waitForObject(":Line.Auxiliary_QCheckBox")) + type(waitForObject(":Start point.X _ModuleBase_ParamSpinBox"), "") type(waitForObject(":Start point.X _ModuleBase_ParamSpinBox"), start_point[0]) - + type(waitForObject(":Start point.Y _ModuleBase_ParamSpinBox"), "") - type(waitForObject(":Start point.Y _ModuleBase_ParamSpinBox"), start_point[1]) - + type(waitForObject(":Start point.Y _ModuleBase_ParamSpinBox"), start_point[1]) + type(waitForObject(":End point.X _ModuleBase_ParamSpinBox"), "") type(waitForObject(":End point.X _ModuleBase_ParamSpinBox"), end_point[0]) - + type(waitForObject(":End point.Y _ModuleBase_ParamSpinBox"), "") type(waitForObject(":End point.Y _ModuleBase_ParamSpinBox"), end_point[1]) clickButton(waitForObject(":Line.property_panel_ok_QToolButton")) - + def circle_create_in_view(center, radius, aux=0): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Circle")) - - if aux==1: + + if aux == 1: clickButton(waitForObject(":Circle.Auxiliary_QCheckBox")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), center[0], center[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), radius[0], radius[1], 0, Qt.LeftButton) clickButton(waitForObject(":Circle.property_panel_cancel_QToolButton")) - + def circle_create(center, radius, aux=0): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Circle")) - - if aux==1: + + if aux == 1: clickButton(waitForObject(":Circle.Auxiliary_QCheckBox")) - + type(waitForObject(":Center.X _ModuleBase_ParamSpinBox"), "") type(waitForObject(":Center.X _ModuleBase_ParamSpinBox"), center[0]) @@ -167,68 +167,68 @@ def circle_create(center, radius, aux=0): type(waitForObject(":Circle.CircleRadius_ModuleBase_ParamSpinBox"), radius) clickButton(waitForObject(":Circle.property_panel_ok_QToolButton")) - + def arc_create(center, start_point, end_point, aux=0): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Arc")) - - if aux==1: + + if aux == 1: clickButton(waitForObject(":Arc.Auxiliary_QCheckBox")) type(waitForObject(":Center.X _ModuleBase_ParamSpinBox_2"), "") type(waitForObject(":Center.X _ModuleBase_ParamSpinBox_2"), center[0]) - + type(waitForObject(":Center.Y _ModuleBase_ParamSpinBox_2"), "") type(waitForObject(":Center.Y _ModuleBase_ParamSpinBox_2"), center[1]) - + type(waitForObject(":Start point.X _ModuleBase_ParamSpinBox_2"), "") type(waitForObject(":Start point.X _ModuleBase_ParamSpinBox_2"), start_point[0]) - + type(waitForObject(":Start point.Y _ModuleBase_ParamSpinBox_2"), "") type(waitForObject(":Start point.Y _ModuleBase_ParamSpinBox_2"), start_point[1]) type(waitForObject(":End point.X _ModuleBase_ParamSpinBox_2"), "") type(waitForObject(":End point.X _ModuleBase_ParamSpinBox_2"), end_point[0]) - + type(waitForObject(":End point.Y _ModuleBase_ParamSpinBox_2"), "") type(waitForObject(":End point.Y _ModuleBase_ParamSpinBox_2"), end_point[1]) - - clickButton(waitForObject(":Arc.property_panel_ok_QToolButton")) - + + clickButton(waitForObject(":Arc.property_panel_ok_QToolButton")) + def arc_create_in_view(center, start_point, end_point, aux=0): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Arc")) - - if aux==1: + + if aux == 1: clickButton(waitForObject(":Arc.Auxiliary_QCheckBox")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), center[0], center[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), start_point[0], start_point[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), end_point[0], end_point[1], 0, Qt.LeftButton) - + clickButton(waitForObject(":Arc.property_panel_cancel_QToolButton")) - + def save(filename): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "File")) mouseClick(waitForObjectItem(":_QMenu", "Save As...")) - + type(waitForObject(":fileNameEdit_QLineEdit"), filename) clickButton(waitForObject(":Save File.Save_QPushButton")) - + def extrusion(point, to_size, from_size): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Features")) mouseClick(waitForObjectItem(":_QMenu", "Extrusion")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) - + type(waitForObject(":Extrusion.to_size_ModuleBase_ParamSpinBox"), "") type(waitForObject(":Extrusion.to_size_ModuleBase_ParamSpinBox"), to_size) - + type(waitForObject(":Extrusion.from_size_ModuleBase_ParamSpinBox"), "") type(waitForObject(":Extrusion.from_size_ModuleBase_ParamSpinBox"), from_size) - + clickButton(waitForObject(":Extrusion.property_panel_ok_QToolButton")) - + def open(filename): clickButton(waitForObject(":SALOME*.Open_QToolButton")) waitForObject(":fileNameEdit_QLineEdit_2").setText(filename) @@ -239,55 +239,55 @@ def point_fixe(point): mouseClick(waitForObjectItem(":Sketch_QMenu", "Fixed")) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) clickButton(waitForObject(":Fixed.property_panel_cancel_QToolButton")) - - + + def distance(start_point, end_point, annotation_point): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Distance")) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), start_point[0], start_point[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), end_point[0], end_point[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), annotation_point[0], annotation_point[1], 0, Qt.LeftButton) - - #if length!=0: - #type(waitForObject(":_ModuleBase_ParamSpinBox"), "") - #type(waitForObject(":_ModuleBase_ParamSpinBox"), length) - + + # if length!=0: + # type(waitForObject(":_ModuleBase_ParamSpinBox"), "") + # type(waitForObject(":_ModuleBase_ParamSpinBox"), length) + clickButton(waitForObject(":Distance.property_panel_cancel_QToolButton")) - + def change_distance(point, value): doubleClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) type(waitForObject(":Distance.ConstraintValue_ModuleBase_ParamSpinBox"), "") type(waitForObject(":Distance.ConstraintValue_ModuleBase_ParamSpinBox"), value) - clickButton(waitForObject(":Distance.property_panel_ok_QToolButton")) - + clickButton(waitForObject(":Distance.property_panel_ok_QToolButton")) + def parallel(point_1, point_2): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Parallel")) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_1[0], point_1[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0], point_2[1], 0, Qt.LeftButton) clickButton(waitForObject(":Parallel.property_panel_cancel_QToolButton_2")) - + def perpendicular(point_1, point_2): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Perpendicular")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_1[0], point_1[1], 0, Qt.LeftButton) - mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0], point_2[1], 0, Qt.LeftButton) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0], point_2[1], 0, Qt.LeftButton) + clickButton(waitForObject(":Perpendicular.property_panel_cancel_QToolButton")) - + def coincident(point_1, point_2): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Coincident")) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_1[0], point_1[1], 0, Qt.LeftButton) - mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0], point_2[1], 0, Qt.LeftButton) + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0], point_2[1], 0, Qt.LeftButton) clickButton(waitForObject(":Coincident.property_panel_cancel_QToolButton")) - + def equal(point_1, point_2): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Equal")) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_1[0], point_1[1], 0, Qt.LeftButton) - mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0], point_2[1], 0, Qt.LeftButton) + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0], point_2[1], 0, Qt.LeftButton) clickButton(waitForObject(":Equal.property_panel_cancel_QToolButton")) def vertical(point): @@ -295,71 +295,71 @@ def vertical(point): mouseClick(waitForObjectItem(":Sketch_QMenu", "Vertical")) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) clickButton(waitForObject(":Vertical.property_panel_cancel_QToolButton")) - + def horizontal(point): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Horizontal")) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) clickButton(waitForObject(":Horizontal.property_panel_cancel_QToolButton")) - + def fit_all(): clickButton(waitForObject(":SALOME*.Fit All_QToolButton")) def boolean_select_operation_type(type): - real_name = "{container=':property_panel_dock.Operation type_QGroupBox' toolTip='%s' type='QToolButton' unnamed='1' visible='1'}" % type + real_name = "{container=':property_panel_dock.Operation type_QGroupBox' toolTip='%s' type='QToolButton' unnamed='1' visible='1'}" % type clickButton(waitForObject(real_name)) def boolean_cut(main_object, tool_object): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Features")) mouseClick(waitForObjectItem(":_QMenu", "Boolean")) - + boolean_select_operation_type("Cut") - + mouseClick(waitForObject(":Boolean.Main objects_QListWidget"), 89, 62, 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), main_object[0], main_object[1], 0, Qt.LeftButton) - + mouseClick(waitForObject(":Boolean.Tool object_QListWidget"), 98, 87, 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), tool_object[0], tool_object[1], 0, Qt.LeftButton) - + clickButton(waitForObject(":Boolean.property_panel_ok_QToolButton")) - + def boolean_fuse(main_object, tool_object): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Features")) mouseClick(waitForObjectItem(":_QMenu", "Boolean")) - + boolean_select_operation_type("Fuse") - + mouseClick(waitForObject(":Boolean.Main objects_QListWidget"), 89, 62, 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), main_object[0], main_object[1], 0, Qt.LeftButton) - + mouseClick(waitForObject(":Boolean.Tool object_QListWidget"), 98, 87, 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), tool_object[0], tool_object[1], 0, Qt.LeftButton) - + clickButton(waitForObject(":Boolean.property_panel_ok_QToolButton")) - + def boolean_common(main_object, tool_object): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Features")) mouseClick(waitForObjectItem(":_QMenu", "Boolean")) - + boolean_select_operation_type("Common") - + mouseClick(waitForObject(":Boolean.Main objects_QListWidget"), 89, 62, 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), main_object[0], main_object[1], 0, Qt.LeftButton) - + mouseClick(waitForObject(":Boolean.Tool object_QListWidget"), 98, 87, 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), tool_object[0], tool_object[1], 0, Qt.LeftButton) - + clickButton(waitForObject(":Boolean.property_panel_ok_QToolButton")) - + def length(point, annotation_point): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Length")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), annotation_point[0], annotation_point[1], 0, Qt.LeftButton) - + clickButton(waitForObject(":Length.property_panel_cancel_QToolButton")) - + def change_length(point, value): mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) @@ -367,16 +367,16 @@ def change_length(point, value): type(waitForObject(":Length.ConstraintValue_ModuleBase_ParamSpinBox"), value) clickButton(waitForObject(":Length.property_panel_ok_QToolButton")) - + def radius(point, annotation_point): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Radius")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), annotation_point[0], annotation_point[1], 0, Qt.LeftButton) - + clickButton(waitForObject(":Radius.property_panel_cancel_QToolButton")) - + def change_radius(point, value): mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) @@ -384,66 +384,68 @@ def change_radius(point, value): type(waitForObject(":Radius.ConstraintValue_ModuleBase_ParamSpinBox"), value) clickButton(waitForObject(":Radius.property_panel_ok_QToolButton")) - + def tangent(point_1, point_2): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Sketch")) mouseClick(waitForObjectItem(":Sketch_QMenu", "Tangent")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_1[0], point_1[1], 0, Qt.LeftButton) - mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0], point_2[1], 0, Qt.LeftButton) + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0], point_2[1], 0, Qt.LeftButton) clickButton(waitForObject(":Tangent.property_panel_cancel_QToolButton")) - + def partition(main_objects, tool_object): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Features")) mouseClick(waitForObjectItem(":_QMenu", "Partition")) - + for main_object in main_objects: mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), main_object[0], main_object[1], 33554432, Qt.LeftButton) - + mouseClick(waitForObject(":Partition.Tool object_QListWidget"), 116, 69, 0, Qt.LeftButton) mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), tool_object[0], tool_object[1], 0, Qt.LeftButton) clickButton(waitForObject(":Partition.property_panel_ok_QToolButton")) - + def plane(point, distance): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Construction")) mouseClick(waitForObjectItem(":_QMenu", "Plane")) - + mouseClick(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point[0], point[1], 0, Qt.LeftButton) type(waitForObject(":Plane.distance_ModuleBase_ParamSpinBox"), "") type(waitForObject(":Plane.distance_ModuleBase_ParamSpinBox"), 100) + type(waitForObject(":Plane.distance_ModuleBase_ParamSpinBox"), "") clickButton(waitForObject(":Plane.property_panel_ok_QToolButton")) - + def point(x, y, z): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Construction")) mouseClick(waitForObjectItem(":_QMenu", "Point")) - + type(waitForObject(":Point.x_ModuleBase_ParamSpinBox"), "") type(waitForObject(":Point.x_ModuleBase_ParamSpinBox"), x) - + type(waitForObject(":Point.y_ModuleBase_ParamSpinBox"), "") type(waitForObject(":Point.y_ModuleBase_ParamSpinBox"), y) - + type(waitForObject(":Point.z_ModuleBase_ParamSpinBox"), "") type(waitForObject(":Point.z_ModuleBase_ParamSpinBox"), z) - + type(waitForObject(":Point.z_ModuleBase_ParamSpinBox"), "") + clickButton(waitForObject(":Point.property_panel_ok_QToolButton")) - + def axis(point_1, point_2): mouseClick(waitForObjectItem(":SALOME*_QMenuBar", "Construction")) mouseClick(waitForObjectItem(":_QMenu", "Axis")) - - mouseDrag(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_1[0]-40, point_1[1]-40, 80, 80, 1, Qt.LeftButton) - mouseDrag(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0]-40, point_2[1]-40, 80, 80, 1, Qt.LeftButton) - + + mouseDrag(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_1[0] - 40, point_1[1] - 40, 80, 80, 1, Qt.LeftButton) + mouseDrag(waitForObject(":SALOME*.3D View Operations_OCCViewer_ViewPort3d"), point_2[0] - 40, point_2[1] - 40, 80, 80, 1, Qt.LeftButton) + clickButton(waitForObject(":Axis.property_panel_ok_QToolButton")) - - - - - - + + + + + + diff --git a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/test.py b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/test.py index ef471e42f..4f8db40d7 100644 --- a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/test.py +++ b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/test.py @@ -1,47 +1,60 @@ def main(): - #[project] NewGEOM - #[Scenario] Construction_001 - #[Topic] 'Construction of point, axis and plane' functionality - #[Tested functionality] - #[Summary description] - #[Expected results] - #[General comments] - + # [project] NewGEOM + # [Scenario] Construction_001 + # [Topic] 'Construction of point, axis and plane' functionality + # [Tested functionality] + # [Summary description] + # [Expected results] + # [General comments] + source(findFile("scripts", "common.py")) - - #[section] Application start - #[step] Launch SALOME + + # [section] Application start + # [step] Launch SALOME startApplication("salome_run.sh") set_defaults() - - #[step] Open 'for_construction_001.hdf' + + # [step] Open 'for_construction_001.hdf' open(DATA_PATH + "/for_construction_001.hdf") - - #[step] Activate NewGeom + + # [step] Activate NewGeom clickButton(waitForObject(":SALOME*.NewGeom_QToolButton")) - + # [step] Activate Part_1 waitForObjectItem(":Object browser_XGUI_DataTree", "Part\\_1 (Not loaded)") clickItem(":Object browser_XGUI_DataTree", "Part\\_1 (Not loaded)", 71, 10, 0, Qt.LeftButton) openItemContextMenu(waitForObject(":Object browser_XGUI_DataTree"), "Part\\_1 (Not loaded)", 70, 9, 0) activateItem(waitForObjectItem(":_QMenu", "Activate")) - - #[step] Create plane basing on upper face of the box - plane((283, 127), 100) - #[step] Fit all + # [step] Fit all fit_all() + test.vp("INIT") + + # [step] Create plane basing on upper face of the box + plane((340, 120), 100) - #[check] Check that plane has been created - test.vp("VP1") - + # [step] Fit all + fit_all() + + # [check] Check that plane has been created [vp PLANE] + test.vp("PLANE") + + # [step] Create 2 points by property panel point(-50, -50, 125) point(50, 50, 125) - - axis((168, 138), (583, 137)) - test.vp("VP2") - + # [step] Fit all + clickButton(waitForObject(":SALOME*.Fit All_QToolButton")) + + # [check] Check that the points have been created [vp POINTS] + test.vp("POINTS") + + # [step] Create axis between the 2 points + axis((213, 142), (538, 142)) + + # [check] Check that the axis have been created [vp AXIS] + test.vp("AXIS") + # [step] Close application without saving close_application() diff --git a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/AXIS b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/AXIS new file mode 100644 index 000000000..cc5bd0f72 --- /dev/null +++ b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/AXIS @@ -0,0 +1,12 @@ + + + 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 + + + + + + + + diff --git a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/INIT b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/INIT new file mode 100644 index 000000000..ab019c43b --- /dev/null +++ b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/INIT @@ -0,0 +1,6 @@ + + + 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 + + diff --git a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/PLANE b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/PLANE new file mode 100644 index 000000000..463f01203 --- /dev/null +++ b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/PLANE @@ -0,0 +1,11 @@ + + + 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 + + + + + + + diff --git a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/POINTS b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/POINTS new file mode 100644 index 000000000..8e401a884 --- /dev/null +++ b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/POINTS @@ -0,0 +1,12 @@ + + + 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 + + + + + + + + diff --git a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/VP1 b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/VP1 deleted file mode 100644 index e16065555..000000000 --- a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/VP1 +++ /dev/null @@ -1 +0,0 @@ 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 \ No newline at end of file diff --git a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/VP2 b/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/VP2 deleted file mode 100644 index 6a33bb8c8..000000000 --- a/test.squish/suite_FEATURE_CONSTRUCTION/tst_construction_001/verificationPoints/VP2 +++ /dev/null @@ -1,11 +0,0 @@ - - - - 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 - - - - - - - diff --git a/test_squish.sh b/test_squish.sh index d536ede8a..09ca51ec6 100755 --- a/test_squish.sh +++ b/test_squish.sh @@ -75,14 +75,14 @@ TESTCASES="" #squishrunner-run suite_ISSUES_SALOME "${TESTCASES}" TESTCASES="" -#TESTCASES="${TESTCASES} --testcase tst_boolean_001" -#TESTCASES="${TESTCASES} --testcase tst_boolean_002" -#TESTCASES="${TESTCASES} --testcase tst_boolean_003" -#squishrunner-run suite_FEATURE_BOOLEAN "${TESTCASES}" +TESTCASES="${TESTCASES} --testcase tst_boolean_001" +TESTCASES="${TESTCASES} --testcase tst_boolean_002" +TESTCASES="${TESTCASES} --testcase tst_boolean_003" +squishrunner-run suite_FEATURE_BOOLEAN "${TESTCASES}" TESTCASES="" -#TESTCASES="${TESTCASES} --testcase tst_construction_001" -#squishrunner-run suite_FEATURE_CONSTRUCTION "${TESTCASES}" +TESTCASES="${TESTCASES} --testcase tst_construction_001" +squishrunner-run suite_FEATURE_CONSTRUCTION "${TESTCASES}" TESTCASES="" TESTCASES="${TESTCASES} --testcase tst_extrusion_001" -- 2.30.2