How to use

TypeValue

in

uk.gov.gchq.gaffer.types

@Test
public void testCanSerialiseDeSerialiseCorrectlyTypeOnly() throws SerialisationException {
  TypeValue typeValue = new TypeValue();
  typeValue.setType("testType");
  byte[] bytes = serialiser.serialise(typeValue);
  String serialisedForm = new String(bytes);
  assertEquals("testType\0", serialisedForm);
  TypeValue deSerialisedTypeValue = serialiser.deserialise(bytes);
  assertEquals(typeValue.getType(), deSerialisedTypeValue.getType());
  assertNull(typeValue.getValue(), deSerialisedTypeValue.getValue());
  assertEquals(typeValue, deSerialisedTypeValue);
}

@Test
public void testCanSerialiseDeSerialiseCorrectlyValueOnly() throws SerialisationException {
  TypeValue typeValue = new TypeValue();
  typeValue.setValue("testValue");
  byte[] bytes = serialiser.serialise(typeValue);
  String serialisedForm = new String(bytes);
  assertEquals("\0testValue", serialisedForm);
  TypeValue deSerialisedTypeValue = serialiser.deserialise(bytes);
  assertNull(deSerialisedTypeValue.getType());
  assertEquals(typeValue.getValue(), deSerialisedTypeValue.getValue());
  assertEquals(typeValue, deSerialisedTypeValue);
}

@Test
public void testComparisonsAreAsExpected() {
  TypeValue typeValue = new TypeValue("a", "b");
  assertEquals(0, typeValue.compareTo(new TypeValue("a", "b")));
  assertTrue(typeValue.compareTo(null) > 0);
  assertTrue(typeValue.compareTo(new TypeValue()) > 0);
  assertTrue(typeValue.compareTo(new TypeValue("1", "b")) > 0);
  assertTrue(typeValue.compareTo(new TypeValue("a", "a")) > 0);
  assertTrue(typeValue.compareTo(new TypeValue("b", "a")) < 0);
  assertTrue(typeValue.compareTo(new TypeValue("a", "c")) < 0);
}

  @Override
  public int compareTo(final TypeValue typeValue) {
    if (null == typeValue) {
      return 1;
    }
    int i = stringComparator.compare(type, typeValue.getType());
    if (i != 0) {
      return i;
    }
    return stringComparator.compare(value, typeValue.getValue());
  }
}

@Override
public TypeValue deserialise(final byte[] bytes) throws SerialisationException {
  int lastDelimiter = 0;
  TypeValue typeValue = new TypeValue();
  for (int i = 0; i < bytes.length; i++) {
    if (bytes[i] == ByteArrayEscapeUtils.DELIMITER) {
      if (i > 0) {
        try {
          typeValue.setType(new String(ByteArrayEscapeUtils.unEscape(bytes, lastDelimiter, i), CommonConstants.UTF_8));
        } catch (final UnsupportedEncodingException e) {
          throw new SerialisationException("Failed to deserialise the Type from TypeValue Object", e);
        }
      }
      lastDelimiter = i + 1;
      break;
    }
  }
  if (bytes.length > lastDelimiter) {
    try {
      typeValue.setValue(new String(ByteArrayEscapeUtils.unEscape(bytes, lastDelimiter, bytes.length), CommonConstants.UTF_8));
    } catch (final UnsupportedEncodingException e) {
      throw new SerialisationException("Failed to deserialise the Value from TypeValue Object", e);
    }
  }
  return typeValue;
}

@Test
public void testCanSerialiseDeSerialiseCorrectly() throws SerialisationException {
  TypeValue typeValue = new TypeValue("testType", "testValue");
  byte[] bytes = serialiser.serialise(typeValue);
  String serialisedForm = new String(bytes);
  assertEquals("testType\0testValue", serialisedForm);
  TypeValue deSerialisedTypeValue = serialiser.deserialise(bytes);
  assertEquals(typeValue.getType(), deSerialisedTypeValue.getType());
  assertEquals(typeValue.getValue(), deSerialisedTypeValue.getValue());
  assertEquals(typeValue, deSerialisedTypeValue);
}

  @Override
  public TypeValue apply(final Object value) {
    return new TypeValue(null, null != value ? value.toString() : null);
  }
}

  @Test
  public void testHashCodeAndEqualsMethodTreatsEmptyStringAsNull() {
    // Given
    TypeValue typeValueEmptyStrings = new TypeValue("", "");
    TypeValue typeValueNullStrings = new TypeValue(null, null);

    // When
    boolean equalsResult = typeValueEmptyStrings.equals(typeValueNullStrings);

    // Then
    assertTrue(equalsResult);
    assertEquals(typeValueEmptyStrings.hashCode(), typeValueNullStrings.hashCode());
  }
}

@Override
public byte[] serialise(final TypeValue typeValue) throws SerialisationException {
  String type = typeValue.getType();
  String value = typeValue.getValue();
  if ((null == type || type.isEmpty()) && (null == value || value.isEmpty())) {
    throw new SerialisationException("TypeValue passed to serialiser is blank");
  }
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  if (null != type) {
    try {
      out.write(ByteArrayEscapeUtils.escape(type.getBytes(CommonConstants.UTF_8)));
    } catch (final IOException e) {
      throw new SerialisationException("Failed to serialise the Type from TypeValue Object", e);
    }
  }
  out.write(ByteArrayEscapeUtils.DELIMITER);
  if (null != value) {
    try {
      out.write(ByteArrayEscapeUtils.escape(value.getBytes(CommonConstants.UTF_8)));
    } catch (final IOException e) {
      throw new SerialisationException("Failed to serialise the Value from TypeValue Object", e);
    }
  }
  return out.toByteArray();
}

@Test
public void testCanSerialiseDeserialiseCorrectlyAndBeEscaped() throws SerialisationException {
  TypeValue typeValue = new TypeValue("testType", "testValue");
  byte[] bytes = ByteArrayEscapeUtils.escape(serialiser.serialise(typeValue));
  String serialisedForm = new String(bytes);
  assertEquals("testType\1\1testValue", serialisedForm);
  TypeValue deSerialisedTypeValue = serialiser.deserialise(ByteArrayEscapeUtils
      .unEscape(bytes));
  assertEquals(typeValue.getType(), deSerialisedTypeValue.getType());
  assertEquals(typeValue.getValue(), deSerialisedTypeValue.getValue());
  assertEquals(typeValue, deSerialisedTypeValue);
}

@Override
public TypeValue deserialise(final byte[] bytes) throws SerialisationException {
  int lastDelimiter = 0;
  TypeValue typeValue = new TypeValue();
  for (int i = 0; i < bytes.length; i++) {
    if (bytes[i] == ByteArrayEscapeUtils.DELIMITER) {
      if (i > 0) {
        try {
          typeValue.setType(new String(ByteArrayEscapeUtils.unEscape(bytes, lastDelimiter, i), CommonConstants.UTF_8));
        } catch (final UnsupportedEncodingException e) {
          throw new SerialisationException("Failed to deserialise the Type from TypeValue Object", e);
        }
      }
      lastDelimiter = i + 1;
      break;
    }
  }
  if (bytes.length > lastDelimiter) {
    try {
      typeValue.setValue(new String(ByteArrayEscapeUtils.unEscape(bytes, lastDelimiter, bytes.length), CommonConstants.UTF_8));
    } catch (final UnsupportedEncodingException e) {
      throw new SerialisationException("Failed to deserialise the Value from TypeValue Object", e);
    }
  }
  return typeValue;
}

  @Override
  public Pair<TypeValue, byte[]>[] getHistoricSerialisationPairs() {
    TypeValue typeValue = new TypeValue("testType", "testValue");
    return new Pair[]{
        new Pair(typeValue, new byte[]{116, 101, 115, 116, 84, 121, 112, 101, 0, 116, 101, 115, 116, 86, 97, 108, 117, 101})
    };

  }
}

@Override
public Object[] serialise(final TypeValue object) throws SerialisationException {
  if (null != object) {
    return new Object[]{object.getType(), object.getValue()};
  }
  return new Object[]{null, null};
}

@Test
public void shouldConvertObjectToTypeValue() {
  // Given
  final ToTypeValue function = new ToTypeValue();
  final Object value = 1L;
  // When
  final TypeValue result = function.apply(value);
  // Then
  assertEquals(new TypeValue(null, value.toString()), result);
}

  @Override
  public int compareTo(final TypeValue typeValue) {
    if (null == typeValue) {
      return 1;
    }
    int i = stringComparator.compare(type, typeValue.getType());
    if (i != 0) {
      return i;
    }
    return stringComparator.compare(value, typeValue.getValue());
  }
}

@Test
public void shouldConvertStringToTypeValue() {
  // Given
  final ToTypeValue function = new ToTypeValue();
  final Object value = "value1";
  // When
  final TypeValue result = function.apply(value);
  // Then
  assertEquals(new TypeValue(null, value.toString()), result);
}

@Override
public void write(final Kryo kryo, final Output output, final TypeValue typeValue) {
  output.writeString(typeValue.getType());
  output.writeString(typeValue.getValue());
}

@Test
public void shouldConvertNullToTypeValue() {
  // Given
  final ToTypeValue function = new ToTypeValue();
  final Object value = null;
  // When
  final TypeValue result = function.apply(value);
  // Then
  assertEquals(new TypeValue(null, null), result);
}

@Override
public byte[] serialise(final TypeValue typeValue) throws SerialisationException {
  String type = typeValue.getType();
  String value = typeValue.getValue();
  if ((null == type || type.isEmpty()) && (null == value || value.isEmpty())) {
    throw new SerialisationException("TypeValue passed to serialiser is blank");
  }
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  if (null != type) {
    try {
      out.write(ByteArrayEscapeUtils.escape(type.getBytes(CommonConstants.UTF_8)));
    } catch (final IOException e) {
      throw new SerialisationException("Failed to serialise the Type from TypeValue Object", e);
    }
  }
  out.write(ByteArrayEscapeUtils.DELIMITER);
  if (null != value) {
    try {
      out.write(ByteArrayEscapeUtils.escape(value.getBytes(CommonConstants.UTF_8)));
    } catch (final IOException e) {
      throw new SerialisationException("Failed to serialise the Value from TypeValue Object", e);
    }
  }
  return out.toByteArray();
}

@Override
public TypeValue deserialise(final Object[] objects) throws SerialisationException {
  if (objects.length == 2) {
    if (objects[0] instanceof String && objects[1] instanceof String) {
      return new TypeValue((String) objects[0], (String) objects[1]);
    } else if (null == objects[0]) {
      return null;
    }
  }
  throw new SerialisationException("Could not de-serialise objects to a TypeValue");
}