diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexAlignSelf.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexAlignSelf.ets new file mode 100644 index 0000000000000000000000000000000000000000..0648f748bc78534a9df01818864e2b74b5613adc --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexAlignSelf.ets @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ +import { MessageManager,Callback } from '../../../../common/MessageManager'; +@Entry +@Component +struct FlexAlignSelf_End { + private content: string = "FlexAlignSelf_End Page"; + + onPageShow() { + console.info('FlexAlignSelf_End page show called'); + } + + onBuildDone() { + console.info('FlexAlignSelf_End page build done called'); + } + + build() { + Column() { + Column() { + Text('FlexTest12').fontSize(9).fontColor(0xCCCCCC).width('90%') + Flex({ + direction: FlexDirection.Row, + alignItems: ItemAlign.End, + wrap: FlexWrap.NoWrap, + }) { + Text('1').width(150).height(50).backgroundColor(0xF5DEB3).alignSelf(ItemAlign.End).key('textAlignSelf01') + Text('2').width(150).height(100).backgroundColor(0xD2B48C).key('textAlignSelf02') + Text('3').width(150).height(150).backgroundColor(0xF5DEB3).key('textAlignSelf03') + } + .key('flexAlignSelf') + .height(200) + .width(500) + .backgroundColor(0xAFEEEE) + }.width('100%').alignItems(HorizontalAlign.Start) + }.width('100%') + } +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexBase.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexBase.ets new file mode 100644 index 0000000000000000000000000000000000000000..c6796da1a5f110283a9d281a44e52be8d6550562 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexBase.ets @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ +import { MessageManager,Callback } from '../../../../common/MessageManager'; +@Entry +@Component +struct FlexBase_End { + @State testHeight: number = 150 + @State testWidth: number = 450 + messageManager:MessageManager = new MessageManager() + private content: string = "FlexBase_End Page"; + onPageShow() { + console.info('FlexBase_Center onPageShow'); + globalThis.value = { + name:'messageManager',message:this.messageManager + } + let callback:Callback = (message:any) => { + console.log('message = ' + message.name + "--" + message.value); + if (message.name == 'height') { + this.testHeight = message.value; + } + if (message.name == 'width') { + this.testWidth = message.value; + } + } + this.messageManager.registerCallback(callback); + } + + onBuildDone() { + console.info('FlexBase_End page build done called'); + } + + build() { + Column() { + Column() { + Text('FlexBase_1').fontSize(9).fontColor(0xCCCCCC).width('90%') + Flex({ + direction: FlexDirection.Row, + alignItems: ItemAlign.End, + wrap: FlexWrap.NoWrap, + }) { + Text('1').width(150).height(50).backgroundColor(0xF5DEB3).key('textFlex01') + Text('2').width(150).height(100).backgroundColor(0xD2B48C).key('textFlex02') + Text('3').width(150).height(150).backgroundColor(0xF5DEB3).key('textFlex03') + } + .key('flex01') + .height(this.testHeight) + .width(this.testWidth) + .backgroundColor(0xAFEEEE) + }.width('100%').alignItems(HorizontalAlign.Start) + }.width('100%') + } +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexExceed.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexExceed.ets new file mode 100644 index 0000000000000000000000000000000000000000..20efc0114e09391b994502bd762aaf1d2f8d9206 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexExceed.ets @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ +import { MessageManager,Callback } from '../../../../common/MessageManager'; +@Entry +@Component +struct FlexExceed_End { + @State testPadding: number = 0 + @State testMargin: number = 0 + messageManager:MessageManager = new MessageManager() + private content: string = "FlexExceed_End Page"; + onPageShow() { + console.info('FlexBase_Center onPageShow'); + globalThis.value = { + name:'messageManager',message:this.messageManager + } + let callback:Callback = (message:any) => { + console.log('message = ' + message.name + "--" + message.value); + if (message.name == 'padding') { + this.testPadding = message.value; + } + if (message.name == 'margin') { + this.testMargin = message.value; + } + } + this.messageManager.registerCallback(callback); + } + + onBuildDone() { + console.info('FlexExceed_End page build done called'); + } + + build() { + Column() { + Column() { + Text('FlexExceed_1').fontSize(9).fontColor(0xCCCCCC).width('90%') + Flex({ + direction: FlexDirection.Row, + alignItems: ItemAlign.End, + wrap: FlexWrap.NoWrap, + }) { + Text('1').width(150).height(50).backgroundColor(0xF5DEB3).key('textExceed01') + Text('2').width(150).height(100).backgroundColor(0xD2B48C).key('textExceed02') + Text('3').width(150).height(150).backgroundColor(0xF5DEB3).key('textExceed03') + } + .key('flexExceed01') + .height(200) + .width(500) + .margin(this.testMargin) + .padding(this.testPadding) + .backgroundColor(0xAFEEEE) + }.width('100%').alignItems(HorizontalAlign.Start) + }.width('100%') + } +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexHeightModify.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexHeightModify.ets new file mode 100644 index 0000000000000000000000000000000000000000..5d531f2c23c13fc12581e12611147eafa444ea00 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexHeightModify.ets @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ +import { MessageManager,Callback } from '../../../../common/MessageManager'; +@Entry +@Component +struct FlexHeightModify_End { + @State testHeight: number = 50 + messageManager:MessageManager = new MessageManager() + private content: string = "FlexHeightModify_End Page"; + onPageShow() { + console.info('FlexHeightModify_End onPageShow'); + globalThis.value = { + name:'messageManager',message:this.messageManager + } + let callback:Callback = (message:any) => { + console.log('message = ' + message.name + "--" + message.value); + if (message.name == 'height') { + this.testHeight = message.value; + } + } + this.messageManager.registerCallback(callback); + + } + + onBuildDone() { + console.info('FlexHeightModify_End page build done called'); + } + + build() { + Column() { + Column() { + Text('FlexHeightModify').fontSize(9).fontColor(0xCCCCCC).width('90%') + Flex({ + direction: FlexDirection.Row, + alignItems: ItemAlign.End, + wrap: FlexWrap.NoWrap, + }) { + Text('1').width(150).height(this.testHeight).backgroundColor(0xF5DEB3).key('textHeightModify01') + Text('2').width(150).height(100).backgroundColor(0xD2B48C).key('textHeightModify02') + Text('3').width(150).height(150).backgroundColor(0xF5DEB3).key('textHeightModify03') + } + .key('flexHeightModify') + .height(200) + .width(500) + .backgroundColor(0xAFEEEE) + }.width('100%').alignItems(HorizontalAlign.Start) + }.width('100%') + } +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexMargin.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexMargin.ets new file mode 100644 index 0000000000000000000000000000000000000000..5cfb2b855c2e2aa817bdb69fb62306e67f0d42cb --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexMargin.ets @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ +import { MessageManager,Callback } from '../../../../common/MessageManager'; +@Entry +@Component +struct FlexMargin_End { + private content: string = "FlexMargin_End Page"; + + onPageShow() { + console.info('FlexMargin_End page show called'); + } + + onBuildDone() { + console.info('FlexMargin_End page build done called'); + } + + build() { + Column() { + Column() { + Text('FlexTest05').fontSize(9).fontColor(0xCCCCCC).width('90%') + Flex({ + direction: FlexDirection.Row, + alignItems: ItemAlign.End, + wrap: FlexWrap.NoWrap, + }) { + Text('1').width(150).height(50).backgroundColor(0xF5DEB3).key('textFlexMargin01') + Text('2').width(150).height(100).backgroundColor(0xD2B48C).key('textFlexMargin02') + Text('3').width(150).height(150).backgroundColor(0xF5DEB3).key('textFlexMargin03') + } + .key('flexMargin') + .height(200) + .width(500) + .margin(10) + .backgroundColor(0xAFEEEE) + }.width('100%').alignItems(HorizontalAlign.Start) + }.width('100%') + } +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexOffset.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexOffset.ets new file mode 100644 index 0000000000000000000000000000000000000000..aa355aff9252223474fa666a45adba348fbf6032 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexOffset.ets @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ +import { MessageManager,Callback } from '../../../../common/MessageManager'; +@Entry +@Component +struct FlexOffset_End { + private content: string = "FlexOffset_End Page"; + + onPageShow() { + console.info('FlexOffset_End page show called'); + } + + onBuildDone() { + console.info('FlexOffset_End page build done called'); + } + + build() { + Column() { + Column() { + Text('FlexTest09').fontSize(9).fontColor(0xCCCCCC).width('90%') + Flex({ + direction: FlexDirection.Row, + alignItems: ItemAlign.End, + wrap: FlexWrap.NoWrap, + }) { + Text('1').width(150).height(50).backgroundColor(0xF5DEB3).offset({ x: 15, y: 30 }).key('textOffset01') + Text('2').width(150).height(100).backgroundColor(0xD2B48C).key('textOffset02') + Text('3').width(150).height(150).backgroundColor(0xF5DEB3).key('textOffset03') + } + .key('flexOffset') + .height(200) + .width(500) + .backgroundColor(0xAFEEEE) + }.width('100%').alignItems(HorizontalAlign.Start) + }.width('100%') + } +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexPadding.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexPadding.ets new file mode 100644 index 0000000000000000000000000000000000000000..5c392f7a6e515a56ac4d990c4f84f8fd4164898b --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexPadding.ets @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ +import { MessageManager,Callback } from '../../../../common/MessageManager'; +@Entry +@Component +struct FlexPadding_End { + @State testPadding: number = 0 + messageManager:MessageManager = new MessageManager() + private content: string = "FlexPadding_End Page"; + onPageShow() { + console.info('FlexBase_Center onPageShow'); + globalThis.value = { + name:'messageManager',message:this.messageManager + } + let callback:Callback = (message:any) => { + console.log('message = ' + message.name + "--" + message.value); + if (message.name == 'padding') { + this.testPadding = message.value; + } + } + this.messageManager.registerCallback(callback); + } + + onBuildDone() { + console.info('FlexPadding_End page build done called'); + } + + build() { + Column() { + Column() { + Text('FlexPadding_1').fontSize(9).fontColor(0xCCCCCC).width('90%') + Flex({ + direction: FlexDirection.Row, + alignItems: ItemAlign.End, + wrap: FlexWrap.NoWrap, + }) { + Text('1').width(150).height(50).backgroundColor(0xF5DEB3).key('textFlexPadding01') + Text('2').width(150).height(100).backgroundColor(0xD2B48C).key('textFlexPadding02') + Text('3').width(150).height(150).backgroundColor(0xF5DEB3).key('textFlexPadding03') + } + .key('flexPadding01') + .height(200) + .width(500) + .padding(this.testPadding) + .backgroundColor(0xAFEEEE) + }.width('100%').alignItems(HorizontalAlign.Start) + }.width('100%') + } +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexTextMargin.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexTextMargin.ets new file mode 100644 index 0000000000000000000000000000000000000000..423aa09b12082507d9e5c495d3d0ba1cd88a8814 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexTextMargin.ets @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ +import { MessageManager,Callback } from '../../../../common/MessageManager'; +@Entry +@Component +struct FlexTextMargin_End { + @State testMargin: number = 0 + messageManager:MessageManager = new MessageManager() + private content: string = "FlexTextMargin_End Page"; + onPageShow() { + console.info('FlexBase_Center onPageShow'); + globalThis.value = { + name:'messageManager',message:this.messageManager + } + let callback:Callback = (message:any) => { + console.log('message = ' + message.name + "--" + message.value); + if (message.name == 'margin') { + this.testMargin = message.value; + } + } + this.messageManager.registerCallback(callback); + } + + onBuildDone() { + console.info('FlexTextMargin_End page build done called'); + } + + build() { + Column() { + Column() { + Text('FlexTextMargin_1').fontSize(9).fontColor(0xCCCCCC).width('90%') + Flex({ + direction: FlexDirection.Row, + alignItems: ItemAlign.End, + wrap: FlexWrap.NoWrap, + }) { + Text('1').width(150).height(50).backgroundColor(0xF5DEB3).margin(this.testMargin).key('textMargin01') + Text('2').width(150).height(100).backgroundColor(0xD2B48C).key('textMargin02') + Text('3').width(150).height(150).backgroundColor(0xF5DEB3).key('textMargin03') + } + .key('flexTextMargin01') + .height(200) + .width(500) + .backgroundColor(0xAFEEEE) + }.width('100%').alignItems(HorizontalAlign.Start) + }.width('100%') + } +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexVisibility.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexVisibility.ets new file mode 100644 index 0000000000000000000000000000000000000000..df5c0f8c7d38f68fc6e57e4b5a80bcd21ffa2275 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexVisibility.ets @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ +import { MessageManager,Callback } from '../../../../common/MessageManager'; +@Entry +@Component +struct FlexVisibility_End { + @State testVisibility: number = Visibility.Visible + messageManager:MessageManager = new MessageManager() + private content: string = "FlexVisibility_End Page"; + onPageShow() { + console.info('FlexBase_Center onPageShow'); + globalThis.value = { + name:'messageManager',message:this.messageManager + } + let callback:Callback = (message:any) => { + console.log('message = ' + message.name + "--" + message.value); + if (message.name == 'visibility') { + this.testVisibility = message.value; + } + } + this.messageManager.registerCallback(callback); + } + + onBuildDone() { + console.info('FlexVisibility_End page build done called'); + } + + build() { + Column() { + Column() { + Text('FlexTest10').fontSize(9).fontColor(0xCCCCCC).width('90%') + Flex({ + direction: FlexDirection.Row, + alignItems: ItemAlign.End, + wrap: FlexWrap.NoWrap, + }) { + Text('1').width(150).height(50).backgroundColor(0xF5DEB3).visibility(this.testVisibility).key('textVisible01') + Text('2').width(150).height(100).backgroundColor(0xD2B48C).key('textVisible02') + Text('3').width(150).height(150).backgroundColor(0xF5DEB3).key('textVisible03') + } + .key('flexVisible') + .height(200) + .width(500) + .backgroundColor(0xAFEEEE) + }.width('100%').alignItems(HorizontalAlign.Start) + }.width('100%') + } +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexAlignSelfJsunit.test.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexAlignSelfJsunit.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..a724b9415e3cc4b22d77f1bf854066998f06e0f0 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexAlignSelfJsunit.test.ets @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ + +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import router from '@system.router'; +import CommonFunc from "../../../../MainAbility/common/Common"; +import { MessageManager,Callback } from '../../../../MainAbility/common/MessageManager'; +export default function flexAlignSelf_EndJsunit() { + describe('flexItemAlignEndTest', function () { + beforeEach(async function (done) { + let options = { + uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexAlignSelf', + } + try { + router.clear(); + await CommonFunc.sleep(1000); + let pages = router.getState(); + console.info("get FlexSecond state success " + JSON.stringify(pages)); + if (!("FlexSecond" == pages.name)) { + console.info("get FlexSecond state success " + JSON.stringify(pages.name)); + let result = await router.push(options) + console.info("push FlexSecond page success " + JSON.stringify(result)); + } + } catch (err) { + console.error("push FlexSecond page error " + JSON.stringify(err)); + } + await CommonFunc.sleep(2000); + done() + }); + + afterEach(async function () { + await CommonFunc.sleep(1000); + console.info("FlexSecond after each called"); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_1300 + * @tc.name testFlexItemAlignEndSetAlignSelf + * @tc.desc The first subcomponent set AlignSelf attribute. + */ + it('testFlexItemAlignEndSetAlignSelf', 0, async function (done) { + console.info('new testFlexItemAlignEndSetAlignSelf START'); + let strJson1 = getInspectorByKey('flexAlignSelf'); + let obj1 = JSON.parse(strJson1); + let strJson2 = getInspectorByKey('textAlignSelf01'); + let obj2 = JSON.parse(strJson2); + let textAlignSelf01 = CommonFunc.getComponentRect('textAlignSelf01'); + let textAlignSelf02 = CommonFunc.getComponentRect('textAlignSelf02'); + let textAlignSelf03 = CommonFunc.getComponentRect('textAlignSelf03'); + let flexAlignSelf01 = CommonFunc.getComponentRect('flexAlignSelf'); + expect(textAlignSelf01.left).assertEqual(flexAlignSelf01.left) + expect(textAlignSelf01.right).assertEqual(textAlignSelf02.left) + expect(textAlignSelf02.right).assertEqual(textAlignSelf03.left) + expect(textAlignSelf01.bottom).assertEqual(textAlignSelf02.bottom) + expect(textAlignSelf02.bottom).assertEqual(textAlignSelf03.bottom) + expect(textAlignSelf01.bottom).assertEqual(flexAlignSelf01.bottom) + + expect(Math.round(textAlignSelf01.bottom - textAlignSelf01.top)).assertEqual(vp2px(50)) + expect(Math.round(textAlignSelf01.right - textAlignSelf01.left)).assertEqual(vp2px(150)) + expect(Math.round(textAlignSelf02.bottom - textAlignSelf02.top)).assertEqual(vp2px(100)) + expect(Math.round(textAlignSelf02.right - textAlignSelf02.left)).assertEqual(vp2px(150)) + expect(Math.round(textAlignSelf03.bottom - textAlignSelf03.top)).assertEqual(vp2px(150)) + expect(Math.round(textAlignSelf03.right - textAlignSelf03.left)).assertEqual(vp2px(150)) + + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + expect(obj2.$attrs.alignSelf).assertEqual("ItemAlign.End"); + console.info('new testFlexItemAlignEndSetAlignSelf END'); + done(); + }); + }) +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexBaseJsunit.test.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexBaseJsunit.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..a4b20d558144784b873649097b0aa02b795f6785 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexBaseJsunit.test.ets @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ + +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import router from '@system.router'; +import CommonFunc from "../../../../MainAbility/common/Common"; +import { MessageManager,Callback } from '../../../../MainAbility/common/MessageManager'; +export default function flexBase_EndJsunit() { + describe('flexItemAlignEndTest', function () { + beforeEach(async function (done) { + let options = { + uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexBase', + } + try { + router.clear(); + await CommonFunc.sleep(1000); + let pages = router.getState(); + console.info("get FlexBase state success " + JSON.stringify(pages)); + if (!("FlexBase" == pages.name)) { + console.info("get FlexBase state success " + JSON.stringify(pages.name)); + let result = await router.push(options) + console.info("push FlexBase page success " + JSON.stringify(result)); + } + } catch (err) { + console.error("push FlexBase page error " + JSON.stringify(err)); + } + await CommonFunc.sleep(2000); + done() + }); + afterEach(async function () { + await CommonFunc.sleep(1000); + console.info("FlexBase after each called"); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_0100 + * @tc.name testFlexItemAlignEnd + * @tc.desc The subcomponent is inside the parent component. + */ + it('testFlexItemAlignEnd', 0, async function (done) { + console.info('new testFlexItemAlignEnd START'); + globalThis.value.message.notify({name:'height', value:200}); + globalThis.value.message.notify({name:'width', value:500}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flex01'); + let obj1 = JSON.parse(strJson1); + let textFlex01 = CommonFunc.getComponentRect('textFlex01'); + let textFlex02 = CommonFunc.getComponentRect('textFlex02'); + let textFlex03 = CommonFunc.getComponentRect('textFlex03'); + let flex01 = CommonFunc.getComponentRect('flex01'); + expect(flex01.bottom).assertEqual(textFlex01.bottom) + expect(textFlex01.bottom).assertEqual(textFlex02.bottom) + expect(textFlex02.bottom).assertEqual(textFlex03.bottom) + + expect(textFlex01.right).assertEqual(textFlex02.left) + expect(textFlex02.right).assertEqual(textFlex03.left) + expect(Math.round(flex01.right - textFlex03.right)).assertEqual(vp2px(50)) + + expect(Math.round(textFlex01.bottom - textFlex01.top)).assertEqual(vp2px(50)) + expect(Math.round(textFlex02.bottom - textFlex02.top)).assertEqual(vp2px(100)) + expect(Math.round(textFlex03.bottom - textFlex03.top)).assertEqual(vp2px(150)) + expect(Math.round(textFlex01.right - textFlex01.left)).assertEqual(vp2px(150)) + expect(Math.round(textFlex02.right - textFlex02.left)).assertEqual(vp2px(150)) + expect(Math.round(textFlex03.right - textFlex03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEnd END'); + done(); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_0200 + * @tc.name testFlexItemAlignEndExceed + * @tc.desc The subcomponent exceeds the parent component. + */ + it('testFlexItemAlignEndExceed', 0, async function (done) { + console.info('new testFlexItemAlignEndExceed START'); + globalThis.value.message.notify({name:'height', value:140}); + globalThis.value.message.notify({name:'width', value:420}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flex01'); + let obj1 = JSON.parse(strJson1); + let textFlex01 = CommonFunc.getComponentRect('textFlex01'); + let textFlex02 = CommonFunc.getComponentRect('textFlex02'); + let textFlex03 = CommonFunc.getComponentRect('textFlex03'); + let flex01 = CommonFunc.getComponentRect('flex01'); + expect(flex01.bottom).assertEqual(textFlex01.bottom) + expect(textFlex01.bottom).assertEqual(textFlex02.bottom) + expect(textFlex02.bottom).assertEqual(textFlex03.bottom) + expect(textFlex03.bottom).assertEqual(flex01.bottom) + expect(textFlex03.right).assertEqual(flex01.right) + + expect(Math.round(textFlex01.bottom - textFlex01.top)).assertEqual(vp2px(50)) + expect(Math.round(textFlex02.bottom - textFlex02.top)).assertEqual(vp2px(100)) + expect(Math.round(textFlex03.bottom - textFlex03.top)).assertEqual(vp2px(150)) + expect(Math.round(textFlex01.right - textFlex01.left)).assertEqual(vp2px(140)) + expect(Math.round(textFlex02.right - textFlex02.left)).assertEqual(vp2px(140)) + expect(Math.round(textFlex03.right - textFlex03.left)).assertEqual(vp2px(140)) + + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndExceed END'); + done(); + }); + }) +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexExceedJsunit.test.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexExceedJsunit.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..35ea4280078ddf570fe6fef2f23235c6270d97b1 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexExceedJsunit.test.ets @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ + +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import router from '@system.router'; +import CommonFunc from "../../../../MainAbility/common/Common"; +import { MessageManager,Callback } from '../../../../MainAbility/common/MessageManager'; +export default function flexExceed_EndJsunit() { + describe('flexItemAlignEndTest', function () { + beforeEach(async function (done) { + let options = { + uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexExceed', + } + try { + router.clear(); + await CommonFunc.sleep(1000); + let pages = router.getState(); + console.info("get FlexExceed state success " + JSON.stringify(pages)); + if (!("FlexExceed" == pages.name)) { + console.info("get FlexExceed state success " + JSON.stringify(pages.name)); + let result = await router.push(options) + console.info("push FlexExceed page success " + JSON.stringify(result)); + } + } catch (err) { + console.error("push FlexExceed page error " + JSON.stringify(err)); + } + await CommonFunc.sleep(2000); + done() + }); + afterEach(async function () { + await CommonFunc.sleep(1000); + console.info("FlexExceed after each called"); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_0600 + * @tc.name testFlexItemAlignEndSetMarPad + * @tc.desc Subcomponent inside when parent component set margin and padding. + */ + it('testFlexItemAlignEndSetMarPad', 0, async function (done) { + console.info('new testFlexItemAlignEndSetMarPad START'); + globalThis.value.message.notify({name:'padding', value:10}); + globalThis.value.message.notify({name:'margin', value:10}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flexExceed01'); + let obj1 = JSON.parse(strJson1); + let textExceed01 = CommonFunc.getComponentRect('textExceed01'); + let textExceed02 = CommonFunc.getComponentRect('textExceed02'); + let textExceed03 = CommonFunc.getComponentRect('textExceed03'); + let flexExceed01 = CommonFunc.getComponentRect('flexExceed01'); + expect(textExceed01.bottom).assertEqual(textExceed02.bottom) + expect(textExceed02.bottom).assertEqual(textExceed03.bottom) + expect(Math.round(flexExceed01.bottom - textExceed01.bottom)).assertEqual(vp2px(10)) + expect(Math.round(textExceed01.left - flexExceed01.left)).assertEqual(vp2px(10)) + + expect(Math.round(textExceed01.bottom - textExceed01.top)).assertEqual(vp2px(50)) + expect(Math.round(textExceed02.bottom - textExceed02.top)).assertEqual(vp2px(100)) + expect(Math.round(textExceed03.bottom - textExceed03.top)).assertEqual(vp2px(150)) + expect(Math.round(textExceed01.right - textExceed01.left)).assertEqual(vp2px(150)) + expect(Math.round(textExceed02.right - textExceed02.left)).assertEqual(vp2px(150)) + expect(Math.round(textExceed03.right - textExceed03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndSetMarPad END'); + done(); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_0700 + * @tc.name testFlexItemAlignEndSetMarPadExceed + * @tc.desc Subcomponent outside when parent component set margin and padding. + */ + it('testFlexItemAlignEndSetMarPadExceed', 0, async function (done) { + console.info('new testFlexItemAlignEndSetMarPadExceed START'); + globalThis.value.message.notify({name:'padding', value:30}); + globalThis.value.message.notify({name:'margin', value:30}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flexExceed01'); + let obj1 = JSON.parse(strJson1); + let textExceed01 = CommonFunc.getComponentRect('textExceed01'); + let textExceed02 = CommonFunc.getComponentRect('textExceed02'); + let textExceed03 = CommonFunc.getComponentRect('textExceed03'); + let flexExceed01 = CommonFunc.getComponentRect('flexExceed01'); + + expect(textExceed01.bottom).assertEqual(textExceed02.bottom) + expect(textExceed02.bottom).assertEqual(textExceed03.bottom) + expect(flexExceed01.bottom - textExceed01.bottom).assertEqual(vp2px(30)) + expect(textExceed01.left - flexExceed01.left).assertEqual(vp2px(30)) + + expect(textExceed01.bottom - textExceed01.top).assertEqual(vp2px(50)) + expect(textExceed02.bottom - textExceed02.top).assertEqual(vp2px(100)) + expect(textExceed03.bottom - textExceed03.top).assertEqual(vp2px(150)) + expect(textExceed01.right - textExceed01.left).assertEqual(vp2px(440/3)) + expect(textExceed02.right - textExceed02.left).assertEqual(vp2px(440/3)) + expect(textExceed03.right - textExceed03.left).assertEqual(vp2px(440/3)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndSetMarPadExceed END'); + done(); + }); + }) +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexHeightModifyJsunit.test.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexHeightModifyJsunit.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..099f0eaa2536834ce710822bbaf013ab84ff1774 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexHeightModifyJsunit.test.ets @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ + +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import router from '@system.router'; +import CommonFunc from "../../../../MainAbility/common/Common"; +import { MessageManager,Callback } from '../../../../MainAbility/common/MessageManager'; +export default function flexHeightModify_EndJsunit() { + describe('flexItemAlignEndTest', function () { + beforeEach(async function (done) { + let options = { + uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexHeightModify', + } + try { + router.clear(); + await CommonFunc.sleep(1000); + let pages = router.getState(); + console.info("get FlexHeightModify state success " + JSON.stringify(pages)); + if (!("FlexHeightModify" == pages.name)) { + console.info("get FlexHeightModify state success " + JSON.stringify(pages.name)); + let result = await router.push(options) + console.info("push FlexHeightModify page success " + JSON.stringify(result)); + } + } catch (err) { + console.error("push FlexHeightModify page error " + JSON.stringify(err)); + } + await CommonFunc.sleep(2000); + done() + }); + afterEach(async function () { + await CommonFunc.sleep(1000); + console.info("FlexHeightModify after each called"); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_0800 + * @tc.name testFlexItemAlignEndDefaultSize + * @tc.desc Check the the default height of the first subcomponent. + */ + it('testFlexItemAlignEndDefaultSize', 0, async function (done) { + console.info('new testFlexItemAlignEndDefaultSize START'); + let strJson1 = getInspectorByKey('flexHeightModify'); + let obj1 = JSON.parse(strJson1); + let textHeightModify01 = CommonFunc.getComponentRect('textHeightModify01'); + let textHeightModify02 = CommonFunc.getComponentRect('textHeightModify02'); + let textHeightModify03 = CommonFunc.getComponentRect('textHeightModify03'); + let flexHeightModify = CommonFunc.getComponentRect('flexHeightModify'); + + expect(textHeightModify01.bottom).assertEqual(textHeightModify02.bottom) + expect(textHeightModify02.bottom).assertEqual(textHeightModify03.bottom) + expect(textHeightModify01.bottom).assertEqual(flexHeightModify.bottom) + + expect(textHeightModify01.left).assertEqual(flexHeightModify.left) + expect(textHeightModify02.left).assertEqual(textHeightModify01.right) + expect(textHeightModify03.left).assertEqual(textHeightModify02.right) + + expect(Math.round(textHeightModify01.bottom - textHeightModify01.top)).assertEqual(vp2px(50)) + expect(Math.round(textHeightModify02.bottom - textHeightModify02.top)).assertEqual(vp2px(100)) + expect(Math.round(textHeightModify03.bottom - textHeightModify03.top)).assertEqual(vp2px(150)) + expect(Math.round(textHeightModify01.right - textHeightModify01.left)).assertEqual(vp2px(150)) + expect(Math.round(textHeightModify02.right - textHeightModify02.left)).assertEqual(vp2px(150)) + expect(Math.round(textHeightModify03.right - textHeightModify03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndDefaultSize END'); + done(); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_0900 + * @tc.name testFlexItemAlignEndHeightModify + * @tc.desc Modify the first subcomponent's height. + */ + it('testFlexItemAlignEndHeightModify', 0, async function (done) { + console.info('new testFlexItemAlignEndHeightModify START'); + globalThis.value.message.notify({name:'height', value:80}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flexHeightModify'); + let obj1 = JSON.parse(strJson1); + let textHeightModify01 = CommonFunc.getComponentRect('textHeightModify01'); + let textHeightModify02 = CommonFunc.getComponentRect('textHeightModify02'); + let textHeightModify03 = CommonFunc.getComponentRect('textHeightModify03'); + let flexHeightModify = CommonFunc.getComponentRect('flexHeightModify'); + + expect(textHeightModify01.bottom).assertEqual(textHeightModify02.bottom) + expect(textHeightModify02.bottom).assertEqual(textHeightModify03.bottom) + expect(textHeightModify01.bottom).assertEqual(flexHeightModify.bottom) + + expect(textHeightModify01.left).assertEqual(flexHeightModify.left) + expect(textHeightModify02.left).assertEqual(textHeightModify01.right) + expect(textHeightModify03.left).assertEqual(textHeightModify02.right) + + expect(Math.round(textHeightModify01.bottom - textHeightModify01.top)).assertEqual(vp2px(80)) + expect(Math.round(textHeightModify02.bottom - textHeightModify02.top)).assertEqual(vp2px(100)) + expect(Math.round(textHeightModify03.bottom - textHeightModify03.top)).assertEqual(vp2px(150)) + expect(Math.round(textHeightModify01.right - textHeightModify01.left)).assertEqual(vp2px(150)) + expect(Math.round(textHeightModify02.right - textHeightModify02.left)).assertEqual(vp2px(150)) + expect(Math.round(textHeightModify03.right - textHeightModify03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndHeightModify END'); + done(); + }); + }) +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexMarginJsunit.test.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexMarginJsunit.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..dc2b79b192862ef4eb55327efa0873ec8cf42896 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexMarginJsunit.test.ets @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ + +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import router from '@system.router'; +import CommonFunc from "../../../../MainAbility/common/Common"; +import { MessageManager,Callback } from '../../../../MainAbility/common/MessageManager'; +export default function flexMargin_EndJsunit() { + describe('flexItemAlignEndTest', function () { + beforeEach(async function (done) { + let options = { + uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexMargin', + } + try { + router.clear(); + await CommonFunc.sleep(1000); + let pages = router.getState(); + console.info("get FlexMargin state success " + JSON.stringify(pages)); + if (!("FlexMargin" == pages.name)) { + console.info("get FlexMargin state success " + JSON.stringify(pages.name)); + let result = await router.push(options) + console.info("push FlexMargin page success " + JSON.stringify(result)); + } + } catch (err) { + console.error("push FlexMargin page error " + JSON.stringify(err)); + } + await CommonFunc.sleep(2000); + done() + }); + afterEach(async function () { + await CommonFunc.sleep(1000); + console.info("FlexMargin after each called"); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_0500 + * @tc.name testItemAlignEndParentSetMargin + * @tc.desc Parent component set margin attribute. + */ + it('testItemAlignEndParentSetMargin', 0, async function (done) { + console.info('new testItemAlignEndParentSetMargin START'); + let strJson1 = getInspectorByKey('flexMargin'); + let obj1 = JSON.parse(strJson1); + let textFlexMargin01 = CommonFunc.getComponentRect('textFlexMargin01'); + let textFlexMargin02 = CommonFunc.getComponentRect('textFlexMargin02'); + let textFlexMargin03 = CommonFunc.getComponentRect('textFlexMargin03'); + let flexMargin = CommonFunc.getComponentRect('flexMargin'); + expect(textFlexMargin01.left).assertEqual(flexMargin.left) + expect(textFlexMargin01.right).assertEqual(textFlexMargin02.left) + expect(textFlexMargin02.right).assertEqual(textFlexMargin03.left) + + expect(flexMargin.bottom).assertEqual(textFlexMargin01.bottom) + expect(textFlexMargin01.bottom).assertEqual(textFlexMargin02.bottom) + expect(textFlexMargin02.bottom).assertEqual(textFlexMargin03.bottom) + + expect(Math.round(textFlexMargin01.bottom - textFlexMargin01.top)).assertEqual(vp2px(50)) + expect(Math.round(textFlexMargin02.bottom - textFlexMargin02.top)).assertEqual(vp2px(100)) + expect(Math.round(textFlexMargin03.bottom - textFlexMargin03.top)).assertEqual(vp2px(150)) + expect(Math.round(textFlexMargin01.right - textFlexMargin01.left)).assertEqual(vp2px(150)) + expect(Math.round(textFlexMargin02.right - textFlexMargin02.left)).assertEqual(vp2px(150)) + expect(Math.round(textFlexMargin03.right - textFlexMargin03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testItemAlignEndParentSetMargin END'); + done(); + }); + }) +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexOffsetJsunit.test.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexOffsetJsunit.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..96c85743cca4565bb87392cb58b5e7c6ede2521e --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexOffsetJsunit.test.ets @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ + +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import router from '@system.router'; +import CommonFunc from "../../../../MainAbility/common/Common"; +import { MessageManager,Callback } from '../../../../MainAbility/common/MessageManager'; +export default function flexOffset_EndJsunit() { + describe('flexItemAlignEndTest', function () { + beforeEach(async function (done) { + let options = { + uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexOffset', + } + try { + router.clear(); + await CommonFunc.sleep(1000); + let pages = router.getState(); + console.info("get FlexOffset state success " + JSON.stringify(pages)); + if (!("FlexOffset" == pages.name)) { + console.info("get FlexOffset state success " + JSON.stringify(pages.name)); + let result = await router.push(options) + console.info("push FlexOffset page success " + JSON.stringify(result)); + } + } catch (err) { + console.error("push FlexOffset page error " + JSON.stringify(err)); + } + await CommonFunc.sleep(2000); + done() + }); + afterEach(async function () { + await CommonFunc.sleep(1000); + console.info("FlexOffset after each called"); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_1000 + * @tc.name testFlexItemAlignEndSetOffset + * @tc.desc First subcomponent set offset attribute. + */ + it('testFlexItemAlignEndSetOffset', 0, async function (done) { + console.info('new testFlexItemAlignEndSetOffset START'); + let strJson1 = getInspectorByKey('flexOffset'); + let obj1 = JSON.parse(strJson1); + let textOffset01 = CommonFunc.getComponentRect('textOffset01'); + let textOffset02 = CommonFunc.getComponentRect('textOffset02'); + let textOffset03 = CommonFunc.getComponentRect('textOffset03'); + let flexOffset = CommonFunc.getComponentRect('flexOffset'); + expect(Math.round((textOffset01.right - textOffset02.left)*10)/10).assertEqual(Math.round(vp2px(15)*10)/10) + expect(Math.round(textOffset01.bottom - flexOffset.bottom)).assertEqual(vp2px(30)) + expect(Math.round((textOffset01.left - flexOffset.left)*10)/10).assertEqual(Math.round(vp2px(15)*10)/10) + expect(textOffset03.left).assertEqual(textOffset02.right) + expect(textOffset02.bottom).assertEqual(textOffset03.bottom) + expect(textOffset03.bottom).assertEqual(flexOffset.bottom) + + expect(Math.round(textOffset01.bottom - textOffset01.top)).assertEqual(vp2px(50)) + expect(Math.round(textOffset02.bottom - textOffset02.top)).assertEqual(vp2px(100)) + expect(Math.round(textOffset03.bottom - textOffset03.top)).assertEqual(vp2px(150)) + expect(Math.round(textOffset01.right - textOffset01.left)).assertEqual(vp2px(150)) + expect(Math.round(textOffset02.right - textOffset02.left)).assertEqual(vp2px(150)) + expect(Math.round(textOffset03.right - textOffset03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndSetOffset END'); + done(); + }); + }) +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexPaddingJsunit.test.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexPaddingJsunit.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..94e9d254e80ff389a73858116810c4b8797e9b70 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexPaddingJsunit.test.ets @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ + +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import router from '@system.router'; +import CommonFunc from "../../../../MainAbility/common/Common"; +import { MessageManager,Callback } from '../../../../MainAbility/common/MessageManager'; +export default function flexPadding_EndJsunit() { + describe('flexItemAlignEndTest', function () { + beforeEach(async function (done) { + let options = { + uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexPadding', + } + try { + router.clear(); + await CommonFunc.sleep(1000); + let pages = router.getState(); + console.info("get FlexPadding state success " + JSON.stringify(pages)); + if (!("FlexPadding" == pages.name)) { + console.info("get FlexPadding state success " + JSON.stringify(pages.name)); + let result = await router.push(options) + console.info("push FlexPadding page success " + JSON.stringify(result)); + } + } catch (err) { + console.error("push FlexPadding page error " + JSON.stringify(err)); + } + await CommonFunc.sleep(2000); + done() + }); + afterEach(async function () { + await CommonFunc.sleep(1000); + console.info("FlexPadding after each called"); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_0300 + * @tc.name testFlexItemAlignEndParentSetPadding + * @tc.desc Parent component set paddding,subcomponent does not exceed the parent component. + */ + it('testFlexItemAlignEndParentSetPadding', 0, async function (done) { + console.info('new testFlexItemAlignEndParentSetPadding START'); + globalThis.value.message.notify({name:'padding', value:10}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flexPadding01'); + let obj1 = JSON.parse(strJson1); + let strJson2 = getInspectorByKey('textFlexPadding01'); + let obj2 = JSON.parse(strJson2); + let textFlexPadding01 = CommonFunc.getComponentRect('textFlexPadding01') + let textFlexPadding02 = CommonFunc.getComponentRect('textFlexPadding02') + let textFlexPadding03 = CommonFunc.getComponentRect('textFlexPadding03') + let flexPadding01 = CommonFunc.getComponentRect('flexPadding01') + + expect(textFlexPadding01.bottom).assertEqual(textFlexPadding02.bottom) + expect(textFlexPadding02.bottom).assertEqual(textFlexPadding03.bottom) + expect(Math.round(flexPadding01.bottom - textFlexPadding01.bottom)).assertEqual(vp2px(10)) + expect(Math.round(textFlexPadding01.left - flexPadding01.left)).assertEqual(vp2px(10)) + expect(textFlexPadding03.right).assertLess(flexPadding01.right) + + expect(Math.round(textFlexPadding01.bottom - textFlexPadding01.top)).assertEqual(vp2px(50)) + expect(Math.round(textFlexPadding02.bottom - textFlexPadding02.top)).assertEqual(vp2px(100)) + expect(Math.round(textFlexPadding03.bottom - textFlexPadding03.top)).assertEqual(vp2px(150)) + + expect(Math.round(textFlexPadding01.right - textFlexPadding01.left)).assertEqual(vp2px(150)) + expect(Math.round(textFlexPadding02.right - textFlexPadding02.left)).assertEqual(vp2px(150)) + expect(Math.round(textFlexPadding03.right - textFlexPadding03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndParentSetPadding END'); + done(); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_0400 + * @tc.name testFlexItemAlignEndParentSetPaddingExceed + * @tc.desc Parent component set paddding,subcomponent exceedS the parent component. + */ + it('testFlexItemAlignEndParentSetPaddingExceed', 0, async function (done) { + console.info('new testFlexItemAlignEndParentSetPaddingExceed START'); + globalThis.value.message.notify({name:'padding', value:30}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flexPadding01'); + let obj1 = JSON.parse(strJson1); + let strJson2 = getInspectorByKey('textFlexPadding01'); + let obj2 = JSON.parse(strJson2); + let textFlexPadding01 = CommonFunc.getComponentRect('textFlexPadding01') + let textFlexPadding02 = CommonFunc.getComponentRect('textFlexPadding02') + let textFlexPadding03 = CommonFunc.getComponentRect('textFlexPadding03') + let flexPadding01 = CommonFunc.getComponentRect('flexPadding01') + expect(textFlexPadding01.bottom).assertEqual(textFlexPadding02.bottom) + expect(textFlexPadding02.bottom).assertEqual(textFlexPadding03.bottom) + expect(Math.round(flexPadding01.bottom - textFlexPadding01.bottom)).assertEqual(vp2px(30)) + expect(Math.round(textFlexPadding01.left - flexPadding01.left)).assertEqual(vp2px(30)) + expect(textFlexPadding03.right).assertLess(flexPadding01.right) + + expect(Math.round(textFlexPadding01.bottom - textFlexPadding01.top)).assertEqual(vp2px(50)) + expect(Math.round(textFlexPadding02.bottom - textFlexPadding02.top)).assertEqual(vp2px(100)) + expect(Math.round(textFlexPadding03.bottom - textFlexPadding03.top)).assertEqual(vp2px(150)) + expect(Math.round(textFlexPadding01.right - textFlexPadding01.left)).assertEqual(vp2px(440/3)) + expect(Math.round(textFlexPadding02.right - textFlexPadding02.left)).assertEqual(vp2px(440/3)) + expect(Math.round(textFlexPadding03.right - textFlexPadding03.left)).assertEqual(vp2px(440/3)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndParentSetPaddingExceed END'); + done(); + }); + }) +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexTextMarginJsunit.test.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexTextMarginJsunit.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..4d6fe1e05014e8f3a83ada402023d896addfc2bf --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexTextMarginJsunit.test.ets @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ + +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import router from '@system.router'; +import CommonFunc from "../../../../MainAbility/common/Common"; +import { MessageManager,Callback } from '../../../../MainAbility/common/MessageManager'; +export default function flexTextMargin_EndJsunit() { + describe('flexItemAlignEndTest', function () { + beforeEach(async function (done) { + let options = { + uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexTextMargin', + } + try { + router.clear(); + await CommonFunc.sleep(1000); + let pages = router.getState(); + console.info("get FlexTextMargin state success " + JSON.stringify(pages)); + if (!("FlexTextMargin" == pages.name)) { + console.info("get FlexTextMargin state success " + JSON.stringify(pages.name)); + let result = await router.push(options) + console.info("push FlexTextMargin page success " + JSON.stringify(result)); + } + } catch (err) { + console.error("push FlexTextMargin page error " + JSON.stringify(err)); + } + await CommonFunc.sleep(2000); + done() + }); + afterEach(async function () { + await CommonFunc.sleep(1000); + console.info("FlexTextMargin after each called"); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_1400 + * @tc.name testFlexItemAlignEndSubSetMargin + * @tc.desc Subcomponents set margin within the scope of the parent component. + */ + it('testFlexItemAlignEndSubSetMargin', 0, async function (done) { + console.info('new testFlexItemAlignEndSubSetMargin START'); + globalThis.value.message.notify({name:'margin', value:10}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flexTextMargin01'); + let obj1 = JSON.parse(strJson1); + let textMargin01 = CommonFunc.getComponentRect('textMargin01'); + let textMargin02 = CommonFunc.getComponentRect('textMargin02'); + let textMargin03 = CommonFunc.getComponentRect('textMargin03'); + let flexTextMargin01 = CommonFunc.getComponentRect('flexTextMargin01'); + expect(Math.round(textMargin01.left - flexTextMargin01.left)).assertEqual(vp2px(10)) + expect(Math.round(textMargin02.left - textMargin01.right)).assertEqual(vp2px(10)) + expect(textMargin02.right).assertEqual(textMargin03.left) + expect(Math.round(flexTextMargin01.right - textMargin03.right)).assertEqual(vp2px(30)) + + expect(Math.round(flexTextMargin01.bottom - textMargin01.bottom)).assertEqual(vp2px(10)) + expect(textMargin02.bottom).assertEqual(textMargin03.bottom) + expect(textMargin03.bottom).assertEqual(flexTextMargin01.bottom) + + expect(Math.round(textMargin01.bottom - textMargin01.top)).assertEqual(vp2px(50)) + expect(Math.round(textMargin02.bottom - textMargin02.top)).assertEqual(vp2px(100)) + expect(Math.round(textMargin03.bottom - textMargin03.top)).assertEqual(vp2px(150)) + expect(Math.round(textMargin01.right - textMargin01.left)).assertEqual(vp2px(150)) + expect(Math.round(textMargin02.right - textMargin02.left)).assertEqual(vp2px(150)) + expect(Math.round(textMargin03.right - textMargin03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndSubSetMargin END'); + done(); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_1500 + * @tc.name testFlexItemAlignEndSubSetMarginExceed + * @tc.desc Subcomponents set margin outside the scope of the parent component. + */ + it('testFlexItemAlignEndSubSetMarginExceed', 0, async function (done) { + console.info('new testFlexItemAlignEndSubSetMarginExceed START'); + globalThis.value.message.notify({name:'margin', value:30}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flexTextMargin01'); + let obj1 = JSON.parse(strJson1); + let textMargin01 = CommonFunc.getComponentRect('textMargin01'); + let textMargin02 = CommonFunc.getComponentRect('textMargin02'); + let textMargin03 = CommonFunc.getComponentRect('textMargin03'); + let flexTextMargin01 = CommonFunc.getComponentRect('flexTextMargin01'); + expect(Math.round(textMargin01.left - flexTextMargin01.left)).assertEqual(vp2px(30)) + expect(Math.round(textMargin02.left - textMargin01.right)).assertEqual(vp2px(30)) + expect(textMargin02.right).assertEqual(textMargin03.left) + expect(textMargin03.right).assertEqual(flexTextMargin01.right) + expect(Math.round(flexTextMargin01.bottom - textMargin01.bottom)).assertEqual(vp2px(30)) + expect(textMargin02.bottom).assertEqual(textMargin03.bottom) + expect(textMargin03.bottom).assertEqual(flexTextMargin01.bottom) + + expect(Math.round(textMargin01.bottom - textMargin01.top)).assertEqual(vp2px(50)) + expect(Math.round(textMargin02.bottom - textMargin02.top)).assertEqual(vp2px(100)) + expect(Math.round(textMargin03.bottom - textMargin03.top)).assertEqual(vp2px(150)) + expect(Math.round(textMargin01.right - textMargin01.left)).assertEqual(vp2px(440/3)) + expect(Math.round(textMargin02.right - textMargin02.left)).assertEqual(vp2px(440/3)) + expect(Math.round(textMargin03.right - textMargin03.left)).assertEqual(vp2px(440/3)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + console.info('new testFlexItemAlignEndSubSetMarginExceed END'); + done(); + }); + }) +} diff --git a/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexVisibilityJsunit.test.ets b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexVisibilityJsunit.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..76414305967cb4e140beef74d2489f02302bb001 --- /dev/null +++ b/arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_End/FlexVisibilityJsunit.test.ets @@ -0,0 +1,131 @@ +/* + * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd. + * 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. + */ + +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; +import router from '@system.router'; +import CommonFunc from "../../../../MainAbility/common/Common"; +import {MessageManager,Callback} from '../../../../MainAbility/common/MessageManager'; +export default function flexVisibility_EndJsunit() { + describe('flexItemAlignEndTest', function () { + beforeEach(async function (done) { + let options = { + uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_End/FlexVisibility', + } + try { + router.clear(); + await CommonFunc.sleep(1000); + let pages = router.getState(); + console.info("get FlexVisibility state success " + JSON.stringify(pages)); + if (!("FlexVisibility" == pages.name)) { + console.info("get FlexVisibility state success " + JSON.stringify(pages.name)); + let result = await router.push(options) + console.info("push FlexVisibility page success " + JSON.stringify(result)); + } + } catch (err) { + console.error("push FlexVisibility page error " + JSON.stringify(err)); + } + await CommonFunc.sleep(2000); + done() + }); + + afterEach(async function () { + await CommonFunc.sleep(1000); + console.info("FlexVisibility after each called"); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_1100 + * @tc.name testFlexItemAlignEndSubSetVisibilityNone + * @tc.desc The first subcomponent set Visibility.None attribute. + */ + it('testFlexItemAlignEndSubSetVisibilityNone', 0, async function (done) { + console.info('new testFlexItemAlignEndSubSetVisibilityNone START'); + try { + globalThis.value.message.notify({name:'visibility', value:Visibility.None}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flexVisible'); + let obj1 = JSON.parse(strJson1); + let strJson2 = getInspectorByKey('textVisible01'); + let obj2 = JSON.parse(strJson2); + expect(obj2.$attrs.visibility).assertEqual("Visibility.None"); + let textVisible01 = CommonFunc.getComponentRect('textVisible01'); + let textVisible02 = CommonFunc.getComponentRect('textVisible02'); + let textVisible03 = CommonFunc.getComponentRect('textVisible03'); + let flexVisible = CommonFunc.getComponentRect('flexVisible'); + + expect(textVisible01.left).assertEqual(textVisible01.right) + expect(textVisible01.right).assertEqual(flexVisible.left) + expect(textVisible02.left).assertEqual(flexVisible.left) + expect(textVisible02.right).assertEqual(textVisible03.left) + expect(textVisible02.bottom).assertEqual(textVisible03.bottom) + expect(textVisible03.bottom).assertEqual(flexVisible.bottom) + + expect(Math.round(textVisible02.bottom - textVisible02.top)).assertEqual(vp2px(100)) + expect(Math.round(textVisible03.bottom - textVisible03.top)).assertEqual(vp2px(150)) + expect(Math.round(textVisible02.right - textVisible02.left)).assertEqual(vp2px(150)) + expect(Math.round(textVisible03.right - textVisible03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.visibility).assertEqual("Visibility.Visible"); + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + } catch (err) { + console.error('[testFlexItemAlignBaselineSubSetVisibilityNone] failed'); + expect().assertFail(); + } + console.info('new testFlexItemAlignEndSubSetVisibilityNone END'); + done(); + }); + + /** + * @tc.number SUB_ACE_FLEXALIGNITEMS_END_1200 + * @tc.name testFlexItemAlignEndSubSetVisibilityHidden + * @tc.desc The first subcomponent set Visibility.Hidden attribute. + */ + it('testFlexItemAlignEndSubSetVisibilityHidden', 0, async function (done) { + console.info('new testFlexItemAlignEndSubSetVisibilityHidden START'); + try { + globalThis.value.message.notify({name:'visibility', value:Visibility.Hidden}); + await CommonFunc.sleep(2000); + let strJson1 = getInspectorByKey('flexVisible'); + let obj1 = JSON.parse(strJson1); + let strJson2 = getInspectorByKey('textVisible01'); + let obj2 = JSON.parse(strJson2); + expect(obj2.$attrs.visibility).assertEqual("Visibility.Hidden"); + let textVisible01 = CommonFunc.getComponentRect('textVisible01'); + let textVisible02 = CommonFunc.getComponentRect('textVisible02'); + let textVisible03 = CommonFunc.getComponentRect('textVisible03'); + let flexVisible = CommonFunc.getComponentRect('flexVisible'); + expect(textVisible01.left).assertEqual(flexVisible.left) + expect(textVisible01.right).assertEqual(textVisible02.left) + expect(textVisible02.right).assertEqual(textVisible03.left) + expect(textVisible02.bottom).assertEqual(textVisible03.bottom) + expect(textVisible03.bottom).assertEqual(flexVisible.bottom) + + expect(Math.round(textVisible01.bottom - textVisible01.top)).assertEqual(vp2px(50)) + expect(Math.round(textVisible02.bottom - textVisible02.top)).assertEqual(vp2px(100)) + expect(Math.round(textVisible03.bottom - textVisible03.top)).assertEqual(vp2px(150)) + expect(Math.round(textVisible01.right - textVisible01.left)).assertEqual(vp2px(150)) + expect(Math.round(textVisible02.right - textVisible02.left)).assertEqual(vp2px(150)) + expect(Math.round(textVisible03.right - textVisible03.left)).assertEqual(vp2px(150)) + expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row') + expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.End') + } catch (err) { + console.error('[testFlexItemAlignBaselineSubSetVisibilityNone] failed'); + expect().assertFail(); + } + console.info('new testFlexItemAlignEndSubSetVisibilityHidden END'); + done(); + }); + }) +}