FlexAlignItems xts code submit

Signed-off-by: Nzhanghailin <hlzhangai@isoftstone.com>

arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/FlexAlignSelf.ets

+/*
+ * 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.
+ */
+ 
+@Entry
+@Component
+struct FlexAlignSelf_Baseline {
+  private content: string = "FlexAlignSelf_Baseline Page";
+
+  onPageShow() {
+    console.info('FlexAlignSelf_Baseline page show called');
+  }
+
+  onBuildDone() {
+    console.info('FlexAlignSelf_Baseline page build done called');
+  }
+
+  build() { 
+    Column() {
+      Column() {
+        Text('FlexTest12').fontSize(9).fontColor(0xCCCCCC).width('90%')
+        Flex({
+          direction: FlexDirection.Row,
+          alignItems: ItemAlign.Baseline,
+          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%')
+  }
+}

arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/FlexBase.ets

+/*
+ * 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_Baseline {
+  @State testHeight: number = 150
+  @State testWidth: number = 450
+  messageManager:MessageManager = new MessageManager()
+  private content: string = "FlexBase_Baseline 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_Baseline page build done called');
+  }
+
+  build() { 
+    Column() {
+      Column() {
+        Text('FlexTest01').fontSize(9).fontColor(0xCCCCCC).width('90%')
+        Flex({
+          direction: FlexDirection.Row,
+          alignItems: ItemAlign.Baseline,
+          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%')
+  }
+}

arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/FlexExceed.ets

+/*
+ * 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_Baseline {
+  @State testPadding: number = 0
+  @State testMargin: number = 0
+  messageManager:MessageManager = new MessageManager()
+  private content: string = "FlexExceed_Baseline 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_Baseline page build done called');
+  }
+
+  build() { 
+    Column() {
+      Column() {
+        Text('FlexExceed_1').fontSize(9).fontColor(0xCCCCCC).width('90%')
+        Flex({
+          direction: FlexDirection.Row,
+          alignItems: ItemAlign.Baseline,
+          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%')
+  }
+}

arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/FlexHeightModify.ets

+/*
+ * 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_Baseline {
+  @State testHeight: number = 50
+  messageManager:MessageManager = new MessageManager()
+  private content: string = "FlexHeightModify_Baseline Page";
+  onPageShow() {
+    console.info('FlexHeightModify_Baseline 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_Baseline page build done called');
+  }
+
+  build() { 
+    Column() {
+      Column() {
+        Text('FlexHeightModify').fontSize(9).fontColor(0xCCCCCC).width('90%')
+        Flex({
+          direction: FlexDirection.Row,
+          alignItems: ItemAlign.Baseline,
+          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%')
+  }
+}

arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/FlexMargin.ets

+/*
+ * 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.
+ */
+ 
+@Entry
+@Component
+struct FlexMargin_Baseline {
+  private content: string = "FlexMargin_Baseline Page";
+
+  onPageShow() {
+    console.info('FlexMargin_Baseline page show called');
+  }
+
+  onBuildDone() {
+    console.info('FlexMargin_Baseline page build done called');
+  }
+
+  build() { 
+    Column() {
+      Column() {
+        Text('FlexMargin').fontSize(9).fontColor(0xCCCCCC).width('90%')
+        Flex({
+          direction: FlexDirection.Row,
+          alignItems: ItemAlign.Baseline,
+          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%')
+  }
+}

arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/FlexOffset.ets

+/*
+ * 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.
+ */
+ 
+@Entry
+@Component
+struct FlexOffset_Baseline {
+  private content: string = "FlexOffset_Baseline Page";
+
+  onPageShow() {
+    console.info('FlexOffset_Baseline page show called');
+  }
+
+  onBuildDone() {
+    console.info('FlexOffset_Baseline page build done called');
+  }
+
+  build() { 
+    Column() {
+      Column() {
+        Text('FlexTest09').fontSize(9).fontColor(0xCCCCCC).width('90%')
+        Flex({
+          direction: FlexDirection.Row,
+          alignItems: ItemAlign.Baseline,
+          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%')
+  }
+}

arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/FlexPadding.ets

+/*
+ * 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_Baseline {
+  @State testPadding: number = 0
+  messageManager:MessageManager = new MessageManager()
+  private content: string = "FlexPadding_Baseline Page";
+  onPageShow() {
+    console.info('FlexPadding_Baseline 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_Baseline page build done called');
+  }
+
+  build() { 
+    Column() {
+      Column() {
+        Text('FlexTest03').fontSize(9).fontColor(0xCCCCCC).width('90%')
+        Flex({
+          direction: FlexDirection.Row,
+          alignItems: ItemAlign.Baseline,
+          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%')
+  }
+}

arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/FlexTextMargin.ets

+/*
+ * 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_Baseline {
+  @State testMargin: number = 0
+  messageManager:MessageManager = new MessageManager()
+  private content: string = "FlexTextMargin_Baseline Page";
+  onPageShow() {
+    console.info('FlexTextMargin_Baseline 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_Baseline page build done called');
+  }
+
+  build() { 
+    Column() {
+      Column() {
+        Text('FlexTextMargin_1').fontSize(9).fontColor(0xCCCCCC).width('90%')
+        Flex({
+          direction: FlexDirection.Row,
+          alignItems: ItemAlign.Baseline,
+          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%')
+  }
+}

arkui/ace_ets_layout_test/entry/src/main/ets/MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/FlexVisibility.ets

+/*
+ * 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_Baseline {
+  @State testVisibility: number = Visibility.Visible
+  messageManager:MessageManager = new MessageManager()
+  private content: string = "FlexVisibility_Baseline Page";
+  onPageShow() {
+    console.info('FlexVisibility_Baseline 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_Baseline page build done called');
+  }
+
+  build() { 
+    Column() {
+      Column() {
+        Text('FlexTest10').fontSize(9).fontColor(0xCCCCCC).width('90%')
+        Flex({
+          direction: FlexDirection.Row,
+          alignItems: ItemAlign.Baseline,
+          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%')
+  }
+}

arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_Baseline/FlexAlignSelfJsunit.test.ets

+/*
+ * 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";
+export default function flexAlignSelf_BaselineJsunit() {
+  describe('flexItemAlignBaselineTest', function () {
+    beforeEach(async function (done) {
+      let options = {
+        uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/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_BASELINE_1300
+     * @tc.name      testFlexItemAlignBaselineSetAlignSelf
+     * @tc.desc      The first subcomponent set ItemAlign.End attribute.
+     */
+    it('testFlexItemAlignBaselineSetAlignSelf', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineSetAlignSelf START');
+      let strJson1 = getInspectorByKey('flexAlignSelf');
+      let obj1 = JSON.parse(strJson1);
+      let strJson2 = getInspectorByKey('textAlignSelf01');
+      let obj2 = JSON.parse(strJson2);
+      let alignSelf01 = CommonFunc.getComponentRect('textAlignSelf01');
+      let alignSelf02 = CommonFunc.getComponentRect('textAlignSelf02');
+      let alignSelf03 = CommonFunc.getComponentRect('textAlignSelf03');
+      let flexAlignSelf01 = CommonFunc.getComponentRect('flexAlignSelf');
+      expect(alignSelf01.bottom).assertEqual(flexAlignSelf01.bottom)
+      expect(alignSelf03.top).assertEqual(flexAlignSelf01.top)
+      expect(alignSelf02.top - alignSelf03.top).assertEqual(alignSelf03.bottom - alignSelf02.bottom)
+      expect(Math.round(alignSelf01.bottom - alignSelf01.top)).assertEqual(vp2px(50))
+      expect(Math.round(alignSelf02.bottom - alignSelf02.top)).assertEqual(vp2px(100))
+      expect(Math.round(alignSelf03.bottom - alignSelf03.top)).assertEqual(vp2px(150))
+      expect(Math.round(alignSelf01.right - alignSelf01.left)).assertEqual(vp2px(150))
+      expect(Math.round(alignSelf02.right - alignSelf02.left)).assertEqual(vp2px(150))
+      expect(Math.round(alignSelf03.right - alignSelf03.left)).assertEqual(vp2px(150))
+
+      expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row')
+      expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.Baseline')
+      expect(obj2.$attrs.alignSelf).assertEqual("ItemAlign.End");
+      console.info('new testFlexItemAlignBaselineSetAlignSelf END');
+      done();
+    });
+  })
+}

arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_Baseline/FlexBaseJsunit.test.ets

+/*
+ * 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_BaselineJsunit() {
+  describe('flexItemAlignBaselineTest', function () {
+    beforeEach(async function (done) {
+      let options = {
+        uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/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_BASELINE_0100
+     * @tc.name      testFlexItemAlignBaseline
+     * @tc.desc      The subcomponent is inside the parent component.
+     */
+    it('testFlexItemAlignBaseline', 0, async function (done) {
+      console.info('new testFlexItemAlignBaseline 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(textFlex01.left).assertEqual(flex01.left)
+      expect(textFlex01.right).assertEqual(textFlex02.left)
+      expect(textFlex02.right).assertEqual(textFlex03.left)
+      expect(Math.round(flex01.right - textFlex03.right)).assertEqual(vp2px(50))
+
+      expect(textFlex01.top - textFlex03.top).assertEqual(textFlex03.bottom - textFlex01.bottom)
+      expect(textFlex02.top - textFlex03.top).assertEqual(textFlex03.bottom - textFlex02.bottom)
+
+      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.Baseline')
+      console.info('new testFlexItemAlignBaseline END');
+      done();
+    });
+
+    /**
+     * @tc.number    SUB_ACE_FLEXALIGNITEMS_BASELINE_0200
+     * @tc.name      testFlexItemAlignBaselineExceed
+     * @tc.desc      The subcomponent exceeds the parent component.
+     */
+    it('testFlexItemAlignBaselineExceed', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineExceed 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(textFlex01.left).assertEqual(flex01.left)
+      expect(textFlex01.right).assertEqual(textFlex02.left)
+      expect(textFlex02.right).assertEqual(textFlex03.left)
+      expect(textFlex03.top).assertEqual(flex01.top)
+      expect(textFlex03.bottom).assertLarger(flex01.bottom)
+      expect(textFlex03.right).assertEqual(flex01.right)
+
+      expect(textFlex01.top - textFlex03.top).assertEqual(textFlex03.bottom - textFlex01.bottom)
+      expect(textFlex02.top - textFlex03.top).assertEqual(textFlex03.bottom - textFlex02.bottom)
+
+      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.Baseline')
+      console.info('new testFlexItemAlignBaselineExceed END');
+      done();
+    });
+  })
+}

arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_Baseline/FlexExceedJsunit.test.ets

+/*
+ * 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_BaselineJsunit() {
+  describe('flexItemAlignBaselineTest', function () {
+    beforeEach(async function (done) {
+      let options = {
+        uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/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_BASELINE_0600
+     * @tc.name      testFlexItemAlignBaselineSetMarPad
+     * @tc.desc      Subcomponent inside when parent component set margin and padding.
+     */
+    it('testFlexItemAlignBaselineSetMarPad', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineSetMarPad 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(Math.round(textExceed01.left - flexExceed01.left)).assertEqual(vp2px(10))
+      expect(textExceed01.right).assertEqual(textExceed02.left)
+      expect(textExceed02.right).assertEqual(textExceed03.left)
+      expect(Math.round(flexExceed01.right - textExceed03.right)).assertEqual(vp2px(40))
+
+      expect(Math.round(textExceed01.top - flexExceed01.top)).assertEqual(vp2px(60))
+      expect(Math.round(textExceed03.top - flexExceed01.top)).assertEqual(vp2px(10))
+      expect(textExceed01.top - textExceed03.top).assertEqual(textExceed03.bottom - textExceed01.bottom)
+      expect(textExceed02.top - textExceed03.top).assertEqual(textExceed03.bottom - textExceed02.bottom)
+
+      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.Baseline')
+      console.info('new testFlexItemAlignBaselineSetMarPad END');
+      done();
+    });
+
+    /**
+     * @tc.number    SUB_ACE_FLEXALIGNITEMS_BASELINE_0700
+     * @tc.name      testFlexItemAlignBaselineSetMarPadExceed
+     * @tc.desc      Subcomponent outside when parent component set margin and padding.
+     */
+    it('testFlexItemAlignBaselineSetMarPadExceed', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineSetMarPadExceed 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(Math.round(textExceed01.left - flexExceed01.left)).assertEqual(vp2px(30))
+      expect(textExceed01.right).assertEqual(textExceed02.left)
+      expect(textExceed02.right).assertEqual(textExceed03.left)
+      expect(Math.round(flexExceed01.right - textExceed03.right)).assertEqual(vp2px(30))
+
+      expect(Math.round(textExceed01.top - flexExceed01.top)).assertEqual(vp2px(80))
+      expect(Math.round(textExceed03.top - flexExceed01.top)).assertEqual(vp2px(30))
+      expect(textExceed01.top - textExceed03.top).assertEqual(textExceed03.bottom - textExceed01.bottom)
+      expect(textExceed02.top - textExceed03.top).assertEqual(textExceed03.bottom - textExceed02.bottom)
+
+      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(Math.round(vp2px(440/3)))
+      expect(Math.round(textExceed02.right - textExceed02.left)).assertEqual(Math.round(vp2px(440/3)))
+      expect(Math.round(textExceed03.right - textExceed03.left)).assertEqual(Math.round(vp2px(440/3)))
+      expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row')
+      expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.Baseline')
+      console.info('new testFlexItemAlignBaselineSetMarPadExceed END');
+      done();
+    });
+  })
+}

arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_Baseline/FlexHeightModifyJsunit.test.ets

+/*
+ * 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_BaselineJsunit() {
+  describe('flexItemAlignBaselineTest', function () {
+    beforeEach(async function (done) {
+      let options = {
+        uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/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_BASELINE_0800
+     * @tc.name      testFlexItemAlignBaselineDefaultSize
+     * @tc.desc      Modify the first subcomponent's height.
+     */
+    it('testFlexItemAlignBaselineDefaultSize', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineDefaultSize 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.left).assertEqual(flexHeightModify.left)
+      expect(textHeightModify02.left).assertEqual(textHeightModify01.right)
+      expect(textHeightModify03.left).assertEqual(textHeightModify02.right)
+
+      expect(textHeightModify01.top - textHeightModify03.top).assertEqual(textHeightModify03.bottom - textHeightModify01.bottom)
+      expect(textHeightModify02.top - textHeightModify03.top).assertEqual(textHeightModify03.bottom - textHeightModify02.bottom)
+
+      expect(Math.round(textHeightModify01.top - flexHeightModify.top)).assertEqual(vp2px(50))
+      expect(textHeightModify03.top).assertEqual(flexHeightModify.top)
+
+      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.Baseline')
+      console.info('new testFlexItemAlignBaselineDefaultSize END');
+      done();
+    });
+
+    /**
+     * @tc.number    SUB_ACE_FLEXALIGNITEMS_BASELINE_0900
+     * @tc.name      testFlexItemAlignBaselineHeightModify
+     * @tc.desc      Modify the first subcomponent's height.
+     */
+    it('testFlexItemAlignBaselineHeightModify', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineHeightModify 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.left).assertEqual(flexHeightModify.left)
+      expect(textHeightModify02.left).assertEqual(textHeightModify01.right)
+      expect(textHeightModify03.left).assertEqual(textHeightModify02.right)
+
+      expect(textHeightModify01.top - textHeightModify03.top).assertEqual(textHeightModify03.bottom - textHeightModify01.bottom)
+      expect(textHeightModify02.top - textHeightModify03.top).assertEqual(textHeightModify03.bottom - textHeightModify02.bottom)
+
+      expect(Math.round((textHeightModify01.top - flexHeightModify.top)*10)/10).assertEqual(Math.round(vp2px(35)*10)/10)
+      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.Baseline')
+      console.info('new testFlexItemAlignBaselineHeightModify END');
+      done();
+    });
+  })
+}

arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_Baseline/FlexMarginJsunit.test.ets

+/*
+ * 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";
+
+export default function flexMargin_BaselineJsunit() {
+  describe('flexItemAlignBaselineTest', function () {
+    beforeEach(async function (done) {
+      let options = {
+        uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/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_BASELINE_0500
+     * @tc.name      testItemAlignBaselineParentSetMargin
+     * @tc.desc      Parent component set margin attribute.
+     */
+    it('testItemAlignBaselineParentSetMargin', 0, async function (done) {
+      console.info('new testItemAlignBaselineParentSetMargin 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(Math.round(flexMargin.right - textFlexMargin03.right)).assertEqual(vp2px(50))
+
+      expect(textFlexMargin03.top).assertEqual(flexMargin.top)
+      expect(textFlexMargin01.top - textFlexMargin03.top).assertEqual(textFlexMargin03.bottom - textFlexMargin01.bottom)
+      expect(textFlexMargin02.top - textFlexMargin03.top).assertEqual(textFlexMargin03.bottom - textFlexMargin02.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.Baseline')
+      console.info('new testItemAlignBaselineParentSetMargin END');
+      done();
+    });
+  })
+}

arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_Baseline/FlexOffsetJsunit.test.ets

+/*
+ * 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";
+
+export default function flexOffset_BaselineJsunit() {
+  describe('flexItemAlignBaselineTest', function () {
+    beforeEach(async function (done) {
+      let options = {
+        uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/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_BASELINE_1000
+     * @tc.name      testFlexItemAlignBaselineSetOffset
+     * @tc.desc      First subcomponent set offset attribute.
+     */
+    it('testFlexItemAlignBaselineSetOffset', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineSetOffset 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(textOffset03.top).assertEqual(flexOffset.top)
+      expect(Math.round((textOffset01.right - textOffset02.left)*10)/10).assertEqual(Math.round(vp2px(15)*10)/10)
+      expect(textOffset02.right).assertEqual(textOffset03.left)
+      expect(Math.round(textOffset01.top - flexOffset.top)).assertEqual(vp2px(80))
+      expect(Math.round((textOffset01.left - flexOffset.left)*10)/10).assertEqual(Math.round(vp2px(15)*10)/10)
+      expect(textOffset02.top - textOffset03.top).assertEqual(textOffset03.bottom - textOffset02.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.Baseline')
+      console.info('new testFlexItemAlignBaselineSetOffset END');
+      done();
+    });
+  })
+}

arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_Baseline/FlexPaddingJsunit.test.ets

+/*
+ * 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_BaselineJsunit() {
+  describe('flexItemAlignBaselineTest', function () {
+    beforeEach(async function (done) {
+      let options = {
+        uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/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_BASELINE_0300
+     * @tc.name      testFlexItemAlignBaselineParentSetPadding
+     * @tc.desc      Parent component set paddding,subcomponent does not exceed the parent component.
+     */
+    it('testFlexItemAlignBaselineParentSetPadding', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineParentSetPadding START');
+      globalThis.value.message.notify({name:'padding', value:10});
+      await CommonFunc.sleep(2000);
+      let padddingValue = 10;
+      let strJson1 = getInspectorByKey('flexPadding01');
+      let obj1 = JSON.parse(strJson1);
+      let textFlexPadding01 = CommonFunc.getComponentRect('textFlexPadding01');
+      let textFlexPadding02 = CommonFunc.getComponentRect('textFlexPadding02');
+      let textFlexPadding03 = CommonFunc.getComponentRect('textFlexPadding03');
+      let flexPadding01 = CommonFunc.getComponentRect('flexPadding01');
+      expect(Math.round(textFlexPadding01.left - flexPadding01.left)).assertEqual(vp2px(10))
+      expect(textFlexPadding01.right).assertEqual(textFlexPadding02.left)
+      expect(textFlexPadding02.right).assertEqual(textFlexPadding03.left)
+      expect(Math.round(flexPadding01.right - textFlexPadding03.right)).assertEqual(vp2px(40))
+
+      expect(textFlexPadding03.top - flexPadding01.top).assertEqual(vp2px(padddingValue))
+      expect(textFlexPadding01.top - textFlexPadding03.top).assertEqual(textFlexPadding03.bottom - textFlexPadding01.bottom)
+      expect(textFlexPadding02.top - textFlexPadding03.top).assertEqual(textFlexPadding03.bottom - textFlexPadding02.bottom)
+
+      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.Baseline')
+      console.info('new testFlexItemAlignBaselineParentSetPadding END');
+      done();
+    });
+
+    /**
+     * @tc.number    SUB_ACE_FLEXALIGNITEMS_BASELINE_0400
+     * @tc.name      testFlexItemAlignBaselineParentSetPaddingExceed
+     * @tc.desc      Parent component set paddding,subcomponent exceedS the parent component.
+     */
+    it('testFlexItemAlignBaselineParentSetPaddingExceed', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineParentSetPaddingExceed START');
+      globalThis.value.message.notify({name:'padding', value:30});
+      await CommonFunc.sleep(2000);
+      let padddingValue = 30;
+      let strJson1 = getInspectorByKey('flexPadding01');
+      let obj1 = JSON.parse(strJson1);
+      let textFlexPadding01 = CommonFunc.getComponentRect('textFlexPadding01');
+      let textFlexPadding02 = CommonFunc.getComponentRect('textFlexPadding02');
+      let textFlexPadding03 = CommonFunc.getComponentRect('textFlexPadding03');
+      let flexPadding01 = CommonFunc.getComponentRect('flexPadding01');
+      expect(Math.round(textFlexPadding01.left - flexPadding01.left)).assertEqual(vp2px(30))
+      expect(textFlexPadding01.right).assertEqual(textFlexPadding02.left)
+      expect(textFlexPadding02.right).assertEqual(textFlexPadding03.left)
+      expect(Math.round(flexPadding01.right - textFlexPadding03.right)).assertEqual(vp2px(30))
+
+      expect(textFlexPadding03.top - flexPadding01.top).assertEqual(vp2px(padddingValue))
+      expect(textFlexPadding01.top - textFlexPadding03.top).assertEqual(textFlexPadding03.bottom - textFlexPadding01.bottom)
+      expect(textFlexPadding02.top - textFlexPadding03.top).assertEqual(textFlexPadding03.bottom - textFlexPadding02.bottom)
+
+      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(Math.round(vp2px(440/3)))
+      expect(Math.round(textFlexPadding02.right - textFlexPadding02.left)).assertEqual(Math.round(vp2px(440/3)))
+      expect(Math.round(textFlexPadding03.right - textFlexPadding03.left)).assertEqual(Math.round(vp2px(440/3)))
+      expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row')
+      expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.Baseline')
+      console.info('new testFlexItemAlignBaselineParentSetPaddingExceed END');
+      done();
+    });
+  })
+}

arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_Baseline/FlexTextMarginJsunit.test.ets

+/*
+ * 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_BaselineJsunit() {
+  describe('flexItemAlignBaselineTest', function () {
+    beforeEach(async function (done) {
+      let options = {
+        uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/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_BASELINE_1400
+     * @tc.name      testFlexItemAlignBaselineSubSetMargin
+     * @tc.desc      Subcomponents set margin within the scope of the parent component.
+     */
+    it('testFlexItemAlignBaselineSubSetMargin', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineSubSetMargin START');
+      globalThis.value.message.notify({name:'margin', value:10});
+      await CommonFunc.sleep(2000);
+      let marginValue = 10;
+      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(textMargin03.left).assertEqual(textMargin02.right)
+      expect(Math.round(flexTextMargin01.right - textMargin03.right)).assertEqual(vp2px(30))
+
+      expect(textMargin03.top).assertEqual(flexTextMargin01.top)
+      expect(textMargin01.top - textMargin03.top - vp2px(marginValue)).assertEqual(textMargin03.bottom - textMargin01.bottom + vp2px(marginValue))
+      expect(textMargin02.top - textMargin03.top).assertEqual(textMargin03.bottom - textMargin02.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.Baseline')
+      console.info('new testFlexItemAlignBaselineSubSetMargin END');
+      done();
+    });
+
+    /**
+     * @tc.number    SUB_ACE_FLEXALIGNITEMS_BASELINE_1500
+     * @tc.name      testFlexItemAlignBaselineSubSetMarginExceed
+     * @tc.desc      Subcomponents set margin outside the scope of the parent component.
+     */
+    it('testFlexItemAlignBaselineSubSetMarginExceed', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineSubSetMarginExceed START');
+      globalThis.value.message.notify({name:'margin', value:30});
+      await CommonFunc.sleep(2000);
+      let marginValue = 30;
+      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(textMargin03.left).assertEqual(textMargin02.right)
+      expect(textMargin03.right).assertEqual(flexTextMargin01.right)
+
+      expect(textMargin03.top).assertEqual(flexTextMargin01.top)
+      expect(textMargin01.top - textMargin03.top - vp2px(marginValue)).assertEqual(textMargin03.bottom - textMargin01.bottom + vp2px(marginValue))
+      expect(textMargin02.top - textMargin03.top).assertEqual(textMargin03.bottom - textMargin02.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(Math.round(vp2px(440/3)))
+      expect(Math.round(textMargin02.right - textMargin02.left)).assertEqual(Math.round(vp2px(440/3)))
+      expect(Math.round(textMargin03.right - textMargin03.left)).assertEqual(Math.round(vp2px(440/3)))
+      expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row')
+      expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.Baseline')
+      console.info('new testFlexItemAlignBaselineSubSetMarginExceed END');
+      done();
+    });
+  })
+}

arkui/ace_ets_layout_test/entry/src/main/ets/test/Flex/alignItems/ItemAlign_Baseline/FlexVisibilityJsunit.test.ets

+/*
+ * 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_BaselineJsunit() {
+  describe('flexItemAlignBaselineTest', function () {
+    beforeEach(async function (done) {
+      let options = {
+        uri: 'MainAbility/pages/Flex/alignItems/ItemAlign_Baseline/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(1000);
+      done()
+    });
+
+    afterEach(async function () {
+      await CommonFunc.sleep(1000);
+      console.info("FlexVisibility after each called");
+    });
+
+    /**
+     * @tc.number    SUB_ACE_FLEXALIGNITEMS_BASELINE_1100
+     * @tc.name      testFlexItemAlignBaselineSubSetVisibilityNone
+     * @tc.desc      The first subcomponent set Visibility.None attribute.
+     */
+    it('testFlexItemAlignBaselineSubSetVisibilityNone', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineSubSetVisibilityNone 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(textVisible03.top).assertEqual(flexVisible.top)
+          expect(textVisible01.left).assertEqual(flexVisible.left)
+          expect(textVisible01.right).assertEqual(textVisible02.left)
+          expect(textVisible02.right).assertEqual(textVisible03.left)
+
+          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(Math.round(flexVisible.right - textVisible03.right)).assertEqual(vp2px(200))
+
+          expect(textVisible02.top - textVisible03.top).assertEqual(textVisible03.bottom - textVisible02.bottom)
+          expect(obj1.$attrs.visibility).assertEqual("Visibility.Visible");
+          expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row')
+          expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.Baseline')
+       } catch (err) {
+          console.error('[testFlexItemAlignBaselineSubSetVisibilityNone] failed');
+          expect().assertFail();
+      }
+      console.info('new testFlexItemAlignBaselineSubSetVisibilityNone END');
+      done();
+    });
+
+    /**
+     * @tc.number    SUB_ACE_FLEXALIGNITEMS_BASELINE_1200
+     * @tc.name      testFlexItemAlignBaselineSubSetVisibilityHidden
+     * @tc.desc      The first subcomponent set Visibility.Hidden attribute.
+     */
+    it('testFlexItemAlignBaselineSubSetVisibilityHidden', 0, async function (done) {
+      console.info('new testFlexItemAlignBaselineSubSetVisibilityHidden 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(textVisible03.top).assertEqual(flexVisible.top)
+          expect(textVisible01.left).assertEqual(flexVisible.left)
+          expect(textVisible01.right).assertEqual(textVisible02.left)
+          expect(textVisible02.right).assertEqual(textVisible03.left)
+
+          expect(Math.round(textVisible01.bottom - textVisible01.top)).assertEqual(vp2px(50))
+          expect(Math.round(textVisible01.right - textVisible01.left)).assertEqual(vp2px(150))
+          expect(Math.round(textVisible02.bottom - textVisible02.top)).assertEqual(vp2px(100))
+          expect(Math.round(textVisible02.right - textVisible02.left)).assertEqual(vp2px(150))
+          expect(Math.round(textVisible03.bottom - textVisible03.top)).assertEqual(vp2px(150))
+          expect(Math.round(textVisible03.right - textVisible03.left)).assertEqual(vp2px(150))
+
+          expect(textVisible01.top - textVisible03.top).assertEqual(textVisible03.bottom - textVisible01.bottom)
+          expect(textVisible02.top - textVisible03.top).assertEqual(textVisible03.bottom - textVisible02.bottom)
+
+          expect(obj1.$attrs.constructor.direction).assertEqual('FlexDirection.Row')
+          expect(obj1.$attrs.constructor.alignItems).assertEqual('ItemAlign.Baseline')
+          expect(Math.round(flexVisible.right - textVisible03.right)).assertEqual(vp2px(50))
+       } catch (err) {
+          console.error('[testFlexItemAlignBaselineSubSetVisibilityHidden] failed');
+          expect().assertFail();
+      }
+      console.info('new testFlexItemAlignBaselineSubSetVisibilityHidden END');
+      done();
+    });
+  })
+}