Java 类com.google.protobuf.FloatValue 实例源码

@Test
public void dispatch_event() {
    final TestEventFactory factory = TestEventFactory.newInstance(getClass());
    final float messageValue = 2017.0729f;
    final FloatValue message = FloatValue.newBuilder()
                                         .setValue(messageValue)
                                         .build();
    final EventEnvelope eventEnvelope = EventEnvelope.of(factory.createEvent(message));

    final List<? extends Message> eventMessages = dispatchEvent(aggregate, eventEnvelope);

    assertTrue(aggregate.getState()
                        .getValue()
                        .contains(String.valueOf(messageValue)));
    assertEquals(1, eventMessages.size());
    assertTrue(eventMessages.get(0) instanceof StringValue);
}

@Test
public void log_error_when_event_reaction_fails() {
    final FailingAggregateRepository repository = new FailingAggregateRepository();
    boundedContext.register(repository);

    final TestEventFactory factory = TestEventFactory.newInstance(getClass());

    // Passing negative float value should cause an exception.
    final EventEnvelope envelope =
            EventEnvelope.of(factory.createEvent(FloatValue.newBuilder()
                                                           .setValue(-412.0f)
                                                           .build()));
    boundedContext.getEventBus()
                  .post(envelope.getOuterObject());

    assertTrue(repository.isErrorLogged());
    final RuntimeException lastException = repository.getLastException();
    assertTrue(lastException instanceof HandlerMethodFailedException);

    final HandlerMethodFailedException methodFailedException =
            (HandlerMethodFailedException) lastException;

    assertEquals(envelope.getMessage(), methodFailedException.getDispatchedMessage());
    assertEquals(envelope.getEventContext(), methodFailedException.getMessageContext());

    final MessageEnvelope lastErrorEnvelope = repository.getLastErrorEnvelope();
    assertNotNull(lastErrorEnvelope);
    assertTrue(lastErrorEnvelope instanceof EventEnvelope);
    assertEquals(envelope.getMessage(), lastErrorEnvelope.getMessage());
}

@React
Timestamp on(FloatValue value) {
    final float floatValue = value.getValue();
    if (floatValue < 0) {
        final long longValue = toId(value);
        // Complain only if the passed value represents ID of this aggregate.
        // This would allow other aggregates react on this message.
        if (longValue == getId()) {
            throw new IllegalArgumentException("Negative floating point value passed");
        }
    }
    return Time.getCurrentTime();
}

FloatValueMarshaller() {
  super(FloatValue.getDefaultInstance());
}

@Override
protected final void doMerge(JsonParser parser, int unused, Message.Builder messageBuilder)
    throws IOException {
  FloatValue.Builder builder = (FloatValue.Builder) messageBuilder;
  builder.setValue(ParseSupport.parseFloat(parser));
}

@Override
protected final void doWrite(FloatValue message, JsonGenerator gen) throws IOException {
  SerializeSupport.printFloat(message.getValue(), gen);
}

@Test
public void anyFields() throws Exception {
  TestAllTypes content = TestAllTypes.newBuilder().setOptionalInt32(1234).build();
  TestAny message = TestAny.newBuilder().setAnyValue(Any.pack(content)).build();
  assertMatchesUpstream(message, TestAllTypes.getDefaultInstance());

  TestAny messageWithDefaultAnyValue =
      TestAny.newBuilder().setAnyValue(Any.getDefaultInstance()).build();
  assertMatchesUpstream(messageWithDefaultAnyValue);

  // Well-known types have a special formatting when embedded in Any.
  //
  // 1. Any in Any.
  Any anyMessage = Any.pack(Any.pack(content));
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());

  // 2. Wrappers in Any.
  anyMessage = Any.pack(Int32Value.newBuilder().setValue(12345).build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());
  anyMessage = Any.pack(UInt32Value.newBuilder().setValue(12345).build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());
  anyMessage = Any.pack(Int64Value.newBuilder().setValue(12345).build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());
  anyMessage = Any.pack(UInt64Value.newBuilder().setValue(12345).build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());
  anyMessage = Any.pack(FloatValue.newBuilder().setValue(12345).build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());
  anyMessage = Any.pack(DoubleValue.newBuilder().setValue(12345).build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());
  anyMessage = Any.pack(BoolValue.newBuilder().setValue(true).build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());
  anyMessage = Any.pack(StringValue.newBuilder().setValue("Hello").build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());
  anyMessage =
      Any.pack(BytesValue.newBuilder().setValue(ByteString.copyFrom(new byte[] {1, 2})).build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());

  // 3. Timestamp in Any.
  anyMessage = Any.pack(Timestamps.parse("1969-12-31T23:59:59Z"));
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());

  // 4. Duration in Any
  anyMessage = Any.pack(Durations.parse("12345.10s"));
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());

  // 5. FieldMask in Any
  anyMessage = Any.pack(FieldMaskUtil.fromString("foo.bar,baz"));
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());

  // 6. Struct in Any
  Struct.Builder structBuilder = Struct.newBuilder();
  structBuilder.putFields("number", Value.newBuilder().setNumberValue(1.125).build());
  anyMessage = Any.pack(structBuilder.build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());

  // 7. Value (number type) in Any
  Value.Builder valueBuilder = Value.newBuilder();
  valueBuilder.setNumberValue(1);
  anyMessage = Any.pack(valueBuilder.build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());

  // 8. Value (null type) in Any
  anyMessage = Any.pack(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build());
  assertMatchesUpstream(anyMessage, TestAllTypes.getDefaultInstance());
}

/**
 * Convert a protocol buffer field value to {@link Any} with the below rule:
 * <ul>
 *    <li> If the field is a primitive type and can be mapped to a wrapper message type
 *    defined in //tech/type/proto/wrappers.proto, its value is boxed into a wrapper
 *     and goes to Any.value, the type name of the wrapper goes to Any.type_url.
 *    <li> If the field is already a message, its type name goes to Any.type_url,
 *    its value directly goes to Any.value
 *    <li> If the field is an enum value, the name of the enum value is boxed into
 *    tech.type.String and put into Any.value, and tech.type.String goes to Any.type_url.
 */
private static Any toAnyType(FieldDescriptor.Type protobufType, Object value) {
  Any.Builder builder = Any.newBuilder();
  java.lang.String typeFullName;
  Message wrapperMessage;
  switch (protobufType) {
    case MESSAGE:
      wrapperMessage = (Message) value;
      typeFullName = wrapperMessage.getDescriptorForType().getFullName();
      break;
    case ENUM:
      // NOTE: Erasing the enum type to the String wrapper is currently intentional, to avoid
      // the need to add an enum wrapper type.  This may change in the future.
      typeFullName = StringValue.getDescriptor().getFullName();
      wrapperMessage =
          StringValue.newBuilder().setValue(((EnumValueDescriptor) value).getName()).build();
      break;
    case BOOL:
      typeFullName = BoolValue.getDescriptor().getFullName();
      wrapperMessage = BoolValue.newBuilder().setValue((Boolean) value).build();
      break;
    case DOUBLE:
      typeFullName = DoubleValue.getDescriptor().getFullName();
      wrapperMessage = DoubleValue.newBuilder().setValue((java.lang.Double) value).build();
      break;
    case FLOAT:
      typeFullName = FloatValue.getDescriptor().getFullName();
      wrapperMessage = FloatValue.newBuilder().setValue((java.lang.Float) value).build();
      break;
    case STRING:
      typeFullName = StringValue.getDescriptor().getFullName();
      wrapperMessage = StringValue.newBuilder().setValue((java.lang.String) value).build();
      break;
    case SINT32:
    case SFIXED32:
    case INT32:
      typeFullName = Int32Value.getDescriptor().getFullName();
      wrapperMessage = Int32Value.newBuilder().setValue((Integer) value).build();
      break;
    case SINT64:
    case SFIXED64:
    case INT64:
      typeFullName = Int64Value.getDescriptor().getFullName();
      wrapperMessage = Int64Value.newBuilder().setValue((Long) value).build();
      break;
    case UINT32:
    case FIXED32:
      typeFullName = UInt32Value.getDescriptor().getFullName();
      wrapperMessage = UInt32Value.newBuilder().setValue((Integer) value).build();
      break;
    case UINT64:
    case FIXED64:
      typeFullName = UInt64Value.getDescriptor().getFullName();
      wrapperMessage = UInt64Value.newBuilder().setValue((Long) value).build();
      break;
    case BYTES:
      typeFullName = BytesValue.getDescriptor().getFullName();
      wrapperMessage = BytesValue.newBuilder().setValue(ByteString.copyFrom((byte[]) value))
          .build();
      break;
    default:
      throw new IllegalArgumentException("Type " + protobufType.name()
          + " cannot be converted to Any type.");
  }
  return builder.setTypeUrl(TYPE_SERVICE_BASE_URL + "/" + typeFullName)
      .setValue(wrapperMessage.toByteString()).build();
}

@SuppressWarnings("NumericCastThatLosesPrecision") // Int. part as ID.
static long toId(FloatValue message) {
    final float floatValue = message.getValue();
    return (long) Math.abs(floatValue);
}

@Subscribe
public void on(FloatValue message) {
    // Do nothing. Just expose the method.
}

@Test
public void return_float_msg_field_class_by_descriptor() {
    assertReturnsFieldClass(Float.class, FloatValue.getDescriptor());
}

@React
StringValue handle(FloatValue value) {
    final String digitalPart = String.valueOf(value.getValue());
    return logItem(digitalPart);
}