geode-core/src/test/java/org/apache/geode/pdx/internal/PdxTypeTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License. You may obtain a
 * copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package org.apache.geode.pdx.internal;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Collection;
import java.util.List;

import org.junit.Test;
import org.junit.experimental.categories.Category;

import org.apache.geode.pdx.FieldType;
import org.apache.geode.test.junit.categories.SerializationTest;

@Category(SerializationTest.class)
public class PdxTypeTest {
  static final String TYPE_NAME = "typeName";
  static final boolean EXPECT_DOMAIN_CLASS = true;
  static final PdxField FIELD_0 = new PdxField("field0", 0, 0, FieldType.INT, true);
  static final PdxField FIELD_1 = new PdxField("field1", 1, 1, FieldType.STRING, true);
  static final PdxField FIELD_2 = new PdxField("field2", 2, 0, FieldType.BOOLEAN, false);
  static final PdxField FIELD_3 = new PdxField("field3", 3, 0, FieldType.DOUBLE, false);
  static final PdxField FIELD_4 = new PdxField("field4", 4, 2, FieldType.OBJECT_ARRAY, false);

  static {
    FIELD_3.setDeleted(true);
  }

  @Test
  public void testNoArgConstructor() {
    final PdxType type = new PdxType();
    assertEquals(0, type.getVariableLengthFieldCount());
    assertNull(type.getClassName());
    assertFalse(type.getNoDomainClass());
    assertEquals(0, type.getTypeId());
    assertEquals(0, type.getFieldCount());
    assertFalse(type.getHasDeletedField());
  }

  @Test
  public void testSomeArgsConstructor() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    assertEquals(0, type.getVariableLengthFieldCount());
    assertEquals(TYPE_NAME, type.getClassName());
    assertEquals(!EXPECT_DOMAIN_CLASS, type.getNoDomainClass());
    assertEquals(0, type.getTypeId());
    assertEquals(0, type.getFieldCount());
    assertFalse(type.getHasDeletedField());
  }

  @Test
  public void testGetDSId() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.setTypeId(0xDEADBEEF);
    assertEquals(0xDE, type.getDSId());
  }

  @Test
  public void testGetTypeNum() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.setTypeId(0xDEADBEEF);
    assertEquals(0xADBEEF, type.getTypeNum());
  }

  @Test
  public void testAddField() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    assertEquals(0, type.getFieldCount());
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    assertEquals(3, type.getFieldCount());
    final List<PdxField> fields = type.getFields();
    assertTrue(fields.contains(FIELD_0));
    assertTrue(fields.contains(FIELD_1));
    assertFalse(fields.contains(FIELD_2));
    assertFalse(fields.contains(FIELD_3));
    assertTrue(fields.contains(FIELD_4));
  }

  @Test
  public void testGetPdxField() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    assertSame(FIELD_0, type.getPdxField(FIELD_0.getFieldName()));
    assertSame(FIELD_1, type.getPdxField(FIELD_1.getFieldName()));
    assertNull(type.getPdxField(FIELD_2.getFieldName()));
    assertNull(type.getPdxField(FIELD_3.getFieldName()));
    assertSame(FIELD_4, type.getPdxField(FIELD_4.getFieldName()));
  }

  @Test
  public void testGetPdxFieldByIndex() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    assertSame(FIELD_0, type.getPdxFieldByIndex(1));
    assertSame(FIELD_1, type.getPdxFieldByIndex(2));
    assertSame(FIELD_4, type.getPdxFieldByIndex(0));
  }

  @Test
  public void testGetUndeletedFieldCount() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.setHasDeletedField(true);
    type.addField(FIELD_4);
    type.addField(FIELD_3);
    type.addField(FIELD_2);
    assertEquals(2, type.getUndeletedFieldCount());
  }

  @Test
  public void testGetFieldNames() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    final List<String> fieldNames = type.getFieldNames();
    assertEquals(3, fieldNames.size());
    assertTrue(fieldNames.contains(FIELD_0.getFieldName()));
    assertTrue(fieldNames.contains(FIELD_1.getFieldName()));
    assertFalse(fieldNames.contains(FIELD_2.getFieldName()));
    assertFalse(fieldNames.contains(FIELD_3.getFieldName()));
    assertTrue(fieldNames.contains(FIELD_4.getFieldName()));
  }

  @Test
  public void testSortedFields() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.setHasDeletedField(true);
    type.addField(FIELD_3);
    type.addField(FIELD_2);
    type.addField(FIELD_1);
    final Collection<PdxField> fields = type.getSortedFields();
    assertEquals(2, fields.size());
    assertFalse(fields.contains(FIELD_0));
    assertTrue(fields.contains(FIELD_1));
    assertTrue(fields.contains(FIELD_2));
    assertFalse(fields.contains(FIELD_3));
    assertFalse(fields.contains(FIELD_4));
  }

  @Test
  public void testSortedIdentityFields() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.setHasDeletedField(true);
    type.addField(FIELD_3);
    type.addField(FIELD_2);
    type.addField(FIELD_1);
    final Collection<PdxField> fields = type.getSortedIdentityFields();
    assertEquals(1, fields.size());
    assertFalse(fields.contains(FIELD_0));
    assertTrue(fields.contains(FIELD_1));
    assertFalse(fields.contains(FIELD_2));
    assertFalse(fields.contains(FIELD_3));
    assertFalse(fields.contains(FIELD_4));
  }

  @Test
  public void testHasExtraFields() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.setHasDeletedField(true);
    type.addField(FIELD_3);
    type.addField(FIELD_2);
    type.addField(FIELD_1);
    type.addField(FIELD_0);
    assertFalse(type.hasExtraFields(type));

    final PdxType noDeletedField = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    noDeletedField.addField(FIELD_2);
    noDeletedField.addField(FIELD_1);
    noDeletedField.addField(FIELD_0);
    assertFalse(type.hasExtraFields(noDeletedField));

    final PdxType fewerFields = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    fewerFields.addField(FIELD_2);
    fewerFields.addField(FIELD_1);
    assertTrue(type.hasExtraFields(fewerFields));

    final PdxType moreFields = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    moreFields.addField(FIELD_4);
    moreFields.addField(FIELD_2);
    moreFields.addField(FIELD_1);
    moreFields.addField(FIELD_0);
    assertFalse(type.hasExtraFields(moreFields));
  }

  @Test
  public void testCompatible() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    assertTrue(type.compatible(type));
    assertFalse(type.compatible(null));

    final PdxType sameTypeNameAndFields = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    sameTypeNameAndFields.addField(FIELD_4);
    sameTypeNameAndFields.addField(FIELD_0);
    sameTypeNameAndFields.addField(FIELD_1);
    assertTrue(type.compatible(sameTypeNameAndFields));

    final PdxType sameTypeNameAndFieldsDifferentDomain =
        new PdxType(TYPE_NAME, !EXPECT_DOMAIN_CLASS);
    sameTypeNameAndFieldsDifferentDomain.addField(FIELD_4);
    sameTypeNameAndFieldsDifferentDomain.addField(FIELD_0);
    sameTypeNameAndFieldsDifferentDomain.addField(FIELD_1);
    assertTrue(type.compatible(sameTypeNameAndFieldsDifferentDomain));

    final PdxType sameTypeNameAndDifferentFields = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    sameTypeNameAndDifferentFields.addField(FIELD_3);
    sameTypeNameAndDifferentFields.addField(FIELD_2);
    sameTypeNameAndDifferentFields.addField(FIELD_1);
    assertFalse(type.compatible(sameTypeNameAndDifferentFields));


    final PdxType sameTypeNameAndFieldsInDifferentOrder =
        new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    sameTypeNameAndFieldsInDifferentOrder.addField(FIELD_1);
    sameTypeNameAndFieldsInDifferentOrder.addField(FIELD_0);
    sameTypeNameAndFieldsInDifferentOrder.addField(FIELD_4);
    assertTrue(type.compatible(sameTypeNameAndFieldsInDifferentOrder));
  }

  @Test
  public void testHashCode() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    assertEquals(type.hashCode(), type.hashCode());

    final PdxType sameTypeNameAndFields = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    sameTypeNameAndFields.addField(FIELD_4);
    sameTypeNameAndFields.addField(FIELD_0);
    sameTypeNameAndFields.addField(FIELD_1);
    assertEquals(type.hashCode(), sameTypeNameAndFields.hashCode());

    final PdxType sameTypeNameAndFieldsDifferentDomain =
        new PdxType(TYPE_NAME, !EXPECT_DOMAIN_CLASS);
    sameTypeNameAndFieldsDifferentDomain.addField(FIELD_4);
    sameTypeNameAndFieldsDifferentDomain.addField(FIELD_0);
    sameTypeNameAndFieldsDifferentDomain.addField(FIELD_1);
    assertEquals(type.hashCode(), sameTypeNameAndFieldsDifferentDomain.hashCode());

    final PdxType differentTypeNameAndSameFields =
        new PdxType("Not " + TYPE_NAME, EXPECT_DOMAIN_CLASS);
    differentTypeNameAndSameFields.addField(FIELD_4);
    differentTypeNameAndSameFields.addField(FIELD_0);
    differentTypeNameAndSameFields.addField(FIELD_1);
    assertNotEquals(type.hashCode(), differentTypeNameAndSameFields.hashCode());

    final PdxType sameTypeNameAndDifferentFields = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    sameTypeNameAndDifferentFields.addField(FIELD_3);
    sameTypeNameAndDifferentFields.addField(FIELD_2);
    sameTypeNameAndDifferentFields.addField(FIELD_1);
    assertNotEquals(type.hashCode(), sameTypeNameAndDifferentFields.hashCode());
  }

  @Test
  public void testEquals() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    assertTrue(type.equals(type));
    assertFalse(type.equals(null));
    assertFalse(type.equals(new Object()));

    final PdxType sameTypeNameAndFields = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    sameTypeNameAndFields.addField(FIELD_4);
    sameTypeNameAndFields.addField(FIELD_0);
    sameTypeNameAndFields.addField(FIELD_1);
    assertTrue(type.equals(sameTypeNameAndFields));

    final PdxType sameTypeNameAndFieldsDifferentDomain =
        new PdxType(TYPE_NAME, !EXPECT_DOMAIN_CLASS);
    sameTypeNameAndFieldsDifferentDomain.addField(FIELD_4);
    sameTypeNameAndFieldsDifferentDomain.addField(FIELD_0);
    sameTypeNameAndFieldsDifferentDomain.addField(FIELD_1);
    assertFalse(type.equals(sameTypeNameAndFieldsDifferentDomain));

    final PdxType differentTypeNameAndSameFields =
        new PdxType("Not " + TYPE_NAME, EXPECT_DOMAIN_CLASS);
    differentTypeNameAndSameFields.addField(FIELD_4);
    differentTypeNameAndSameFields.addField(FIELD_0);
    differentTypeNameAndSameFields.addField(FIELD_1);
    assertFalse(type.equals(differentTypeNameAndSameFields));

    final PdxType sameTypeNameAndDifferentFields = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    sameTypeNameAndDifferentFields.addField(FIELD_3);
    sameTypeNameAndDifferentFields.addField(FIELD_2);
    sameTypeNameAndDifferentFields.addField(FIELD_1);
    assertFalse(type.equals(sameTypeNameAndDifferentFields));
  }

  @Test
  public void testToFormattedString() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    final String str = type.toFormattedString();
    assertNotEquals(-1, str.indexOf(TYPE_NAME));
    assertNotEquals(-1, str.indexOf(FIELD_0.getFieldName()));
    assertNotEquals(-1, str.indexOf(FIELD_1.getFieldName()));
    assertNotEquals(-1, str.indexOf(FIELD_4.getFieldName()));
  }

  @Test
  public void testToString() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    final String str = type.toString();
    assertNotEquals(-1, str.indexOf(TYPE_NAME));
    assertNotEquals(-1, str.indexOf(FIELD_0.getFieldName()));
    assertNotEquals(-1, str.indexOf(FIELD_1.getFieldName()));
    assertNotEquals(-1, str.indexOf(FIELD_4.getFieldName()));
  }

  @Test
  public void testToStream() {
    final PdxType type = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    type.addField(FIELD_4);
    type.addField(FIELD_0);
    type.addField(FIELD_1);
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    type.toStream(new PrintStream(byteArrayOutputStream), true);
    final String str = byteArrayOutputStream.toString();
    assertNotEquals(-1, str.indexOf(TYPE_NAME));
    assertNotEquals(-1, str.indexOf(FIELD_0.getFieldName()));
    assertNotEquals(-1, str.indexOf(FIELD_1.getFieldName()));
    assertNotEquals(-1, str.indexOf(FIELD_4.getFieldName()));
  }

  @Test
  public void testToDataAndFromData() throws IOException, ClassNotFoundException {
    final PdxType before = new PdxType(TYPE_NAME, EXPECT_DOMAIN_CLASS);
    before.setHasDeletedField(true);
    before.addField(FIELD_4);
    before.addField(FIELD_3);
    before.addField(FIELD_2);
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(1024);
    DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
    before.toData(dataOutputStream);
    dataOutputStream.close();

    final PdxType after = new PdxType();
    ByteArrayInputStream byteArrayInputStream =
        new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
    DataInputStream dataInputStream = new DataInputStream(byteArrayInputStream);
    after.fromData(dataInputStream);

    assertEquals(before.getVariableLengthFieldCount(), after.getVariableLengthFieldCount());
    assertEquals(before.getClassName(), after.getClassName());
    assertEquals(before.getNoDomainClass(), after.getNoDomainClass());
    assertEquals(before.getTypeId(), after.getTypeId());
    assertEquals(before.getFieldCount(), after.getFieldCount());
    assertEquals(before.getHasDeletedField(), after.getHasDeletedField());
  }
}