| /******************************************************************************* |
| * Copyright (c) 2013 BSI Business Systems Integration AG. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * BSI Business Systems Integration AG - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.scout.sdk.internal.test.operation.formdata; |
| |
| import org.eclipse.jdt.core.IField; |
| import org.eclipse.jdt.core.IMethod; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.scout.sdk.testing.SdkAssert; |
| import org.eclipse.scout.sdk.testing.TestWorkspaceUtility; |
| import org.eclipse.scout.sdk.workspace.dto.formdata.FormDataDtoUpdateOperation; |
| import org.junit.Test; |
| |
| /** |
| * <h3>{@link TableFieldBeanTest}</h3> |
| * |
| * @author Andreas Hoegger |
| * @since 3.10.0 19.08.2013 |
| */ |
| public class TableFieldBeanTest extends AbstractSdkTestWithFormDataProject { |
| |
| public static final String AbstractAddressTableField = "formdata.client.ui.template.formfield.AbstractAddressTableField"; |
| public static final String TableFieldBaseForm = "formdata.client.ui.forms.replace.TableFieldBaseForm"; |
| public static final String TableFieldExForm = "formdata.client.ui.forms.replace.TableFieldExForm"; |
| |
| public static final String BaseWithExtendedTableForm = "formdata.client.ui.forms.BaseWithExtendedTableForm"; |
| public static final String ChildWithExtendedTableForm = "formdata.client.ui.forms.ChildWithExtendedTableForm"; |
| |
| private void createFormData(String typeName) throws Exception { |
| IType field = SdkAssert.assertTypeExists(typeName); |
| FormDataDtoUpdateOperation op = new FormDataDtoUpdateOperation(field); |
| TestWorkspaceUtility.executeAndBuildWorkspace(op); |
| } |
| |
| @Test |
| public void testFormData() throws Exception { |
| testAbstractTableField(); |
| testTableFieldBaseFormData(); |
| testTableFieldExFormData(); |
| testBaseWithExtendedTableFormData(); |
| testChildWithExtendedTableFormData(); |
| } |
| |
| private void testAbstractTableField() throws Exception { |
| createFormData(AbstractAddressTableField); |
| TestWorkspaceUtility.assertNoCompileErrors(); |
| testApiOfAbstractAddressTableFieldData(); |
| } |
| |
| private void testTableFieldBaseFormData() throws Exception { |
| createFormData(TableFieldBaseForm); |
| TestWorkspaceUtility.assertNoCompileErrors(); |
| testApiOfTableFieldBaseFormData(); |
| } |
| |
| private void testTableFieldExFormData() throws Exception { |
| createFormData(TableFieldExForm); |
| TestWorkspaceUtility.assertNoCompileErrors(); |
| testApiOfTableFieldExFormData(); |
| } |
| |
| private void testBaseWithExtendedTableFormData() throws Exception { |
| createFormData(BaseWithExtendedTableForm); |
| TestWorkspaceUtility.assertNoCompileErrors(); |
| testApiOfBaseWithExtendedTableFormData(); |
| } |
| |
| private void testChildWithExtendedTableFormData() throws Exception { |
| createFormData(ChildWithExtendedTableForm); |
| TestWorkspaceUtility.assertNoCompileErrors(); |
| testApiOfChildWithExtendedTableFormData(); |
| } |
| |
| /** |
| * @Generated with org.eclipse.scout.sdk.testing.codegen.ApiTestGenerator |
| */ |
| private void testApiOfAbstractAddressTableFieldData() throws Exception { |
| // type AbstractAddressTableFieldData |
| IType abstractAddressTableFieldData = SdkAssert.assertTypeExists("formdata.shared.services.process.AbstractAddressTableFieldData"); |
| SdkAssert.assertHasFlags(abstractAddressTableFieldData, 1025); |
| SdkAssert.assertHasSuperTypeSignature(abstractAddressTableFieldData, "QAbstractTableFieldBeanData;"); |
| |
| // fields of AbstractAddressTableFieldData |
| SdkAssert.assertEquals("field count of 'AbstractAddressTableFieldData'", 1, abstractAddressTableFieldData.getFields().length); |
| IField serialVersionUID = SdkAssert.assertFieldExist(abstractAddressTableFieldData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID, "J"); |
| |
| SdkAssert.assertEquals("method count of 'AbstractAddressTableFieldData'", 8, abstractAddressTableFieldData.getMethods().length); |
| IMethod abstractAddressTableFieldData1 = SdkAssert.assertMethodExist(abstractAddressTableFieldData, "AbstractAddressTableFieldData", new String[]{}); |
| SdkAssert.assertTrue(abstractAddressTableFieldData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(abstractAddressTableFieldData1, "V"); |
| IMethod addRow = SdkAssert.assertMethodExist(abstractAddressTableFieldData, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow, "QAbstractAddressTableRowData;"); |
| SdkAssert.assertAnnotation(addRow, "java.lang.Override"); |
| IMethod addRow1 = SdkAssert.assertMethodExist(abstractAddressTableFieldData, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow1, "QAbstractAddressTableRowData;"); |
| SdkAssert.assertAnnotation(addRow1, "java.lang.Override"); |
| IMethod createRow = SdkAssert.assertMethodExist(abstractAddressTableFieldData, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow, "QAbstractAddressTableRowData;"); |
| SdkAssert.assertAnnotation(createRow, "java.lang.Override"); |
| IMethod getRowType = SdkAssert.assertMethodExist(abstractAddressTableFieldData, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType, "java.lang.Override"); |
| IMethod getRows = SdkAssert.assertMethodExist(abstractAddressTableFieldData, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows, "[QAbstractAddressTableRowData;"); |
| SdkAssert.assertAnnotation(getRows, "java.lang.Override"); |
| IMethod rowAt = SdkAssert.assertMethodExist(abstractAddressTableFieldData, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt, "QAbstractAddressTableRowData;"); |
| SdkAssert.assertAnnotation(rowAt, "java.lang.Override"); |
| IMethod setRows = SdkAssert.assertMethodExist(abstractAddressTableFieldData, "setRows", new String[]{"[QAbstractAddressTableRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'AbstractAddressTableFieldData'", 1, abstractAddressTableFieldData.getTypes().length); |
| // type AbstractAddressTableRowData |
| IType abstractAddressTableRowData = SdkAssert.assertTypeExists(abstractAddressTableFieldData, "AbstractAddressTableRowData"); |
| SdkAssert.assertHasFlags(abstractAddressTableRowData, 1033); |
| SdkAssert.assertHasSuperTypeSignature(abstractAddressTableRowData, "QAbstractTableRowData;"); |
| |
| // fields of AbstractAddressTableRowData |
| SdkAssert.assertEquals("field count of 'AbstractAddressTableRowData'", 7, abstractAddressTableRowData.getFields().length); |
| IField serialVersionUID1 = SdkAssert.assertFieldExist(abstractAddressTableRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID1, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID1, "J"); |
| IField addressId = SdkAssert.assertFieldExist(abstractAddressTableRowData, "addressId"); |
| SdkAssert.assertHasFlags(addressId, 25); |
| SdkAssert.assertFieldSignature(addressId, "QString;"); |
| IField street = SdkAssert.assertFieldExist(abstractAddressTableRowData, "street"); |
| SdkAssert.assertHasFlags(street, 25); |
| SdkAssert.assertFieldSignature(street, "QString;"); |
| IField poBoxAddress = SdkAssert.assertFieldExist(abstractAddressTableRowData, "poBoxAddress"); |
| SdkAssert.assertHasFlags(poBoxAddress, 25); |
| SdkAssert.assertFieldSignature(poBoxAddress, "QString;"); |
| IField m_addressId = SdkAssert.assertFieldExist(abstractAddressTableRowData, "m_addressId"); |
| SdkAssert.assertHasFlags(m_addressId, 2); |
| SdkAssert.assertFieldSignature(m_addressId, "QString;"); |
| IField m_street = SdkAssert.assertFieldExist(abstractAddressTableRowData, "m_street"); |
| SdkAssert.assertHasFlags(m_street, 2); |
| SdkAssert.assertFieldSignature(m_street, "QString;"); |
| IField m_poBoxAddress = SdkAssert.assertFieldExist(abstractAddressTableRowData, "m_poBoxAddress"); |
| SdkAssert.assertHasFlags(m_poBoxAddress, 2); |
| SdkAssert.assertFieldSignature(m_poBoxAddress, "QBoolean;"); |
| |
| SdkAssert.assertEquals("method count of 'AbstractAddressTableRowData'", 7, abstractAddressTableRowData.getMethods().length); |
| IMethod abstractAddressTableRowData1 = SdkAssert.assertMethodExist(abstractAddressTableRowData, "AbstractAddressTableRowData", new String[]{}); |
| SdkAssert.assertTrue(abstractAddressTableRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(abstractAddressTableRowData1, "V"); |
| IMethod getAddressId = SdkAssert.assertMethodExist(abstractAddressTableRowData, "getAddressId", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getAddressId, "QString;"); |
| IMethod setAddressId = SdkAssert.assertMethodExist(abstractAddressTableRowData, "setAddressId", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setAddressId, "V"); |
| IMethod getStreet = SdkAssert.assertMethodExist(abstractAddressTableRowData, "getStreet", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getStreet, "QString;"); |
| IMethod setStreet = SdkAssert.assertMethodExist(abstractAddressTableRowData, "setStreet", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setStreet, "V"); |
| IMethod getPoBoxAddress = SdkAssert.assertMethodExist(abstractAddressTableRowData, "getPoBoxAddress", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getPoBoxAddress, "QBoolean;"); |
| IMethod setPoBoxAddress = SdkAssert.assertMethodExist(abstractAddressTableRowData, "setPoBoxAddress", new String[]{"QBoolean;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setPoBoxAddress, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'AbstractAddressTableRowData'", 0, abstractAddressTableRowData.getTypes().length); |
| } |
| |
| /** |
| * @Generated with org.eclipse.scout.sdk.testing.codegen.ApiTestGenerator |
| */ |
| private void testApiOfTableFieldBaseFormData() throws Exception { |
| // type TableFieldBaseFormData |
| IType tableFieldBaseFormData = SdkAssert.assertTypeExists("formdata.shared.services.process.replace.TableFieldBaseFormData"); |
| SdkAssert.assertHasFlags(tableFieldBaseFormData, 1); |
| SdkAssert.assertHasSuperTypeSignature(tableFieldBaseFormData, "QAbstractFormData;"); |
| |
| // fields of TableFieldBaseFormData |
| SdkAssert.assertEquals("field count of 'TableFieldBaseFormData'", 1, tableFieldBaseFormData.getFields().length); |
| IField serialVersionUID = SdkAssert.assertFieldExist(tableFieldBaseFormData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID, "J"); |
| |
| SdkAssert.assertEquals("method count of 'TableFieldBaseFormData'", 6, tableFieldBaseFormData.getMethods().length); |
| IMethod tableFieldBaseFormData1 = SdkAssert.assertMethodExist(tableFieldBaseFormData, "TableFieldBaseFormData", new String[]{}); |
| SdkAssert.assertTrue(tableFieldBaseFormData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(tableFieldBaseFormData1, "V"); |
| IMethod getAddressTable = SdkAssert.assertMethodExist(tableFieldBaseFormData, "getAddressTable", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getAddressTable, "QAddressTable;"); |
| IMethod getEmptyTable = SdkAssert.assertMethodExist(tableFieldBaseFormData, "getEmptyTable", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getEmptyTable, "QEmptyTable;"); |
| IMethod getNoTable = SdkAssert.assertMethodExist(tableFieldBaseFormData, "getNoTable", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getNoTable, "QNoTable;"); |
| IMethod getPersonTable = SdkAssert.assertMethodExist(tableFieldBaseFormData, "getPersonTable", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getPersonTable, "QPersonTable;"); |
| IMethod getTable = SdkAssert.assertMethodExist(tableFieldBaseFormData, "getTable", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getTable, "QTable;"); |
| |
| SdkAssert.assertEquals("inner types count of 'TableFieldBaseFormData'", 5, tableFieldBaseFormData.getTypes().length); |
| // type AddressTable |
| IType addressTable = SdkAssert.assertTypeExists(tableFieldBaseFormData, "AddressTable"); |
| SdkAssert.assertHasFlags(addressTable, 9); |
| SdkAssert.assertHasSuperTypeSignature(addressTable, "QAbstractAddressTableFieldData;"); |
| |
| // fields of AddressTable |
| SdkAssert.assertEquals("field count of 'AddressTable'", 1, addressTable.getFields().length); |
| IField serialVersionUID1 = SdkAssert.assertFieldExist(addressTable, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID1, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID1, "J"); |
| |
| SdkAssert.assertEquals("method count of 'AddressTable'", 8, addressTable.getMethods().length); |
| IMethod addressTable1 = SdkAssert.assertMethodExist(addressTable, "AddressTable", new String[]{}); |
| SdkAssert.assertTrue(addressTable1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(addressTable1, "V"); |
| IMethod addRow = SdkAssert.assertMethodExist(addressTable, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow, "QAddressTableRowData;"); |
| SdkAssert.assertAnnotation(addRow, "java.lang.Override"); |
| IMethod addRow1 = SdkAssert.assertMethodExist(addressTable, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow1, "QAddressTableRowData;"); |
| SdkAssert.assertAnnotation(addRow1, "java.lang.Override"); |
| IMethod createRow = SdkAssert.assertMethodExist(addressTable, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow, "QAddressTableRowData;"); |
| SdkAssert.assertAnnotation(createRow, "java.lang.Override"); |
| IMethod getRowType = SdkAssert.assertMethodExist(addressTable, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType, "java.lang.Override"); |
| IMethod getRows = SdkAssert.assertMethodExist(addressTable, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows, "[QAddressTableRowData;"); |
| SdkAssert.assertAnnotation(getRows, "java.lang.Override"); |
| IMethod rowAt = SdkAssert.assertMethodExist(addressTable, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt, "QAddressTableRowData;"); |
| SdkAssert.assertAnnotation(rowAt, "java.lang.Override"); |
| IMethod setRows = SdkAssert.assertMethodExist(addressTable, "setRows", new String[]{"[QAddressTableRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'AddressTable'", 1, addressTable.getTypes().length); |
| // type AddressTableRowData |
| IType addressTableRowData = SdkAssert.assertTypeExists(addressTable, "AddressTableRowData"); |
| SdkAssert.assertHasFlags(addressTableRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(addressTableRowData, "QAbstractAddressTableRowData;"); |
| |
| // fields of AddressTableRowData |
| SdkAssert.assertEquals("field count of 'AddressTableRowData'", 3, addressTableRowData.getFields().length); |
| IField serialVersionUID2 = SdkAssert.assertFieldExist(addressTableRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID2, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID2, "J"); |
| IField city = SdkAssert.assertFieldExist(addressTableRowData, "city"); |
| SdkAssert.assertHasFlags(city, 25); |
| SdkAssert.assertFieldSignature(city, "QString;"); |
| IField m_city = SdkAssert.assertFieldExist(addressTableRowData, "m_city"); |
| SdkAssert.assertHasFlags(m_city, 2); |
| SdkAssert.assertFieldSignature(m_city, "QString;"); |
| |
| SdkAssert.assertEquals("method count of 'AddressTableRowData'", 3, addressTableRowData.getMethods().length); |
| IMethod addressTableRowData1 = SdkAssert.assertMethodExist(addressTableRowData, "AddressTableRowData", new String[]{}); |
| SdkAssert.assertTrue(addressTableRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(addressTableRowData1, "V"); |
| IMethod getCity = SdkAssert.assertMethodExist(addressTableRowData, "getCity", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getCity, "QString;"); |
| IMethod setCity = SdkAssert.assertMethodExist(addressTableRowData, "setCity", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setCity, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'AddressTableRowData'", 0, addressTableRowData.getTypes().length); |
| // type EmptyTable |
| IType emptyTable = SdkAssert.assertTypeExists(tableFieldBaseFormData, "EmptyTable"); |
| SdkAssert.assertHasFlags(emptyTable, 9); |
| SdkAssert.assertHasSuperTypeSignature(emptyTable, "QAbstractTableFieldBeanData;"); |
| |
| // fields of EmptyTable |
| SdkAssert.assertEquals("field count of 'EmptyTable'", 1, emptyTable.getFields().length); |
| IField serialVersionUID3 = SdkAssert.assertFieldExist(emptyTable, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID3, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID3, "J"); |
| |
| SdkAssert.assertEquals("method count of 'EmptyTable'", 8, emptyTable.getMethods().length); |
| IMethod emptyTable1 = SdkAssert.assertMethodExist(emptyTable, "EmptyTable", new String[]{}); |
| SdkAssert.assertTrue(emptyTable1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(emptyTable1, "V"); |
| IMethod addRow2 = SdkAssert.assertMethodExist(emptyTable, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow2, "QEmptyTableRowData;"); |
| SdkAssert.assertAnnotation(addRow2, "java.lang.Override"); |
| IMethod addRow3 = SdkAssert.assertMethodExist(emptyTable, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow3, "QEmptyTableRowData;"); |
| SdkAssert.assertAnnotation(addRow3, "java.lang.Override"); |
| IMethod createRow1 = SdkAssert.assertMethodExist(emptyTable, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow1, "QEmptyTableRowData;"); |
| SdkAssert.assertAnnotation(createRow1, "java.lang.Override"); |
| IMethod getRowType1 = SdkAssert.assertMethodExist(emptyTable, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType1, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType1, "java.lang.Override"); |
| IMethod getRows1 = SdkAssert.assertMethodExist(emptyTable, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows1, "[QEmptyTableRowData;"); |
| SdkAssert.assertAnnotation(getRows1, "java.lang.Override"); |
| IMethod rowAt1 = SdkAssert.assertMethodExist(emptyTable, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt1, "QEmptyTableRowData;"); |
| SdkAssert.assertAnnotation(rowAt1, "java.lang.Override"); |
| IMethod setRows1 = SdkAssert.assertMethodExist(emptyTable, "setRows", new String[]{"[QEmptyTableRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows1, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'EmptyTable'", 1, emptyTable.getTypes().length); |
| // type EmptyTableRowData |
| IType emptyTableRowData = SdkAssert.assertTypeExists(emptyTable, "EmptyTableRowData"); |
| SdkAssert.assertHasFlags(emptyTableRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(emptyTableRowData, "QAbstractTableRowData;"); |
| |
| // fields of EmptyTableRowData |
| SdkAssert.assertEquals("field count of 'EmptyTableRowData'", 1, emptyTableRowData.getFields().length); |
| IField serialVersionUID4 = SdkAssert.assertFieldExist(emptyTableRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID4, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID4, "J"); |
| |
| SdkAssert.assertEquals("method count of 'EmptyTableRowData'", 1, emptyTableRowData.getMethods().length); |
| IMethod emptyTableRowData1 = SdkAssert.assertMethodExist(emptyTableRowData, "EmptyTableRowData", new String[]{}); |
| SdkAssert.assertTrue(emptyTableRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(emptyTableRowData1, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'EmptyTableRowData'", 0, emptyTableRowData.getTypes().length); |
| // type NoTable |
| IType noTable = SdkAssert.assertTypeExists(tableFieldBaseFormData, "NoTable"); |
| SdkAssert.assertHasFlags(noTable, 9); |
| SdkAssert.assertHasSuperTypeSignature(noTable, "QAbstractTableFieldBeanData;"); |
| |
| // fields of NoTable |
| SdkAssert.assertEquals("field count of 'NoTable'", 1, noTable.getFields().length); |
| IField serialVersionUID5 = SdkAssert.assertFieldExist(noTable, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID5, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID5, "J"); |
| |
| SdkAssert.assertEquals("method count of 'NoTable'", 3, noTable.getMethods().length); |
| IMethod noTable1 = SdkAssert.assertMethodExist(noTable, "NoTable", new String[]{}); |
| SdkAssert.assertTrue(noTable1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(noTable1, "V"); |
| IMethod createRow2 = SdkAssert.assertMethodExist(noTable, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow2, "QAbstractTableRowData;"); |
| SdkAssert.assertAnnotation(createRow2, "java.lang.Override"); |
| IMethod getRowType2 = SdkAssert.assertMethodExist(noTable, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType2, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType2, "java.lang.Override"); |
| |
| SdkAssert.assertEquals("inner types count of 'NoTable'", 0, noTable.getTypes().length); |
| // type PersonTable |
| IType personTable = SdkAssert.assertTypeExists(tableFieldBaseFormData, "PersonTable"); |
| SdkAssert.assertHasFlags(personTable, 9); |
| SdkAssert.assertHasSuperTypeSignature(personTable, "QAbstractPersonTableFieldData;"); |
| |
| // fields of PersonTable |
| SdkAssert.assertEquals("field count of 'PersonTable'", 1, personTable.getFields().length); |
| IField serialVersionUID6 = SdkAssert.assertFieldExist(personTable, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID6, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID6, "J"); |
| |
| SdkAssert.assertEquals("method count of 'PersonTable'", 8, personTable.getMethods().length); |
| IMethod personTable1 = SdkAssert.assertMethodExist(personTable, "PersonTable", new String[]{}); |
| SdkAssert.assertTrue(personTable1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(personTable1, "V"); |
| IMethod addRow4 = SdkAssert.assertMethodExist(personTable, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow4, "QPersonTableRowData;"); |
| SdkAssert.assertAnnotation(addRow4, "java.lang.Override"); |
| IMethod addRow5 = SdkAssert.assertMethodExist(personTable, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow5, "QPersonTableRowData;"); |
| SdkAssert.assertAnnotation(addRow5, "java.lang.Override"); |
| IMethod createRow3 = SdkAssert.assertMethodExist(personTable, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow3, "QPersonTableRowData;"); |
| SdkAssert.assertAnnotation(createRow3, "java.lang.Override"); |
| IMethod getRowType3 = SdkAssert.assertMethodExist(personTable, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType3, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType3, "java.lang.Override"); |
| IMethod getRows2 = SdkAssert.assertMethodExist(personTable, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows2, "[QPersonTableRowData;"); |
| SdkAssert.assertAnnotation(getRows2, "java.lang.Override"); |
| IMethod rowAt2 = SdkAssert.assertMethodExist(personTable, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt2, "QPersonTableRowData;"); |
| SdkAssert.assertAnnotation(rowAt2, "java.lang.Override"); |
| IMethod setRows2 = SdkAssert.assertMethodExist(personTable, "setRows", new String[]{"[QPersonTableRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows2, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'PersonTable'", 1, personTable.getTypes().length); |
| // type PersonTableRowData |
| IType personTableRowData = SdkAssert.assertTypeExists(personTable, "PersonTableRowData"); |
| SdkAssert.assertHasFlags(personTableRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(personTableRowData, "QAbstractPersonTableRowData;"); |
| |
| // fields of PersonTableRowData |
| SdkAssert.assertEquals("field count of 'PersonTableRowData'", 1, personTableRowData.getFields().length); |
| IField serialVersionUID7 = SdkAssert.assertFieldExist(personTableRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID7, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID7, "J"); |
| |
| SdkAssert.assertEquals("method count of 'PersonTableRowData'", 1, personTableRowData.getMethods().length); |
| IMethod personTableRowData1 = SdkAssert.assertMethodExist(personTableRowData, "PersonTableRowData", new String[]{}); |
| SdkAssert.assertTrue(personTableRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(personTableRowData1, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'PersonTableRowData'", 0, personTableRowData.getTypes().length); |
| // type Table |
| IType table = SdkAssert.assertTypeExists(tableFieldBaseFormData, "Table"); |
| SdkAssert.assertHasFlags(table, 9); |
| SdkAssert.assertHasSuperTypeSignature(table, "QAbstractTableFieldBeanData;"); |
| |
| // fields of Table |
| SdkAssert.assertEquals("field count of 'Table'", 1, table.getFields().length); |
| IField serialVersionUID8 = SdkAssert.assertFieldExist(table, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID8, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID8, "J"); |
| |
| SdkAssert.assertEquals("method count of 'Table'", 8, table.getMethods().length); |
| IMethod table1 = SdkAssert.assertMethodExist(table, "Table", new String[]{}); |
| SdkAssert.assertTrue(table1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(table1, "V"); |
| IMethod addRow6 = SdkAssert.assertMethodExist(table, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow6, "QTableRowData;"); |
| SdkAssert.assertAnnotation(addRow6, "java.lang.Override"); |
| IMethod addRow7 = SdkAssert.assertMethodExist(table, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow7, "QTableRowData;"); |
| SdkAssert.assertAnnotation(addRow7, "java.lang.Override"); |
| IMethod createRow4 = SdkAssert.assertMethodExist(table, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow4, "QTableRowData;"); |
| SdkAssert.assertAnnotation(createRow4, "java.lang.Override"); |
| IMethod getRowType4 = SdkAssert.assertMethodExist(table, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType4, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType4, "java.lang.Override"); |
| IMethod getRows3 = SdkAssert.assertMethodExist(table, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows3, "[QTableRowData;"); |
| SdkAssert.assertAnnotation(getRows3, "java.lang.Override"); |
| IMethod rowAt3 = SdkAssert.assertMethodExist(table, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt3, "QTableRowData;"); |
| SdkAssert.assertAnnotation(rowAt3, "java.lang.Override"); |
| IMethod setRows3 = SdkAssert.assertMethodExist(table, "setRows", new String[]{"[QTableRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows3, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'Table'", 1, table.getTypes().length); |
| // type TableRowData |
| IType tableRowData = SdkAssert.assertTypeExists(table, "TableRowData"); |
| SdkAssert.assertHasFlags(tableRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(tableRowData, "QAbstractTableRowData;"); |
| |
| // fields of TableRowData |
| SdkAssert.assertEquals("field count of 'TableRowData'", 5, tableRowData.getFields().length); |
| IField serialVersionUID9 = SdkAssert.assertFieldExist(tableRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID9, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID9, "J"); |
| IField first = SdkAssert.assertFieldExist(tableRowData, "first"); |
| SdkAssert.assertHasFlags(first, 25); |
| SdkAssert.assertFieldSignature(first, "QString;"); |
| IField second = SdkAssert.assertFieldExist(tableRowData, "second"); |
| SdkAssert.assertHasFlags(second, 25); |
| SdkAssert.assertFieldSignature(second, "QString;"); |
| IField m_first = SdkAssert.assertFieldExist(tableRowData, "m_first"); |
| SdkAssert.assertHasFlags(m_first, 2); |
| SdkAssert.assertFieldSignature(m_first, "QString;"); |
| IField m_second = SdkAssert.assertFieldExist(tableRowData, "m_second"); |
| SdkAssert.assertHasFlags(m_second, 2); |
| SdkAssert.assertFieldSignature(m_second, "QString;"); |
| |
| SdkAssert.assertEquals("method count of 'TableRowData'", 5, tableRowData.getMethods().length); |
| IMethod tableRowData1 = SdkAssert.assertMethodExist(tableRowData, "TableRowData", new String[]{}); |
| SdkAssert.assertTrue(tableRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(tableRowData1, "V"); |
| IMethod getFirst = SdkAssert.assertMethodExist(tableRowData, "getFirst", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getFirst, "QString;"); |
| IMethod setFirst = SdkAssert.assertMethodExist(tableRowData, "setFirst", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setFirst, "V"); |
| IMethod getSecond = SdkAssert.assertMethodExist(tableRowData, "getSecond", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getSecond, "QString;"); |
| IMethod setSecond = SdkAssert.assertMethodExist(tableRowData, "setSecond", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setSecond, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'TableRowData'", 0, tableRowData.getTypes().length); |
| } |
| |
| /** |
| * @Generated with org.eclipse.scout.sdk.testing.codegen.ApiTestGenerator |
| */ |
| private void testApiOfTableFieldExFormData() throws Exception { |
| // type TableFieldExFormData |
| IType tableFieldExFormData = SdkAssert.assertTypeExists("formdata.shared.services.process.replace.TableFieldExFormData"); |
| SdkAssert.assertHasFlags(tableFieldExFormData, 1); |
| SdkAssert.assertHasSuperTypeSignature(tableFieldExFormData, "QTableFieldBaseFormData;"); |
| |
| // fields of TableFieldExFormData |
| SdkAssert.assertEquals("field count of 'TableFieldExFormData'", 1, tableFieldExFormData.getFields().length); |
| IField serialVersionUID = SdkAssert.assertFieldExist(tableFieldExFormData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID, "J"); |
| |
| SdkAssert.assertEquals("method count of 'TableFieldExFormData'", 6, tableFieldExFormData.getMethods().length); |
| IMethod tableFieldExFormData1 = SdkAssert.assertMethodExist(tableFieldExFormData, "TableFieldExFormData", new String[]{}); |
| SdkAssert.assertTrue(tableFieldExFormData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(tableFieldExFormData1, "V"); |
| IMethod getEmptyTableExtended = SdkAssert.assertMethodExist(tableFieldExFormData, "getEmptyTableExtended", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getEmptyTableExtended, "QEmptyTableExtended;"); |
| IMethod getExtendedAddress = SdkAssert.assertMethodExist(tableFieldExFormData, "getExtendedAddress", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getExtendedAddress, "QExtendedAddress;"); |
| IMethod getExtendedPersonTable = SdkAssert.assertMethodExist(tableFieldExFormData, "getExtendedPersonTable", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getExtendedPersonTable, "QExtendedPersonTable;"); |
| IMethod getNoTableExtended = SdkAssert.assertMethodExist(tableFieldExFormData, "getNoTableExtended", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getNoTableExtended, "QNoTableExtended;"); |
| IMethod getTableExtended = SdkAssert.assertMethodExist(tableFieldExFormData, "getTableExtended", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getTableExtended, "QTableExtended;"); |
| |
| SdkAssert.assertEquals("inner types count of 'TableFieldExFormData'", 5, tableFieldExFormData.getTypes().length); |
| // type EmptyTableExtended |
| IType emptyTableExtended = SdkAssert.assertTypeExists(tableFieldExFormData, "EmptyTableExtended"); |
| SdkAssert.assertHasFlags(emptyTableExtended, 9); |
| SdkAssert.assertHasSuperTypeSignature(emptyTableExtended, "QEmptyTable;"); |
| SdkAssert.assertAnnotation(emptyTableExtended, "org.eclipse.scout.commons.annotations.Replace"); |
| |
| // fields of EmptyTableExtended |
| SdkAssert.assertEquals("field count of 'EmptyTableExtended'", 1, emptyTableExtended.getFields().length); |
| IField serialVersionUID1 = SdkAssert.assertFieldExist(emptyTableExtended, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID1, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID1, "J"); |
| |
| SdkAssert.assertEquals("method count of 'EmptyTableExtended'", 8, emptyTableExtended.getMethods().length); |
| IMethod emptyTableExtended1 = SdkAssert.assertMethodExist(emptyTableExtended, "EmptyTableExtended", new String[]{}); |
| SdkAssert.assertTrue(emptyTableExtended1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(emptyTableExtended1, "V"); |
| IMethod addRow = SdkAssert.assertMethodExist(emptyTableExtended, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow, "QEmptyTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(addRow, "java.lang.Override"); |
| IMethod addRow1 = SdkAssert.assertMethodExist(emptyTableExtended, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow1, "QEmptyTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(addRow1, "java.lang.Override"); |
| IMethod createRow = SdkAssert.assertMethodExist(emptyTableExtended, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow, "QEmptyTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(createRow, "java.lang.Override"); |
| IMethod getRowType = SdkAssert.assertMethodExist(emptyTableExtended, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType, "java.lang.Override"); |
| IMethod getRows = SdkAssert.assertMethodExist(emptyTableExtended, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows, "[QEmptyTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(getRows, "java.lang.Override"); |
| IMethod rowAt = SdkAssert.assertMethodExist(emptyTableExtended, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt, "QEmptyTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(rowAt, "java.lang.Override"); |
| IMethod setRows = SdkAssert.assertMethodExist(emptyTableExtended, "setRows", new String[]{"[QEmptyTableExtendedRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'EmptyTableExtended'", 1, emptyTableExtended.getTypes().length); |
| // type EmptyTableExtendedRowData |
| IType emptyTableExtendedRowData = SdkAssert.assertTypeExists(emptyTableExtended, "EmptyTableExtendedRowData"); |
| SdkAssert.assertHasFlags(emptyTableExtendedRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(emptyTableExtendedRowData, "QEmptyTableRowData;"); |
| |
| // fields of EmptyTableExtendedRowData |
| SdkAssert.assertEquals("field count of 'EmptyTableExtendedRowData'", 3, emptyTableExtendedRowData.getFields().length); |
| IField serialVersionUID2 = SdkAssert.assertFieldExist(emptyTableExtendedRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID2, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID2, "J"); |
| IField single = SdkAssert.assertFieldExist(emptyTableExtendedRowData, "single"); |
| SdkAssert.assertHasFlags(single, 25); |
| SdkAssert.assertFieldSignature(single, "QString;"); |
| IField m_single = SdkAssert.assertFieldExist(emptyTableExtendedRowData, "m_single"); |
| SdkAssert.assertHasFlags(m_single, 2); |
| SdkAssert.assertFieldSignature(m_single, "QString;"); |
| |
| SdkAssert.assertEquals("method count of 'EmptyTableExtendedRowData'", 3, emptyTableExtendedRowData.getMethods().length); |
| IMethod emptyTableExtendedRowData1 = SdkAssert.assertMethodExist(emptyTableExtendedRowData, "EmptyTableExtendedRowData", new String[]{}); |
| SdkAssert.assertTrue(emptyTableExtendedRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(emptyTableExtendedRowData1, "V"); |
| IMethod getSingle = SdkAssert.assertMethodExist(emptyTableExtendedRowData, "getSingle", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getSingle, "QString;"); |
| IMethod setSingle = SdkAssert.assertMethodExist(emptyTableExtendedRowData, "setSingle", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setSingle, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'EmptyTableExtendedRowData'", 0, emptyTableExtendedRowData.getTypes().length); |
| // type ExtendedAddress |
| IType extendedAddress = SdkAssert.assertTypeExists(tableFieldExFormData, "ExtendedAddress"); |
| SdkAssert.assertHasFlags(extendedAddress, 9); |
| SdkAssert.assertHasSuperTypeSignature(extendedAddress, "QAddressTable;"); |
| SdkAssert.assertAnnotation(extendedAddress, "org.eclipse.scout.commons.annotations.Replace"); |
| |
| // fields of ExtendedAddress |
| SdkAssert.assertEquals("field count of 'ExtendedAddress'", 1, extendedAddress.getFields().length); |
| IField serialVersionUID3 = SdkAssert.assertFieldExist(extendedAddress, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID3, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID3, "J"); |
| |
| SdkAssert.assertEquals("method count of 'ExtendedAddress'", 8, extendedAddress.getMethods().length); |
| IMethod extendedAddress1 = SdkAssert.assertMethodExist(extendedAddress, "ExtendedAddress", new String[]{}); |
| SdkAssert.assertTrue(extendedAddress1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(extendedAddress1, "V"); |
| IMethod addRow2 = SdkAssert.assertMethodExist(extendedAddress, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow2, "QExtendedAddressRowData;"); |
| SdkAssert.assertAnnotation(addRow2, "java.lang.Override"); |
| IMethod addRow3 = SdkAssert.assertMethodExist(extendedAddress, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow3, "QExtendedAddressRowData;"); |
| SdkAssert.assertAnnotation(addRow3, "java.lang.Override"); |
| IMethod createRow1 = SdkAssert.assertMethodExist(extendedAddress, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow1, "QExtendedAddressRowData;"); |
| SdkAssert.assertAnnotation(createRow1, "java.lang.Override"); |
| IMethod getRowType1 = SdkAssert.assertMethodExist(extendedAddress, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType1, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType1, "java.lang.Override"); |
| IMethod getRows1 = SdkAssert.assertMethodExist(extendedAddress, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows1, "[QExtendedAddressRowData;"); |
| SdkAssert.assertAnnotation(getRows1, "java.lang.Override"); |
| IMethod rowAt1 = SdkAssert.assertMethodExist(extendedAddress, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt1, "QExtendedAddressRowData;"); |
| SdkAssert.assertAnnotation(rowAt1, "java.lang.Override"); |
| IMethod setRows1 = SdkAssert.assertMethodExist(extendedAddress, "setRows", new String[]{"[QExtendedAddressRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows1, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'ExtendedAddress'", 1, extendedAddress.getTypes().length); |
| // type ExtendedAddressRowData |
| IType extendedAddressRowData = SdkAssert.assertTypeExists(extendedAddress, "ExtendedAddressRowData"); |
| SdkAssert.assertHasFlags(extendedAddressRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(extendedAddressRowData, "QAddressTableRowData;"); |
| |
| // fields of ExtendedAddressRowData |
| SdkAssert.assertEquals("field count of 'ExtendedAddressRowData'", 3, extendedAddressRowData.getFields().length); |
| IField serialVersionUID4 = SdkAssert.assertFieldExist(extendedAddressRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID4, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID4, "J"); |
| IField state = SdkAssert.assertFieldExist(extendedAddressRowData, "state"); |
| SdkAssert.assertHasFlags(state, 25); |
| SdkAssert.assertFieldSignature(state, "QString;"); |
| IField m_state = SdkAssert.assertFieldExist(extendedAddressRowData, "m_state"); |
| SdkAssert.assertHasFlags(m_state, 2); |
| SdkAssert.assertFieldSignature(m_state, "QString;"); |
| |
| SdkAssert.assertEquals("method count of 'ExtendedAddressRowData'", 3, extendedAddressRowData.getMethods().length); |
| IMethod extendedAddressRowData1 = SdkAssert.assertMethodExist(extendedAddressRowData, "ExtendedAddressRowData", new String[]{}); |
| SdkAssert.assertTrue(extendedAddressRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(extendedAddressRowData1, "V"); |
| IMethod getState = SdkAssert.assertMethodExist(extendedAddressRowData, "getState", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getState, "QString;"); |
| IMethod setState = SdkAssert.assertMethodExist(extendedAddressRowData, "setState", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setState, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'ExtendedAddressRowData'", 0, extendedAddressRowData.getTypes().length); |
| // type ExtendedPersonTable |
| IType extendedPersonTable = SdkAssert.assertTypeExists(tableFieldExFormData, "ExtendedPersonTable"); |
| SdkAssert.assertHasFlags(extendedPersonTable, 9); |
| SdkAssert.assertHasSuperTypeSignature(extendedPersonTable, "QPersonTable;"); |
| SdkAssert.assertAnnotation(extendedPersonTable, "org.eclipse.scout.commons.annotations.Replace"); |
| |
| // fields of ExtendedPersonTable |
| SdkAssert.assertEquals("field count of 'ExtendedPersonTable'", 1, extendedPersonTable.getFields().length); |
| IField serialVersionUID5 = SdkAssert.assertFieldExist(extendedPersonTable, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID5, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID5, "J"); |
| |
| SdkAssert.assertEquals("method count of 'ExtendedPersonTable'", 8, extendedPersonTable.getMethods().length); |
| IMethod extendedPersonTable1 = SdkAssert.assertMethodExist(extendedPersonTable, "ExtendedPersonTable", new String[]{}); |
| SdkAssert.assertTrue(extendedPersonTable1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(extendedPersonTable1, "V"); |
| IMethod addRow4 = SdkAssert.assertMethodExist(extendedPersonTable, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow4, "QExtendedPersonTableRowData;"); |
| SdkAssert.assertAnnotation(addRow4, "java.lang.Override"); |
| IMethod addRow5 = SdkAssert.assertMethodExist(extendedPersonTable, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow5, "QExtendedPersonTableRowData;"); |
| SdkAssert.assertAnnotation(addRow5, "java.lang.Override"); |
| IMethod createRow2 = SdkAssert.assertMethodExist(extendedPersonTable, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow2, "QExtendedPersonTableRowData;"); |
| SdkAssert.assertAnnotation(createRow2, "java.lang.Override"); |
| IMethod getRowType2 = SdkAssert.assertMethodExist(extendedPersonTable, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType2, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType2, "java.lang.Override"); |
| IMethod getRows2 = SdkAssert.assertMethodExist(extendedPersonTable, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows2, "[QExtendedPersonTableRowData;"); |
| SdkAssert.assertAnnotation(getRows2, "java.lang.Override"); |
| IMethod rowAt2 = SdkAssert.assertMethodExist(extendedPersonTable, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt2, "QExtendedPersonTableRowData;"); |
| SdkAssert.assertAnnotation(rowAt2, "java.lang.Override"); |
| IMethod setRows2 = SdkAssert.assertMethodExist(extendedPersonTable, "setRows", new String[]{"[QExtendedPersonTableRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows2, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'ExtendedPersonTable'", 1, extendedPersonTable.getTypes().length); |
| // type ExtendedPersonTableRowData |
| IType extendedPersonTableRowData = SdkAssert.assertTypeExists(extendedPersonTable, "ExtendedPersonTableRowData"); |
| SdkAssert.assertHasFlags(extendedPersonTableRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(extendedPersonTableRowData, "QPersonTableRowData;"); |
| |
| // fields of ExtendedPersonTableRowData |
| SdkAssert.assertEquals("field count of 'ExtendedPersonTableRowData'", 3, extendedPersonTableRowData.getFields().length); |
| IField serialVersionUID6 = SdkAssert.assertFieldExist(extendedPersonTableRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID6, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID6, "J"); |
| IField lastName = SdkAssert.assertFieldExist(extendedPersonTableRowData, "lastName"); |
| SdkAssert.assertHasFlags(lastName, 25); |
| SdkAssert.assertFieldSignature(lastName, "QString;"); |
| IField m_lastName = SdkAssert.assertFieldExist(extendedPersonTableRowData, "m_lastName"); |
| SdkAssert.assertHasFlags(m_lastName, 2); |
| SdkAssert.assertFieldSignature(m_lastName, "QString;"); |
| |
| SdkAssert.assertEquals("method count of 'ExtendedPersonTableRowData'", 3, extendedPersonTableRowData.getMethods().length); |
| IMethod extendedPersonTableRowData1 = SdkAssert.assertMethodExist(extendedPersonTableRowData, "ExtendedPersonTableRowData", new String[]{}); |
| SdkAssert.assertTrue(extendedPersonTableRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(extendedPersonTableRowData1, "V"); |
| IMethod getLastName = SdkAssert.assertMethodExist(extendedPersonTableRowData, "getLastName", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getLastName, "QString;"); |
| IMethod setLastName = SdkAssert.assertMethodExist(extendedPersonTableRowData, "setLastName", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setLastName, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'ExtendedPersonTableRowData'", 0, extendedPersonTableRowData.getTypes().length); |
| // type NoTableExtended |
| IType noTableExtended = SdkAssert.assertTypeExists(tableFieldExFormData, "NoTableExtended"); |
| SdkAssert.assertHasFlags(noTableExtended, 9); |
| SdkAssert.assertHasSuperTypeSignature(noTableExtended, "QNoTable;"); |
| SdkAssert.assertAnnotation(noTableExtended, "org.eclipse.scout.commons.annotations.Replace"); |
| |
| // fields of NoTableExtended |
| SdkAssert.assertEquals("field count of 'NoTableExtended'", 1, noTableExtended.getFields().length); |
| IField serialVersionUID7 = SdkAssert.assertFieldExist(noTableExtended, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID7, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID7, "J"); |
| |
| SdkAssert.assertEquals("method count of 'NoTableExtended'", 8, noTableExtended.getMethods().length); |
| IMethod noTableExtended1 = SdkAssert.assertMethodExist(noTableExtended, "NoTableExtended", new String[]{}); |
| SdkAssert.assertTrue(noTableExtended1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(noTableExtended1, "V"); |
| IMethod addRow6 = SdkAssert.assertMethodExist(noTableExtended, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow6, "QNoTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(addRow6, "java.lang.Override"); |
| IMethod addRow7 = SdkAssert.assertMethodExist(noTableExtended, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow7, "QNoTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(addRow7, "java.lang.Override"); |
| IMethod createRow3 = SdkAssert.assertMethodExist(noTableExtended, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow3, "QNoTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(createRow3, "java.lang.Override"); |
| IMethod getRowType3 = SdkAssert.assertMethodExist(noTableExtended, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType3, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType3, "java.lang.Override"); |
| IMethod getRows3 = SdkAssert.assertMethodExist(noTableExtended, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows3, "[QNoTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(getRows3, "java.lang.Override"); |
| IMethod rowAt3 = SdkAssert.assertMethodExist(noTableExtended, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt3, "QNoTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(rowAt3, "java.lang.Override"); |
| IMethod setRows3 = SdkAssert.assertMethodExist(noTableExtended, "setRows", new String[]{"[QNoTableExtendedRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows3, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'NoTableExtended'", 1, noTableExtended.getTypes().length); |
| // type NoTableExtendedRowData |
| IType noTableExtendedRowData = SdkAssert.assertTypeExists(noTableExtended, "NoTableExtendedRowData"); |
| SdkAssert.assertHasFlags(noTableExtendedRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(noTableExtendedRowData, "QAbstractTableRowData;"); |
| |
| // fields of NoTableExtendedRowData |
| SdkAssert.assertEquals("field count of 'NoTableExtendedRowData'", 3, noTableExtendedRowData.getFields().length); |
| IField serialVersionUID8 = SdkAssert.assertFieldExist(noTableExtendedRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID8, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID8, "J"); |
| IField new_ = SdkAssert.assertFieldExist(noTableExtendedRowData, "new_"); |
| SdkAssert.assertHasFlags(new_, 25); |
| SdkAssert.assertFieldSignature(new_, "QString;"); |
| IField m_new = SdkAssert.assertFieldExist(noTableExtendedRowData, "m_new"); |
| SdkAssert.assertHasFlags(m_new, 2); |
| SdkAssert.assertFieldSignature(m_new, "QString;"); |
| |
| SdkAssert.assertEquals("method count of 'NoTableExtendedRowData'", 3, noTableExtendedRowData.getMethods().length); |
| IMethod noTableExtendedRowData1 = SdkAssert.assertMethodExist(noTableExtendedRowData, "NoTableExtendedRowData", new String[]{}); |
| SdkAssert.assertTrue(noTableExtendedRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(noTableExtendedRowData1, "V"); |
| IMethod getNew = SdkAssert.assertMethodExist(noTableExtendedRowData, "getNew", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getNew, "QString;"); |
| IMethod setNew = SdkAssert.assertMethodExist(noTableExtendedRowData, "setNew", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setNew, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'NoTableExtendedRowData'", 0, noTableExtendedRowData.getTypes().length); |
| // type TableExtended |
| IType tableExtended = SdkAssert.assertTypeExists(tableFieldExFormData, "TableExtended"); |
| SdkAssert.assertHasFlags(tableExtended, 9); |
| SdkAssert.assertHasSuperTypeSignature(tableExtended, "QTable;"); |
| SdkAssert.assertAnnotation(tableExtended, "org.eclipse.scout.commons.annotations.Replace"); |
| |
| // fields of TableExtended |
| SdkAssert.assertEquals("field count of 'TableExtended'", 1, tableExtended.getFields().length); |
| IField serialVersionUID9 = SdkAssert.assertFieldExist(tableExtended, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID9, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID9, "J"); |
| |
| SdkAssert.assertEquals("method count of 'TableExtended'", 8, tableExtended.getMethods().length); |
| IMethod tableExtended1 = SdkAssert.assertMethodExist(tableExtended, "TableExtended", new String[]{}); |
| SdkAssert.assertTrue(tableExtended1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(tableExtended1, "V"); |
| IMethod addRow8 = SdkAssert.assertMethodExist(tableExtended, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow8, "QTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(addRow8, "java.lang.Override"); |
| IMethod addRow9 = SdkAssert.assertMethodExist(tableExtended, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow9, "QTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(addRow9, "java.lang.Override"); |
| IMethod createRow4 = SdkAssert.assertMethodExist(tableExtended, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow4, "QTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(createRow4, "java.lang.Override"); |
| IMethod getRowType4 = SdkAssert.assertMethodExist(tableExtended, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType4, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType4, "java.lang.Override"); |
| IMethod getRows4 = SdkAssert.assertMethodExist(tableExtended, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows4, "[QTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(getRows4, "java.lang.Override"); |
| IMethod rowAt4 = SdkAssert.assertMethodExist(tableExtended, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt4, "QTableExtendedRowData;"); |
| SdkAssert.assertAnnotation(rowAt4, "java.lang.Override"); |
| IMethod setRows4 = SdkAssert.assertMethodExist(tableExtended, "setRows", new String[]{"[QTableExtendedRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows4, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'TableExtended'", 1, tableExtended.getTypes().length); |
| // type TableExtendedRowData |
| IType tableExtendedRowData = SdkAssert.assertTypeExists(tableExtended, "TableExtendedRowData"); |
| SdkAssert.assertHasFlags(tableExtendedRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(tableExtendedRowData, "QTableRowData;"); |
| |
| // fields of TableExtendedRowData |
| SdkAssert.assertEquals("field count of 'TableExtendedRowData'", 3, tableExtendedRowData.getFields().length); |
| IField serialVersionUID10 = SdkAssert.assertFieldExist(tableExtendedRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID10, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID10, "J"); |
| IField boolean_ = SdkAssert.assertFieldExist(tableExtendedRowData, "boolean_"); |
| SdkAssert.assertHasFlags(boolean_, 25); |
| SdkAssert.assertFieldSignature(boolean_, "QString;"); |
| IField m_boolean = SdkAssert.assertFieldExist(tableExtendedRowData, "m_boolean"); |
| SdkAssert.assertHasFlags(m_boolean, 2); |
| SdkAssert.assertFieldSignature(m_boolean, "QBoolean;"); |
| |
| SdkAssert.assertEquals("method count of 'TableExtendedRowData'", 3, tableExtendedRowData.getMethods().length); |
| IMethod tableExtendedRowData1 = SdkAssert.assertMethodExist(tableExtendedRowData, "TableExtendedRowData", new String[]{}); |
| SdkAssert.assertTrue(tableExtendedRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(tableExtendedRowData1, "V"); |
| IMethod getBoolean = SdkAssert.assertMethodExist(tableExtendedRowData, "getBoolean", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getBoolean, "QBoolean;"); |
| IMethod setBoolean = SdkAssert.assertMethodExist(tableExtendedRowData, "setBoolean", new String[]{"QBoolean;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setBoolean, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'TableExtendedRowData'", 0, tableExtendedRowData.getTypes().length); |
| } |
| |
| /** |
| * @Generated with org.eclipse.scout.sdk.testing.codegen.ApiTestGenerator |
| */ |
| private void testApiOfBaseWithExtendedTableFormData() throws Exception { |
| // type BaseWithExtendedTableFormData |
| IType baseWithExtendedTableFormData = SdkAssert.assertTypeExists("formdata.shared.services.BaseWithExtendedTableFormData"); |
| SdkAssert.assertHasFlags(baseWithExtendedTableFormData, 1); |
| SdkAssert.assertHasSuperTypeSignature(baseWithExtendedTableFormData, "QAbstractFormData;"); |
| |
| // fields of BaseWithExtendedTableFormData |
| SdkAssert.assertEquals("field count of 'BaseWithExtendedTableFormData'", 1, baseWithExtendedTableFormData.getFields().length); |
| IField serialVersionUID = SdkAssert.assertFieldExist(baseWithExtendedTableFormData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID, "J"); |
| |
| SdkAssert.assertEquals("method count of 'BaseWithExtendedTableFormData'", 2, baseWithExtendedTableFormData.getMethods().length); |
| IMethod baseWithExtendedTableFormData1 = SdkAssert.assertMethodExist(baseWithExtendedTableFormData, "BaseWithExtendedTableFormData", new String[]{}); |
| SdkAssert.assertTrue(baseWithExtendedTableFormData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(baseWithExtendedTableFormData1, "V"); |
| IMethod getTableInForm = SdkAssert.assertMethodExist(baseWithExtendedTableFormData, "getTableInForm", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getTableInForm, "QTableInForm;"); |
| |
| SdkAssert.assertEquals("inner types count of 'BaseWithExtendedTableFormData'", 1, baseWithExtendedTableFormData.getTypes().length); |
| // type TableInForm |
| IType tableInForm = SdkAssert.assertTypeExists(baseWithExtendedTableFormData, "TableInForm"); |
| SdkAssert.assertHasFlags(tableInForm, 9); |
| SdkAssert.assertHasSuperTypeSignature(tableInForm, "QAbstractTableFieldBeanData;"); |
| |
| // fields of TableInForm |
| SdkAssert.assertEquals("field count of 'TableInForm'", 1, tableInForm.getFields().length); |
| IField serialVersionUID1 = SdkAssert.assertFieldExist(tableInForm, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID1, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID1, "J"); |
| |
| SdkAssert.assertEquals("method count of 'TableInForm'", 8, tableInForm.getMethods().length); |
| IMethod tableInForm1 = SdkAssert.assertMethodExist(tableInForm, "TableInForm", new String[]{}); |
| SdkAssert.assertTrue(tableInForm1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(tableInForm1, "V"); |
| IMethod addRow = SdkAssert.assertMethodExist(tableInForm, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow, "QTableInFormRowData;"); |
| SdkAssert.assertAnnotation(addRow, "java.lang.Override"); |
| IMethod addRow1 = SdkAssert.assertMethodExist(tableInForm, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow1, "QTableInFormRowData;"); |
| SdkAssert.assertAnnotation(addRow1, "java.lang.Override"); |
| IMethod createRow = SdkAssert.assertMethodExist(tableInForm, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow, "QTableInFormRowData;"); |
| SdkAssert.assertAnnotation(createRow, "java.lang.Override"); |
| IMethod getRowType = SdkAssert.assertMethodExist(tableInForm, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType, "java.lang.Override"); |
| IMethod getRows = SdkAssert.assertMethodExist(tableInForm, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows, "[QTableInFormRowData;"); |
| SdkAssert.assertAnnotation(getRows, "java.lang.Override"); |
| IMethod rowAt = SdkAssert.assertMethodExist(tableInForm, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt, "QTableInFormRowData;"); |
| SdkAssert.assertAnnotation(rowAt, "java.lang.Override"); |
| IMethod setRows = SdkAssert.assertMethodExist(tableInForm, "setRows", new String[]{"[QTableInFormRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'TableInForm'", 1, tableInForm.getTypes().length); |
| // type TableInFormRowData |
| IType tableInFormRowData = SdkAssert.assertTypeExists(tableInForm, "TableInFormRowData"); |
| SdkAssert.assertHasFlags(tableInFormRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(tableInFormRowData, "QAbstractTableRowData;"); |
| |
| // fields of TableInFormRowData |
| SdkAssert.assertEquals("field count of 'TableInFormRowData'", 5, tableInFormRowData.getFields().length); |
| IField serialVersionUID2 = SdkAssert.assertFieldExist(tableInFormRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID2, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID2, "J"); |
| IField colInAbstractTable = SdkAssert.assertFieldExist(tableInFormRowData, "colInAbstractTable"); |
| SdkAssert.assertHasFlags(colInAbstractTable, 25); |
| SdkAssert.assertFieldSignature(colInAbstractTable, "QString;"); |
| IField colInDesktopForm = SdkAssert.assertFieldExist(tableInFormRowData, "colInDesktopForm"); |
| SdkAssert.assertHasFlags(colInDesktopForm, 25); |
| SdkAssert.assertFieldSignature(colInDesktopForm, "QString;"); |
| IField m_colInAbstractTable = SdkAssert.assertFieldExist(tableInFormRowData, "m_colInAbstractTable"); |
| SdkAssert.assertHasFlags(m_colInAbstractTable, 2); |
| SdkAssert.assertFieldSignature(m_colInAbstractTable, "QString;"); |
| IField m_colInDesktopForm = SdkAssert.assertFieldExist(tableInFormRowData, "m_colInDesktopForm"); |
| SdkAssert.assertHasFlags(m_colInDesktopForm, 2); |
| SdkAssert.assertFieldSignature(m_colInDesktopForm, "QString;"); |
| |
| SdkAssert.assertEquals("method count of 'TableInFormRowData'", 5, tableInFormRowData.getMethods().length); |
| IMethod tableInFormRowData1 = SdkAssert.assertMethodExist(tableInFormRowData, "TableInFormRowData", new String[]{}); |
| SdkAssert.assertTrue(tableInFormRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(tableInFormRowData1, "V"); |
| IMethod getColInAbstractTable = SdkAssert.assertMethodExist(tableInFormRowData, "getColInAbstractTable", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getColInAbstractTable, "QString;"); |
| IMethod setColInAbstractTable = SdkAssert.assertMethodExist(tableInFormRowData, "setColInAbstractTable", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setColInAbstractTable, "V"); |
| IMethod getColInDesktopForm = SdkAssert.assertMethodExist(tableInFormRowData, "getColInDesktopForm", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getColInDesktopForm, "QString;"); |
| IMethod setColInDesktopForm = SdkAssert.assertMethodExist(tableInFormRowData, "setColInDesktopForm", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setColInDesktopForm, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'TableInFormRowData'", 0, tableInFormRowData.getTypes().length); |
| } |
| |
| /** |
| * @Generated with org.eclipse.scout.sdk.testing.codegen.ApiTestGenerator |
| */ |
| private void testApiOfChildWithExtendedTableFormData() throws Exception { |
| // type ChildWithExtendedTableFormData |
| IType childWithExtendedTableFormData = SdkAssert.assertTypeExists("formdata.shared.services.ChildWithExtendedTableFormData"); |
| SdkAssert.assertHasFlags(childWithExtendedTableFormData, 1); |
| SdkAssert.assertHasSuperTypeSignature(childWithExtendedTableFormData, "QBaseWithExtendedTableFormData;"); |
| |
| // fields of ChildWithExtendedTableFormData |
| SdkAssert.assertEquals("field count of 'ChildWithExtendedTableFormData'", 1, childWithExtendedTableFormData.getFields().length); |
| IField serialVersionUID = SdkAssert.assertFieldExist(childWithExtendedTableFormData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID, "J"); |
| |
| SdkAssert.assertEquals("method count of 'ChildWithExtendedTableFormData'", 2, childWithExtendedTableFormData.getMethods().length); |
| IMethod childWithExtendedTableFormData1 = SdkAssert.assertMethodExist(childWithExtendedTableFormData, "ChildWithExtendedTableFormData", new String[]{}); |
| SdkAssert.assertTrue(childWithExtendedTableFormData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(childWithExtendedTableFormData1, "V"); |
| IMethod getChildTable = SdkAssert.assertMethodExist(childWithExtendedTableFormData, "getChildTable", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getChildTable, "QChildTable;"); |
| |
| SdkAssert.assertEquals("inner types count of 'ChildWithExtendedTableFormData'", 1, childWithExtendedTableFormData.getTypes().length); |
| // type ChildTable |
| IType childTable = SdkAssert.assertTypeExists(childWithExtendedTableFormData, "ChildTable"); |
| SdkAssert.assertHasFlags(childTable, 9); |
| SdkAssert.assertHasSuperTypeSignature(childTable, "QAbstractTableFieldBeanData;"); |
| |
| // fields of ChildTable |
| SdkAssert.assertEquals("field count of 'ChildTable'", 1, childTable.getFields().length); |
| IField serialVersionUID1 = SdkAssert.assertFieldExist(childTable, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID1, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID1, "J"); |
| |
| SdkAssert.assertEquals("method count of 'ChildTable'", 8, childTable.getMethods().length); |
| IMethod childTable1 = SdkAssert.assertMethodExist(childTable, "ChildTable", new String[]{}); |
| SdkAssert.assertTrue(childTable1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(childTable1, "V"); |
| IMethod addRow = SdkAssert.assertMethodExist(childTable, "addRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow, "QChildTableRowData;"); |
| SdkAssert.assertAnnotation(addRow, "java.lang.Override"); |
| IMethod addRow1 = SdkAssert.assertMethodExist(childTable, "addRow", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(addRow1, "QChildTableRowData;"); |
| SdkAssert.assertAnnotation(addRow1, "java.lang.Override"); |
| IMethod createRow = SdkAssert.assertMethodExist(childTable, "createRow", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(createRow, "QChildTableRowData;"); |
| SdkAssert.assertAnnotation(createRow, "java.lang.Override"); |
| IMethod getRowType = SdkAssert.assertMethodExist(childTable, "getRowType", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRowType, "QClass<+QAbstractTableRowData;>;"); |
| SdkAssert.assertAnnotation(getRowType, "java.lang.Override"); |
| IMethod getRows = SdkAssert.assertMethodExist(childTable, "getRows", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getRows, "[QChildTableRowData;"); |
| SdkAssert.assertAnnotation(getRows, "java.lang.Override"); |
| IMethod rowAt = SdkAssert.assertMethodExist(childTable, "rowAt", new String[]{"I"}); |
| SdkAssert.assertMethodReturnTypeSignature(rowAt, "QChildTableRowData;"); |
| SdkAssert.assertAnnotation(rowAt, "java.lang.Override"); |
| IMethod setRows = SdkAssert.assertMethodExist(childTable, "setRows", new String[]{"[QChildTableRowData;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setRows, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'ChildTable'", 1, childTable.getTypes().length); |
| // type ChildTableRowData |
| IType childTableRowData = SdkAssert.assertTypeExists(childTable, "ChildTableRowData"); |
| SdkAssert.assertHasFlags(childTableRowData, 9); |
| SdkAssert.assertHasSuperTypeSignature(childTableRowData, "QAbstractTableRowData;"); |
| |
| // fields of ChildTableRowData |
| SdkAssert.assertEquals("field count of 'ChildTableRowData'", 7, childTableRowData.getFields().length); |
| IField serialVersionUID2 = SdkAssert.assertFieldExist(childTableRowData, "serialVersionUID"); |
| SdkAssert.assertHasFlags(serialVersionUID2, 26); |
| SdkAssert.assertFieldSignature(serialVersionUID2, "J"); |
| IField col1InChildForm = SdkAssert.assertFieldExist(childTableRowData, "col1InChildForm"); |
| SdkAssert.assertHasFlags(col1InChildForm, 25); |
| SdkAssert.assertFieldSignature(col1InChildForm, "QString;"); |
| IField colInAbstractTable = SdkAssert.assertFieldExist(childTableRowData, "colInAbstractTable"); |
| SdkAssert.assertHasFlags(colInAbstractTable, 25); |
| SdkAssert.assertFieldSignature(colInAbstractTable, "QString;"); |
| IField colInDesktopForm = SdkAssert.assertFieldExist(childTableRowData, "colInDesktopForm"); |
| SdkAssert.assertHasFlags(colInDesktopForm, 25); |
| SdkAssert.assertFieldSignature(colInDesktopForm, "QString;"); |
| IField m_col1InChildForm = SdkAssert.assertFieldExist(childTableRowData, "m_col1InChildForm"); |
| SdkAssert.assertHasFlags(m_col1InChildForm, 2); |
| SdkAssert.assertFieldSignature(m_col1InChildForm, "QString;"); |
| IField m_colInAbstractTable = SdkAssert.assertFieldExist(childTableRowData, "m_colInAbstractTable"); |
| SdkAssert.assertHasFlags(m_colInAbstractTable, 2); |
| SdkAssert.assertFieldSignature(m_colInAbstractTable, "QString;"); |
| IField m_colInDesktopForm = SdkAssert.assertFieldExist(childTableRowData, "m_colInDesktopForm"); |
| SdkAssert.assertHasFlags(m_colInDesktopForm, 2); |
| SdkAssert.assertFieldSignature(m_colInDesktopForm, "QString;"); |
| |
| SdkAssert.assertEquals("method count of 'ChildTableRowData'", 7, childTableRowData.getMethods().length); |
| IMethod childTableRowData1 = SdkAssert.assertMethodExist(childTableRowData, "ChildTableRowData", new String[]{}); |
| SdkAssert.assertTrue(childTableRowData1.isConstructor()); |
| SdkAssert.assertMethodReturnTypeSignature(childTableRowData1, "V"); |
| IMethod getCol1InChildForm = SdkAssert.assertMethodExist(childTableRowData, "getCol1InChildForm", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getCol1InChildForm, "QString;"); |
| IMethod setCol1InChildForm = SdkAssert.assertMethodExist(childTableRowData, "setCol1InChildForm", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setCol1InChildForm, "V"); |
| IMethod getColInAbstractTable = SdkAssert.assertMethodExist(childTableRowData, "getColInAbstractTable", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getColInAbstractTable, "QString;"); |
| IMethod setColInAbstractTable = SdkAssert.assertMethodExist(childTableRowData, "setColInAbstractTable", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setColInAbstractTable, "V"); |
| IMethod getColInDesktopForm = SdkAssert.assertMethodExist(childTableRowData, "getColInDesktopForm", new String[]{}); |
| SdkAssert.assertMethodReturnTypeSignature(getColInDesktopForm, "QString;"); |
| IMethod setColInDesktopForm = SdkAssert.assertMethodExist(childTableRowData, "setColInDesktopForm", new String[]{"QString;"}); |
| SdkAssert.assertMethodReturnTypeSignature(setColInDesktopForm, "V"); |
| |
| SdkAssert.assertEquals("inner types count of 'ChildTableRowData'", 0, childTableRowData.getTypes().length); |
| } |
| } |
