Datasets:

jitx
/

Methods2Test_java_unit_test_code

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 624k rows

target stringlengths 20 113k	src_fm stringlengths 11 86.3k	src_fm_fc stringlengths 21 86.4k	src_fm_fc_co stringlengths 30 86.4k	src_fm_fc_ms stringlengths 42 86.8k	src_fm_fc_ms_ff stringlengths 43 86.8k
@Test public void mapperCanHandleDocumentWithNullValues() { verifyNullAttribute(EnhancedType.documentOf(FakeDocument.class, FAKE_DOCUMENT_TABLE_SCHEMA), a -> a.name("value") .getter(FakeMappedItem::getAFakeDocument) .setter(FakeMappedItem::setAFakeDocument), FakeMappedItem.builder().build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleInteger() { verifyNullableAttribute(EnhancedType.of(Integer.class), a -> a.name("value") .getter(FakeMappedItem::getAnInteger) .setter(FakeMappedItem::setAnInteger), FakeMappedItem.builder().anInteger(123).build(), AttributeValue.builder().n("123").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveInteger() { verifyAttribute(EnhancedType.of(int.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveInteger) .setter(FakeMappedItem::setAPrimitiveInteger), FakeMappedItem.builder().aPrimitiveInteger(123).build(), AttributeValue.builder().n("123").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleBoolean() { verifyNullableAttribute(EnhancedType.of(Boolean.class), a -> a.name("value") .getter(FakeMappedItem::getABoolean) .setter(FakeMappedItem::setABoolean), FakeMappedItem.builder().aBoolean(true).build(), AttributeValue.builder().bool(true).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void headObjectOtherException_shouldNotThrowException() { S3Exception s3Exception = (S3Exception) S3Exception.builder().statusCode(500).build(); Context.FailedExecution failedExecution = getFailedExecution(s3Exception, HeadObjectRequest.builder().build()); assertThat(interceptor.modifyException(failedExecution, new ExecutionAttributes())).isEqualTo(s3Exception); }	@Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); }	ExceptionTranslationInterceptor implements ExecutionInterceptor { @Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); } }	ExceptionTranslationInterceptor implements ExecutionInterceptor { @Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); } }	ExceptionTranslationInterceptor implements ExecutionInterceptor { @Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); } @Override Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes); }	ExceptionTranslationInterceptor implements ExecutionInterceptor { @Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); } @Override Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes); }
@Test public void mapperCanHandlePrimitiveBoolean() { verifyAttribute(EnhancedType.of(boolean.class), a -> a.name("value") .getter(FakeMappedItem::isAPrimitiveBoolean) .setter(FakeMappedItem::setAPrimitiveBoolean), FakeMappedItem.builder().aPrimitiveBoolean(true).build(), AttributeValue.builder().bool(true).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleString() { verifyNullableAttribute(EnhancedType.of(String.class), a -> a.name("value") .getter(FakeMappedItem::getAString) .setter(FakeMappedItem::setAString), FakeMappedItem.builder().aString("onetwothree").build(), AttributeValue.builder().s("onetwothree").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleLong() { verifyNullableAttribute(EnhancedType.of(Long.class), a -> a.name("value") .getter(FakeMappedItem::getALong) .setter(FakeMappedItem::setALong), FakeMappedItem.builder().aLong(123L).build(), AttributeValue.builder().n("123").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveLong() { verifyAttribute(EnhancedType.of(long.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveLong) .setter(FakeMappedItem::setAPrimitiveLong), FakeMappedItem.builder().aPrimitiveLong(123L).build(), AttributeValue.builder().n("123").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleShort() { verifyNullableAttribute(EnhancedType.of(Short.class), a -> a.name("value") .getter(FakeMappedItem::getAShort) .setter(FakeMappedItem::setAShort), FakeMappedItem.builder().aShort((short)123).build(), AttributeValue.builder().n("123").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveShort() { verifyAttribute(EnhancedType.of(short.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveShort) .setter(FakeMappedItem::setAPrimitiveShort), FakeMappedItem.builder().aPrimitiveShort((short)123).build(), AttributeValue.builder().n("123").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleByte() { verifyNullableAttribute(EnhancedType.of(Byte.class), a -> a.name("value") .getter(FakeMappedItem::getAByte) .setter(FakeMappedItem::setAByte), FakeMappedItem.builder().aByte((byte)123).build(), AttributeValue.builder().n("123").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveByte() { verifyAttribute(EnhancedType.of(byte.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveByte) .setter(FakeMappedItem::setAPrimitiveByte), FakeMappedItem.builder().aPrimitiveByte((byte)123).build(), AttributeValue.builder().n("123").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleDouble() { verifyNullableAttribute(EnhancedType.of(Double.class), a -> a.name("value") .getter(FakeMappedItem::getADouble) .setter(FakeMappedItem::setADouble), FakeMappedItem.builder().aDouble(1.23).build(), AttributeValue.builder().n("1.23").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveDouble() { verifyAttribute(EnhancedType.of(double.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveDouble) .setter(FakeMappedItem::setAPrimitiveDouble), FakeMappedItem.builder().aPrimitiveDouble(1.23).build(), AttributeValue.builder().n("1.23").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void otherRequest_shouldNotThrowException() { S3Exception s3Exception = create404S3Exception(); Context.FailedExecution failedExecution = getFailedExecution(s3Exception, PutObjectRequest.builder().build()); assertThat(interceptor.modifyException(failedExecution, new ExecutionAttributes())).isEqualTo(s3Exception); }	@Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); }	ExceptionTranslationInterceptor implements ExecutionInterceptor { @Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); } }	ExceptionTranslationInterceptor implements ExecutionInterceptor { @Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); } }	ExceptionTranslationInterceptor implements ExecutionInterceptor { @Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); } @Override Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes); }	ExceptionTranslationInterceptor implements ExecutionInterceptor { @Override public Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes) { if (!isS3Exception404(context.exception()) \|\| !isHeadRequest(context.request())) { return context.exception(); } String message = context.exception().getMessage(); S3Exception exception = (S3Exception) (context.exception()); String requestIdFromHeader = exception.awsErrorDetails() .sdkHttpResponse() .firstMatchingHeader("x-amz-request-id") .orElse(null); String requestId = Optional.ofNullable(exception.requestId()).orElse(requestIdFromHeader); AwsErrorDetails errorDetails = exception.awsErrorDetails(); if (context.request() instanceof HeadObjectRequest) { return NoSuchKeyException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchKey", "The specified key does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } if (context.request() instanceof HeadBucketRequest) { return NoSuchBucketException.builder() .awsErrorDetails(fillErrorDetails(errorDetails, "NoSuchBucket", "The specified bucket does not exist.")) .statusCode(404) .requestId(requestId) .message(message) .build(); } return context.exception(); } @Override Throwable modifyException(Context.FailedExecution context, ExecutionAttributes executionAttributes); }
@Test public void mapperCanHandleFloat() { verifyNullableAttribute(EnhancedType.of(Float.class), a -> a.name("value") .getter(FakeMappedItem::getAFloat) .setter(FakeMappedItem::setAFloat), FakeMappedItem.builder().aFloat(1.23f).build(), AttributeValue.builder().n("1.23").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveFloat() { verifyAttribute(EnhancedType.of(float.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveFloat) .setter(FakeMappedItem::setAPrimitiveFloat), FakeMappedItem.builder().aPrimitiveFloat(1.23f).build(), AttributeValue.builder().n("1.23").build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleBinary() { SdkBytes sdkBytes = SdkBytes.fromString("test", UTF_8); verifyNullableAttribute(EnhancedType.of(SdkBytes.class), a -> a.name("value") .getter(FakeMappedItem::getABinaryValue) .setter(FakeMappedItem::setABinaryValue), FakeMappedItem.builder().aBinaryValue(sdkBytes).build(), AttributeValue.builder().b(sdkBytes).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleSimpleList() { verifyNullableAttribute(EnhancedType.listOf(Integer.class), a -> a.name("value") .getter(FakeMappedItem::getAnIntegerList) .setter(FakeMappedItem::setAnIntegerList), FakeMappedItem.builder().anIntegerList(asList(1, 2, 3)).build(), AttributeValue.builder().l(asList(AttributeValue.builder().n("1").build(), AttributeValue.builder().n("2").build(), AttributeValue.builder().n("3").build())).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleNestedLists() { FakeMappedItem fakeMappedItem = FakeMappedItem.builder() .aNestedStructure(singletonList(singletonList(FakeDocument.of("nested", null)))) .build(); Map<String, AttributeValue> documentMap = new HashMap<>(); documentMap.put("documentString", AttributeValue.builder().s("nested").build()); documentMap.put("documentInteger", AttributeValue.builder().nul(true).build()); AttributeValue attributeValue = AttributeValue.builder() .l(singletonList(AttributeValue.builder() .l(AttributeValue.builder().m(documentMap).build()) .build())) .build(); verifyNullableAttribute( EnhancedType.listOf(EnhancedType.listOf(EnhancedType.documentOf(FakeDocument.class, FAKE_DOCUMENT_TABLE_SCHEMA))), a -> a.name("value") .getter(FakeMappedItem::getANestedStructure) .setter(FakeMappedItem::setANestedStructure), fakeMappedItem, attributeValue); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleIntegerSet() { Set<Integer> valueSet = new HashSet<>(asList(1, 2, 3)); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Integer.class), a -> a.name("value") .getter(FakeMappedItem::getAnIntegerSet) .setter(FakeMappedItem::setAnIntegerSet), FakeMappedItem.builder().anIntegerSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleStringSet() { Set<String> valueSet = new HashSet<>(asList("one", "two", "three")); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(String.class), a -> a.name("value") .getter(FakeMappedItem::getAStringSet) .setter(FakeMappedItem::setAStringSet), FakeMappedItem.builder().aStringSet(valueSet).build(), AttributeValue.builder().ss(expectedList).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleLongSet() { Set<Long> valueSet = new HashSet<>(asList(1L, 2L, 3L)); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Long.class), a -> a.name("value") .getter(FakeMappedItem::getALongSet) .setter(FakeMappedItem::setALongSet), FakeMappedItem.builder().aLongSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleShortSet() { Set<Short> valueSet = new HashSet<>(asList((short) 1, (short) 2, (short) 3)); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Short.class), a -> a.name("value") .getter(FakeMappedItem::getAShortSet) .setter(FakeMappedItem::setAShortSet), FakeMappedItem.builder().aShortSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleByteSet() { Set<Byte> valueSet = new HashSet<>(asList((byte) 1, (byte) 2, (byte) 3)); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Byte.class), a -> a.name("value") .getter(FakeMappedItem::getAByteSet) .setter(FakeMappedItem::setAByteSet), FakeMappedItem.builder().aByteSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void encodingTypeSet_decodesListObjectsResponseParts() { Context.ModifyResponse ctx = newContext(V1_TEST_ENCODED_RESPONSE); ListObjectsResponse decoded = (ListObjectsResponse) INTERCEPTOR.modifyResponse(ctx, new ExecutionAttributes()); assertDecoded(decoded::delimiter, " delimiter"); assertDecoded(decoded::nextMarker, " nextmarker"); assertDecoded(decoded::prefix, " prefix"); assertDecoded(decoded::marker, " marker"); assertKeysAreDecoded(decoded.contents()); assertCommonPrefixesAreDecoded(decoded.commonPrefixes()); }	@Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }
@Test public void mapperCanHandleDoubleSet() { Set<Double> valueSet = new HashSet<>(asList(1.2, 3.4, 5.6)); List<String> expectedList = valueSet.stream().map(Object::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Double.class), a -> a.name("value") .getter(FakeMappedItem::getADoubleSet) .setter(FakeMappedItem::setADoubleSet), FakeMappedItem.builder().aDoubleSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleFloatSet() { Set<Float> valueSet = new HashSet<>(asList(1.2f, 3.4f, 5.6f)); List<String> expectedList = valueSet.stream().map(Object::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Float.class), a -> a.name("value") .getter(FakeMappedItem::getAFloatSet) .setter(FakeMappedItem::setAFloatSet), FakeMappedItem.builder().aFloatSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleGenericMap() { Map<String, String> stringMap = new ConcurrentHashMap<>(); stringMap.put("one", "two"); stringMap.put("three", "four"); Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeValueMap.put("one", AttributeValue.builder().s("two").build()); attributeValueMap.put("three", AttributeValue.builder().s("four").build()); verifyNullableAttribute(EnhancedType.mapOf(String.class, String.class), a -> a.name("value") .getter(FakeMappedItem::getAStringMap) .setter(FakeMappedItem::setAStringMap), FakeMappedItem.builder().aStringMap(stringMap).build(), AttributeValue.builder().m(attributeValueMap).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleIntDoubleMap() { Map<Integer, Double> intDoubleMap = new ConcurrentHashMap<>(); intDoubleMap.put(1, 1.0); intDoubleMap.put(2, 3.0); Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeValueMap.put("1", AttributeValue.builder().n("1.0").build()); attributeValueMap.put("2", AttributeValue.builder().n("3.0").build()); verifyNullableAttribute(EnhancedType.mapOf(Integer.class, Double.class), a -> a.name("value") .getter(FakeMappedItem::getAIntDoubleMap) .setter(FakeMappedItem::setAIntDoubleMap), FakeMappedItem.builder().aIntDoubleMap(intDoubleMap).build(), AttributeValue.builder().m(attributeValueMap).build()); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void getAttributeValue_correctlyMapsSuperclassAttributes() { FakeItem fakeItem = FakeItem.builder().id("id-value").build(); fakeItem.setSubclassAttribute("subclass-value"); AttributeValue attributeValue = FakeItem.getTableSchema().attributeValue(fakeItem, "subclass_attribute"); assertThat(attributeValue, is(AttributeValue.builder().s("subclass-value").build())); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void getAttributeValue_correctlyMapsComposedClassAttributes() { FakeItem fakeItem = FakeItem.builder().id("id-value") .composedObject(FakeItemComposedClass.builder().composedAttribute("composed-value").build()) .build(); AttributeValue attributeValue = FakeItem.getTableSchema().attributeValue(fakeItem, "composed_attribute"); assertThat(attributeValue, is(AttributeValue.builder().s("composed-value").build())); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapToItem_correctlyConstructsComposedClass() { Map<String, AttributeValue> itemMap = new HashMap<>(); itemMap.put("id", AttributeValue.builder().s("id-value").build()); itemMap.put("composed_attribute", AttributeValue.builder().s("composed-value").build()); FakeItem fakeItem = FakeItem.getTableSchema().mapToItem(itemMap); assertThat(fakeItem, is(FakeItem.builder() .id("id-value") .composedObject(FakeItemComposedClass.builder() .composedAttribute("composed-value") .build()) .build())); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void buildAbstractTableSchema() { StaticTableSchema<FakeMappedItem> tableSchema = StaticTableSchema.builder(FakeMappedItem.class) .addAttribute(String.class, a -> a.name("aString") .getter(FakeMappedItem::getAString) .setter(FakeMappedItem::setAString)) .build(); assertThat(tableSchema.itemToMap(FAKE_ITEM, false), is(singletonMap("aString", stringValue("test-string")))); exception.expect(UnsupportedOperationException.class); exception.expectMessage("abstract"); tableSchema.mapToItem(singletonMap("aString", stringValue("test-string"))); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void buildAbstractWithFlatten() { StaticTableSchema<FakeMappedItem> tableSchema = StaticTableSchema.builder(FakeMappedItem.class) .flatten(FAKE_DOCUMENT_TABLE_SCHEMA, FakeMappedItem::getAFakeDocument, FakeMappedItem::setAFakeDocument) .build(); FakeDocument document = FakeDocument.of("test-string", null); FakeMappedItem item = FakeMappedItem.builder().aFakeDocument(document).build(); assertThat(tableSchema.itemToMap(item, true), is(singletonMap("documentString", AttributeValue.builder().s("test-string").build()))); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void buildAbstractExtends() { StaticTableSchema<FakeAbstractSuperclass> superclassTableSchema = StaticTableSchema.builder(FakeAbstractSuperclass.class) .addAttribute(String.class, a -> a.name("aString") .getter(FakeAbstractSuperclass::getAString) .setter(FakeAbstractSuperclass::setAString)) .build(); StaticTableSchema<FakeAbstractSubclass> subclassTableSchema = StaticTableSchema.builder(FakeAbstractSubclass.class) .extend(superclassTableSchema) .build(); FakeAbstractSubclass item = new FakeAbstractSubclass(); item.setAString("test-string"); assertThat(subclassTableSchema.itemToMap(item, true), is(singletonMap("aString", AttributeValue.builder().s("test-string").build()))); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void encodingTypeSet_decodesListObjectsV2ResponseParts() { Context.ModifyResponse ctx = newContext(V2_TEST_ENCODED_RESPONSE); ListObjectsV2Response decoded = (ListObjectsV2Response) INTERCEPTOR.modifyResponse(ctx, new ExecutionAttributes()); assertDecoded(decoded::delimiter, " delimiter"); assertDecoded(decoded::prefix, " prefix"); assertDecoded(decoded::startAfter, " startafter"); assertKeysAreDecoded(decoded.contents()); assertCommonPrefixesAreDecoded(decoded.commonPrefixes()); }	@Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }
@Test public void buildAbstractTagWith() { StaticTableSchema<FakeDocument> abstractTableSchema = StaticTableSchema .builder(FakeDocument.class) .tags(new TestStaticTableTag()) .build(); assertThat(abstractTableSchema.tableMetadata().customMetadataObject(TABLE_TAG_KEY, String.class), is(Optional.of(TABLE_TAG_VALUE))); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void buildConcreteTagWith() { StaticTableSchema<FakeDocument> concreteTableSchema = StaticTableSchema .builder(FakeDocument.class) .newItemSupplier(FakeDocument::new) .tags(new TestStaticTableTag()) .build(); assertThat(concreteTableSchema.tableMetadata().customMetadataObject(TABLE_TAG_KEY, String.class), is(Optional.of(TABLE_TAG_VALUE))); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void instantiateFlattenedAbstractClassShouldThrowException() { StaticTableSchema<FakeAbstractSuperclass> superclassTableSchema = StaticTableSchema.builder(FakeAbstractSuperclass.class) .addAttribute(String.class, a -> a.name("aString") .getter(FakeAbstractSuperclass::getAString) .setter(FakeAbstractSuperclass::setAString)) .build(); exception.expect(IllegalArgumentException.class); exception.expectMessage("abstract"); StaticTableSchema.builder(FakeBrokenClass.class) .newItemSupplier(FakeBrokenClass::new) .flatten(superclassTableSchema, FakeBrokenClass::getAbstractObject, FakeBrokenClass::setAbstractObject); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void usesCustomAttributeConverterProvider() { String originalString = "test-string"; String expectedString = "test-string-custom"; when(provider1.converterFor(EnhancedType.of(String.class))).thenReturn(attributeConverter1); when(attributeConverter1.transformFrom(any())).thenReturn(AttributeValue.builder().s(expectedString).build()); StaticTableSchema<FakeMappedItem> tableSchema = StaticTableSchema.builder(FakeMappedItem.class) .newItemSupplier(FakeMappedItem::new) .addAttribute(String.class, a -> a.name("aString") .getter(FakeMappedItem::getAString) .setter(FakeMappedItem::setAString)) .attributeConverterProviders(provider1) .build(); Map<String, AttributeValue> resultMap = tableSchema.itemToMap(FakeMappedItem.builder().aString(originalString).build(), false); assertThat(resultMap.get("aString").s(), is(expectedString)); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void usesCustomAttributeConverterProviders() { String originalString = "test-string"; String expectedString = "test-string-custom"; when(provider2.converterFor(EnhancedType.of(String.class))).thenReturn(attributeConverter2); when(attributeConverter2.transformFrom(any())).thenReturn(AttributeValue.builder().s(expectedString).build()); StaticTableSchema<FakeMappedItem> tableSchema = StaticTableSchema.builder(FakeMappedItem.class) .newItemSupplier(FakeMappedItem::new) .addAttribute(String.class, a -> a.name("aString") .getter(FakeMappedItem::getAString) .setter(FakeMappedItem::setAString)) .attributeConverterProviders(provider1, provider2) .build(); Map<String, AttributeValue> resultMap = tableSchema.itemToMap(FakeMappedItem.builder().aString(originalString).build(), false); assertThat(resultMap.get("aString").s(), is(expectedString)); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void noConverterProvider_throwsException_whenMissingAttributeConverters() { exception.expect(NullPointerException.class); StaticTableSchema<FakeMappedItem> tableSchema = StaticTableSchema.builder(FakeMappedItem.class) .newItemSupplier(FakeMappedItem::new) .addAttribute(String.class, a -> a.name("aString") .getter(FakeMappedItem::getAString) .setter(FakeMappedItem::setAString)) .attributeConverterProviders(Collections.emptyList()) .build(); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void noConverterProvider_handlesCorrectly_whenAttributeConvertersAreSupplied() { String originalString = "test-string"; String expectedString = "test-string-custom"; when(attributeConverter1.transformFrom(any())).thenReturn(AttributeValue.builder().s(expectedString).build()); StaticTableSchema<FakeMappedItem> tableSchema = StaticTableSchema.builder(FakeMappedItem.class) .newItemSupplier(FakeMappedItem::new) .addAttribute(String.class, a -> a.name("aString") .getter(FakeMappedItem::getAString) .setter(FakeMappedItem::setAString) .attributeConverter(attributeConverter1)) .attributeConverterProviders(Collections.emptyList()) .build(); Map<String, AttributeValue> resultMap = tableSchema.itemToMap(FakeMappedItem.builder().aString(originalString).build(), false); assertThat(resultMap.get("aString").s(), is(expectedString)); }	public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }	StaticTableSchema extends WrappedTableSchema<T, StaticImmutableTableSchema<T, T>> { public static <T> Builder<T> builder(Class<T> itemClass) { return new Builder<>(itemClass); } private StaticTableSchema(Builder<T> builder); static Builder<T> builder(Class<T> itemClass); AttributeConverterProvider attributeConverterProvider(); }
@Test public void itemType_returnsCorrectClass() { assertThat(FakeItem.getTableSchema().itemType(), is(equalTo(EnhancedType.of(FakeItem.class)))); }	@Override public EnhancedType<T> itemType() { return this.itemType; }	StaticImmutableTableSchema implements TableSchema<T> { @Override public EnhancedType<T> itemType() { return this.itemType; } }	StaticImmutableTableSchema implements TableSchema<T> { @Override public EnhancedType<T> itemType() { return this.itemType; } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public EnhancedType<T> itemType() { return this.itemType; } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public EnhancedType<T> itemType() { return this.itemType; } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void getTableMetadata_hasCorrectFields() { TableMetadata tableMetadata = FakeItemWithSort.getTableSchema().tableMetadata(); assertThat(tableMetadata.primaryPartitionKey(), is("id")); assertThat(tableMetadata.primarySortKey(), is(Optional.of("sort"))); }	@Override public StaticTableMetadata tableMetadata() { return tableMetadata; }	StaticImmutableTableSchema implements TableSchema<T> { @Override public StaticTableMetadata tableMetadata() { return tableMetadata; } }	StaticImmutableTableSchema implements TableSchema<T> { @Override public StaticTableMetadata tableMetadata() { return tableMetadata; } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public StaticTableMetadata tableMetadata() { return tableMetadata; } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public StaticTableMetadata tableMetadata() { return tableMetadata; } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void itemToMap_returnsCorrectMapWithMultipleAttributes() { Map<String, AttributeValue> attributeMap = createSimpleTableSchema().itemToMap(FAKE_ITEM, false); assertThat(attributeMap.size(), is(3)); assertThat(attributeMap, hasEntry("a_boolean", ATTRIBUTE_VALUE_B)); assertThat(attributeMap, hasEntry("a_primitive_boolean", ATTRIBUTE_VALUE_B)); assertThat(attributeMap, hasEntry("a_string", ATTRIBUTE_VALUE_S)); }	@Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void encodingTypeSet_decodesListObjectVersionsResponse() { Context.ModifyResponse ctx = newContext(TEST_LIST_OBJECT_VERSION_RESPONSE); ListObjectVersionsResponse decoded = (ListObjectVersionsResponse) INTERCEPTOR.modifyResponse(ctx, new ExecutionAttributes()); assertDecoded(decoded::delimiter, " delimiter"); assertDecoded(decoded::prefix, " prefix"); assertDecoded(decoded::keyMarker, " keyMarker"); assertDecoded(decoded::nextKeyMarker, " nextKeyMarker"); assertCommonPrefixesAreDecoded(decoded.commonPrefixes()); assertVersionsAreDecoded(decoded.versions()); }	@Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }
@Test public void itemToMap_filtersAttributes() { Map<String, AttributeValue> attributeMap = createSimpleTableSchema() .itemToMap(FAKE_ITEM, asList("a_boolean", "a_string")); assertThat(attributeMap.size(), is(2)); assertThat(attributeMap, hasEntry("a_boolean", ATTRIBUTE_VALUE_B)); assertThat(attributeMap, hasEntry("a_string", ATTRIBUTE_VALUE_S)); }	@Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test(expected = IllegalArgumentException.class) public void itemToMap_attributeNotFound_throwsIllegalArgumentException() { createSimpleTableSchema().itemToMap(FAKE_ITEM, singletonList("unknown_key")); }	@Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls) { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeMappers.forEach(attributeMapper -> { String attributeKey = attributeMapper.attributeName(); AttributeValue attributeValue = attributeMapper.attributeGetterMethod().apply(item); if (!ignoreNulls \|\| !isNullAttributeValue(attributeValue)) { attributeValueMap.put(attributeKey, attributeValue); } }); indexedFlattenedMappers.forEach((name, flattenedMapper) -> { attributeValueMap.putAll(flattenedMapper.itemToMap(item, ignoreNulls)); }); return unmodifiableMap(attributeValueMap); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapToItem_returnsCorrectItemWithMultipleAttributes() { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeValueMap.put("a_boolean", ATTRIBUTE_VALUE_B); attributeValueMap.put("a_primitive_boolean", ATTRIBUTE_VALUE_B); attributeValueMap.put("a_string", ATTRIBUTE_VALUE_S); FakeMappedItem fakeMappedItem = createSimpleTableSchema().mapToItem(Collections.unmodifiableMap(attributeValueMap)); assertThat(fakeMappedItem, is(FAKE_ITEM)); }	@Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapToItem_unknownAttributes_doNotCauseErrors() { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeValueMap.put("unknown_attribute", ATTRIBUTE_VALUE_S); createSimpleTableSchema().mapToItem(Collections.unmodifiableMap(attributeValueMap)); }	@Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test(expected = IllegalArgumentException.class) public void mapToItem_attributesWrongType_throwsException() { Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeValueMap.put("a_boolean", ATTRIBUTE_VALUE_S); attributeValueMap.put("a_primitive_boolean", ATTRIBUTE_VALUE_S); attributeValueMap.put("a_string", ATTRIBUTE_VALUE_B); createSimpleTableSchema().mapToItem(Collections.unmodifiableMap(attributeValueMap)); }	@Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { @Override public T mapToItem(Map<String, AttributeValue> attributeMap) { B builder = null; Map<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> flattenedAttributeValuesMap = new LinkedHashMap<>(); for (Map.Entry<String, AttributeValue> entry : attributeMap.entrySet()) { String key = entry.getKey(); AttributeValue value = entry.getValue(); if (!isNullAttributeValue(value)) { ResolvedImmutableAttribute<T, B> attributeMapper = indexedMappers.get(key); if (attributeMapper != null) { if (builder == null) { builder = constructNewBuilder(); } attributeMapper.updateItemMethod().accept(builder, value); } else { FlattenedMapper<T, B, ?> flattenedMapper = this.indexedFlattenedMappers.get(key); if (flattenedMapper != null) { Map<String, AttributeValue> flattenedAttributeValues = flattenedAttributeValuesMap.get(flattenedMapper); if (flattenedAttributeValues == null) { flattenedAttributeValues = new HashMap<>(); } flattenedAttributeValues.put(key, value); flattenedAttributeValuesMap.put(flattenedMapper, flattenedAttributeValues); } } } } for (Map.Entry<FlattenedMapper<T, B, ?>, Map<String, AttributeValue>> entry : flattenedAttributeValuesMap.entrySet()) { builder = entry.getKey().mapToItem(builder, this::constructNewBuilder, entry.getValue()); } return builder == null ? null : buildItemFunction.apply(builder); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleEnum() { verifyNullableAttribute(EnhancedType.of(FakeMappedItem.TestEnum.class), a -> a.name("value") .getter(FakeMappedItem::getTestEnum) .setter(FakeMappedItem::setTestEnum), FakeMappedItem.builder().testEnum(FakeMappedItem.TestEnum.ONE).build(), AttributeValue.builder().s("ONE").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleDocument() { FakeDocument fakeDocument = FakeDocument.of("test-123", 123); Map<String, AttributeValue> expectedMap = new HashMap<>(); expectedMap.put("documentInteger", AttributeValue.builder().n("123").build()); expectedMap.put("documentString", AttributeValue.builder().s("test-123").build()); verifyNullableAttribute(EnhancedType.documentOf(FakeDocument.class, FAKE_DOCUMENT_TABLE_SCHEMA), a -> a.name("value") .getter(FakeMappedItem::getAFakeDocument) .setter(FakeMappedItem::setAFakeDocument), FakeMappedItem.builder().aFakeDocument(fakeDocument).build(), AttributeValue.builder().m(expectedMap).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleDocumentWithNullValues() { verifyNullAttribute(EnhancedType.documentOf(FakeDocument.class, FAKE_DOCUMENT_TABLE_SCHEMA), a -> a.name("value") .getter(FakeMappedItem::getAFakeDocument) .setter(FakeMappedItem::setAFakeDocument), FakeMappedItem.builder().build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleInteger() { verifyNullableAttribute(EnhancedType.of(Integer.class), a -> a.name("value") .getter(FakeMappedItem::getAnInteger) .setter(FakeMappedItem::setAnInteger), FakeMappedItem.builder().anInteger(123).build(), AttributeValue.builder().n("123").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveInteger() { verifyAttribute(EnhancedType.of(int.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveInteger) .setter(FakeMappedItem::setAPrimitiveInteger), FakeMappedItem.builder().aPrimitiveInteger(123).build(), AttributeValue.builder().n("123").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void encodingTypeSet_decodesListMultipartUploadsResponse() { Context.ModifyResponse ctx = newContext(TEST_LIST_MULTIPART_UPLOADS_RESPONSE); ListMultipartUploadsResponse decoded = (ListMultipartUploadsResponse) INTERCEPTOR.modifyResponse(ctx, new ExecutionAttributes()); assertDecoded(decoded::delimiter, " delimiter"); assertDecoded(decoded::prefix, " prefix"); assertDecoded(decoded::keyMarker, " keyMarker"); assertDecoded(decoded::nextKeyMarker, " nextKeyMarker"); assertCommonPrefixesAreDecoded(decoded.commonPrefixes()); assertUploadsAreDecoded(decoded.uploads()); assertCommonPrefixesAreDecoded(decoded.commonPrefixes()); }	@Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }
@Test (expected = NullPointerException.class) public void failIfRegionIsNotSetOnS3UtilitiesObject() throws MalformedURLException { S3Utilities.builder().build(); }	public static Builder builder() { return new Builder(); }	S3Utilities { public static Builder builder() { return new Builder(); } }	S3Utilities { public static Builder builder() { return new Builder(); } private S3Utilities(Builder builder); }	S3Utilities { public static Builder builder() { return new Builder(); } private S3Utilities(Builder builder); static Builder builder(); URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest); URL getUrl(GetUrlRequest getUrlRequest); }	S3Utilities { public static Builder builder() { return new Builder(); } private S3Utilities(Builder builder); static Builder builder(); URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest); URL getUrl(GetUrlRequest getUrlRequest); }
@Test public void mapperCanHandleBoolean() { verifyNullableAttribute(EnhancedType.of(Boolean.class), a -> a.name("value") .getter(FakeMappedItem::getABoolean) .setter(FakeMappedItem::setABoolean), FakeMappedItem.builder().aBoolean(true).build(), AttributeValue.builder().bool(true).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveBoolean() { verifyAttribute(EnhancedType.of(boolean.class), a -> a.name("value") .getter(FakeMappedItem::isAPrimitiveBoolean) .setter(FakeMappedItem::setAPrimitiveBoolean), FakeMappedItem.builder().aPrimitiveBoolean(true).build(), AttributeValue.builder().bool(true).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleString() { verifyNullableAttribute(EnhancedType.of(String.class), a -> a.name("value") .getter(FakeMappedItem::getAString) .setter(FakeMappedItem::setAString), FakeMappedItem.builder().aString("onetwothree").build(), AttributeValue.builder().s("onetwothree").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleLong() { verifyNullableAttribute(EnhancedType.of(Long.class), a -> a.name("value") .getter(FakeMappedItem::getALong) .setter(FakeMappedItem::setALong), FakeMappedItem.builder().aLong(123L).build(), AttributeValue.builder().n("123").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveLong() { verifyAttribute(EnhancedType.of(long.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveLong) .setter(FakeMappedItem::setAPrimitiveLong), FakeMappedItem.builder().aPrimitiveLong(123L).build(), AttributeValue.builder().n("123").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleShort() { verifyNullableAttribute(EnhancedType.of(Short.class), a -> a.name("value") .getter(FakeMappedItem::getAShort) .setter(FakeMappedItem::setAShort), FakeMappedItem.builder().aShort((short)123).build(), AttributeValue.builder().n("123").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveShort() { verifyAttribute(EnhancedType.of(short.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveShort) .setter(FakeMappedItem::setAPrimitiveShort), FakeMappedItem.builder().aPrimitiveShort((short)123).build(), AttributeValue.builder().n("123").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleByte() { verifyNullableAttribute(EnhancedType.of(Byte.class), a -> a.name("value") .getter(FakeMappedItem::getAByte) .setter(FakeMappedItem::setAByte), FakeMappedItem.builder().aByte((byte)123).build(), AttributeValue.builder().n("123").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveByte() { verifyAttribute(EnhancedType.of(byte.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveByte) .setter(FakeMappedItem::setAPrimitiveByte), FakeMappedItem.builder().aPrimitiveByte((byte)123).build(), AttributeValue.builder().n("123").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleDouble() { verifyNullableAttribute(EnhancedType.of(Double.class), a -> a.name("value") .getter(FakeMappedItem::getADouble) .setter(FakeMappedItem::setADouble), FakeMappedItem.builder().aDouble(1.23).build(), AttributeValue.builder().n("1.23").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void encodingTypeNotSet_doesNotDecodeListObjectsResponseParts() { ListObjectsResponse original = V1_TEST_ENCODED_RESPONSE.toBuilder() .encodingType((String) null) .build(); Context.ModifyResponse ctx = newContext(original); ListObjectsResponse fromInterceptor = (ListObjectsResponse) INTERCEPTOR.modifyResponse(ctx, new ExecutionAttributes()); assertThat(fromInterceptor).isEqualTo(original); }	@Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }
@Test public void mapperCanHandlePrimitiveDouble() { verifyAttribute(EnhancedType.of(double.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveDouble) .setter(FakeMappedItem::setAPrimitiveDouble), FakeMappedItem.builder().aPrimitiveDouble(1.23).build(), AttributeValue.builder().n("1.23").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleFloat() { verifyNullableAttribute(EnhancedType.of(Float.class), a -> a.name("value") .getter(FakeMappedItem::getAFloat) .setter(FakeMappedItem::setAFloat), FakeMappedItem.builder().aFloat(1.23f).build(), AttributeValue.builder().n("1.23").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandlePrimitiveFloat() { verifyAttribute(EnhancedType.of(float.class), a -> a.name("value") .getter(FakeMappedItem::getAPrimitiveFloat) .setter(FakeMappedItem::setAPrimitiveFloat), FakeMappedItem.builder().aPrimitiveFloat(1.23f).build(), AttributeValue.builder().n("1.23").build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleBinary() { SdkBytes sdkBytes = SdkBytes.fromString("test", UTF_8); verifyNullableAttribute(EnhancedType.of(SdkBytes.class), a -> a.name("value") .getter(FakeMappedItem::getABinaryValue) .setter(FakeMappedItem::setABinaryValue), FakeMappedItem.builder().aBinaryValue(sdkBytes).build(), AttributeValue.builder().b(sdkBytes).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleSimpleList() { verifyNullableAttribute(EnhancedType.listOf(Integer.class), a -> a.name("value") .getter(FakeMappedItem::getAnIntegerList) .setter(FakeMappedItem::setAnIntegerList), FakeMappedItem.builder().anIntegerList(asList(1, 2, 3)).build(), AttributeValue.builder().l(asList(AttributeValue.builder().n("1").build(), AttributeValue.builder().n("2").build(), AttributeValue.builder().n("3").build())).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleNestedLists() { FakeMappedItem fakeMappedItem = FakeMappedItem.builder() .aNestedStructure(singletonList(singletonList(FakeDocument.of("nested", null)))) .build(); Map<String, AttributeValue> documentMap = new HashMap<>(); documentMap.put("documentString", AttributeValue.builder().s("nested").build()); documentMap.put("documentInteger", AttributeValue.builder().nul(true).build()); AttributeValue attributeValue = AttributeValue.builder() .l(singletonList(AttributeValue.builder() .l(AttributeValue.builder().m(documentMap).build()) .build())) .build(); verifyNullableAttribute( EnhancedType.listOf(EnhancedType.listOf(EnhancedType.documentOf(FakeDocument.class, FAKE_DOCUMENT_TABLE_SCHEMA))), a -> a.name("value") .getter(FakeMappedItem::getANestedStructure) .setter(FakeMappedItem::setANestedStructure), fakeMappedItem, attributeValue); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleIntegerSet() { Set<Integer> valueSet = new HashSet<>(asList(1, 2, 3)); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Integer.class), a -> a.name("value") .getter(FakeMappedItem::getAnIntegerSet) .setter(FakeMappedItem::setAnIntegerSet), FakeMappedItem.builder().anIntegerSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleStringSet() { Set<String> valueSet = new HashSet<>(asList("one", "two", "three")); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(String.class), a -> a.name("value") .getter(FakeMappedItem::getAStringSet) .setter(FakeMappedItem::setAStringSet), FakeMappedItem.builder().aStringSet(valueSet).build(), AttributeValue.builder().ss(expectedList).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleLongSet() { Set<Long> valueSet = new HashSet<>(asList(1L, 2L, 3L)); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Long.class), a -> a.name("value") .getter(FakeMappedItem::getALongSet) .setter(FakeMappedItem::setALongSet), FakeMappedItem.builder().aLongSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleShortSet() { Set<Short> valueSet = new HashSet<>(asList((short) 1, (short) 2, (short) 3)); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Short.class), a -> a.name("value") .getter(FakeMappedItem::getAShortSet) .setter(FakeMappedItem::setAShortSet), FakeMappedItem.builder().aShortSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void encodingTypeNotSet_doesNotDecodeListObjectsV2ResponseParts() { ListObjectsV2Response original = V2_TEST_ENCODED_RESPONSE.toBuilder() .encodingType((String) null) .build(); Context.ModifyResponse ctx = newContext(original); ListObjectsV2Response fromInterceptor = (ListObjectsV2Response) INTERCEPTOR.modifyResponse(ctx, new ExecutionAttributes()); assertThat(fromInterceptor).isEqualTo(original); }	@Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }
@Test public void mapperCanHandleByteSet() { Set<Byte> valueSet = new HashSet<>(asList((byte) 1, (byte) 2, (byte) 3)); List<String> expectedList = valueSet.stream().map(Objects::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Byte.class), a -> a.name("value") .getter(FakeMappedItem::getAByteSet) .setter(FakeMappedItem::setAByteSet), FakeMappedItem.builder().aByteSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleDoubleSet() { Set<Double> valueSet = new HashSet<>(asList(1.2, 3.4, 5.6)); List<String> expectedList = valueSet.stream().map(Object::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Double.class), a -> a.name("value") .getter(FakeMappedItem::getADoubleSet) .setter(FakeMappedItem::setADoubleSet), FakeMappedItem.builder().aDoubleSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleFloatSet() { Set<Float> valueSet = new HashSet<>(asList(1.2f, 3.4f, 5.6f)); List<String> expectedList = valueSet.stream().map(Object::toString).collect(toList()); verifyNullableAttribute(EnhancedType.setOf(Float.class), a -> a.name("value") .getter(FakeMappedItem::getAFloatSet) .setter(FakeMappedItem::setAFloatSet), FakeMappedItem.builder().aFloatSet(valueSet).build(), AttributeValue.builder().ns(expectedList).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleGenericMap() { Map<String, String> stringMap = new ConcurrentHashMap<>(); stringMap.put("one", "two"); stringMap.put("three", "four"); Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeValueMap.put("one", AttributeValue.builder().s("two").build()); attributeValueMap.put("three", AttributeValue.builder().s("four").build()); verifyNullableAttribute(EnhancedType.mapOf(String.class, String.class), a -> a.name("value") .getter(FakeMappedItem::getAStringMap) .setter(FakeMappedItem::setAStringMap), FakeMappedItem.builder().aStringMap(stringMap).build(), AttributeValue.builder().m(attributeValueMap).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void mapperCanHandleIntDoubleMap() { Map<Integer, Double> intDoubleMap = new ConcurrentHashMap<>(); intDoubleMap.put(1, 1.0); intDoubleMap.put(2, 3.0); Map<String, AttributeValue> attributeValueMap = new HashMap<>(); attributeValueMap.put("1", AttributeValue.builder().n("1.0").build()); attributeValueMap.put("2", AttributeValue.builder().n("3.0").build()); verifyNullableAttribute(EnhancedType.mapOf(Integer.class, Double.class), a -> a.name("value") .getter(FakeMappedItem::getAIntDoubleMap) .setter(FakeMappedItem::setAIntDoubleMap), FakeMappedItem.builder().aIntDoubleMap(intDoubleMap).build(), AttributeValue.builder().m(attributeValueMap).build()); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void instantiateFlattenedAbstractClassShouldThrowException() { StaticTableSchema<FakeAbstractSuperclass> superclassTableSchema = StaticTableSchema.builder(FakeAbstractSuperclass.class) .addAttribute(String.class, a -> a.name("aString") .getter(FakeAbstractSuperclass::getAString) .setter(FakeAbstractSuperclass::setAString)) .build(); exception.expect(IllegalArgumentException.class); exception.expectMessage("abstract"); StaticTableSchema.builder(FakeBrokenClass.class) .newItemSupplier(FakeBrokenClass::new) .flatten(superclassTableSchema, FakeBrokenClass::getAbstractObject, FakeBrokenClass::setAbstractObject); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void noConverterProvider_throwsException_whenMissingAttributeConverters() { exception.expect(NullPointerException.class); StaticTableSchema<FakeMappedItem> tableSchema = StaticTableSchema.builder(FakeMappedItem.class) .newItemSupplier(FakeMappedItem::new) .addAttribute(String.class, a -> a.name("aString") .getter(FakeMappedItem::getAString) .setter(FakeMappedItem::setAString)) .attributeConverterProviders(Collections.emptyList()) .build(); }	public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }	StaticImmutableTableSchema implements TableSchema<T> { public static <T, B> Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass) { return new Builder<>(itemClass, builderClass); } private StaticImmutableTableSchema(Builder<T, B> builder); static Builder<T, B> builder(Class<T> itemClass, Class<B> builderClass); @Override StaticTableMetadata tableMetadata(); @Override T mapToItem(Map<String, AttributeValue> attributeMap); @Override Map<String, AttributeValue> itemToMap(T item, boolean ignoreNulls); @Override Map<String, AttributeValue> itemToMap(T item, Collection<String> attributes); @Override AttributeValue attributeValue(T item, String key); @Override EnhancedType<T> itemType(); @Override List<String> attributeNames(); @Override boolean isAbstract(); AttributeConverterProvider attributeConverterProvider(); }
@Test public void toBuilder() { StaticAttribute<Object, String> staticAttribute = StaticAttribute.builder(Object.class, String.class) .name("test-attribute") .getter(TEST_GETTER) .setter(TEST_SETTER) .tags(mockTag, mockTag2) .attributeConverter(attributeConverter) .build(); StaticAttribute<Object, String> clonedAttribute = staticAttribute.toBuilder().build(); assertThat(clonedAttribute.name()).isEqualTo("test-attribute"); assertThat(clonedAttribute.getter()).isSameAs(TEST_GETTER); assertThat(clonedAttribute.setter()).isSameAs(TEST_SETTER); assertThat(clonedAttribute.tags()).containsExactly(mockTag, mockTag2); assertThat(clonedAttribute.type()).isEqualTo(EnhancedType.of(String.class)); assertThat(clonedAttribute.attributeConverter()).isSameAs(attributeConverter); }	public Builder<T, R> toBuilder() { return new Builder<>(this.delegateAttribute.toBuilder()); }	StaticAttribute { public Builder<T, R> toBuilder() { return new Builder<>(this.delegateAttribute.toBuilder()); } }	StaticAttribute { public Builder<T, R> toBuilder() { return new Builder<>(this.delegateAttribute.toBuilder()); } private StaticAttribute(Builder<T, R> builder); }	StaticAttribute { public Builder<T, R> toBuilder() { return new Builder<>(this.delegateAttribute.toBuilder()); } private StaticAttribute(Builder<T, R> builder); static Builder<T, R> builder(Class<T> itemClass, EnhancedType<R> attributeType); static Builder<T, R> builder(Class<T> itemClass, Class<R> attributeClass); String name(); Function<T, R> getter(); BiConsumer<T, R> setter(); Collection<StaticAttributeTag> tags(); EnhancedType<R> type(); AttributeConverter<R> attributeConverter(); Builder<T, R> toBuilder(); }	StaticAttribute { public Builder<T, R> toBuilder() { return new Builder<>(this.delegateAttribute.toBuilder()); } private StaticAttribute(Builder<T, R> builder); static Builder<T, R> builder(Class<T> itemClass, EnhancedType<R> attributeType); static Builder<T, R> builder(Class<T> itemClass, Class<R> attributeClass); String name(); Function<T, R> getter(); BiConsumer<T, R> setter(); Collection<StaticAttributeTag> tags(); EnhancedType<R> type(); AttributeConverter<R> attributeConverter(); Builder<T, R> toBuilder(); }
@Test public void setAndRetrievePrimaryPartitionKey() { TableMetadata tableMetadata = StaticTableMetadata.builder() .addIndexPartitionKey(primaryIndexName(), ATTRIBUTE_NAME, AttributeValueType.S) .build(); assertThat(tableMetadata.primaryPartitionKey(), is(ATTRIBUTE_NAME)); }	public static Builder builder() { return new Builder(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }
@Test public void setAndRetrievePrimarySortKey() { TableMetadata tableMetadata = StaticTableMetadata.builder() .addIndexSortKey(primaryIndexName(), ATTRIBUTE_NAME, AttributeValueType.S) .build(); assertThat(tableMetadata.primarySortKey(), is(Optional.of(ATTRIBUTE_NAME))); }	public static Builder builder() { return new Builder(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }
@Test public void otherResponses_shouldNotModifyResponse() { HeadObjectResponse original = HeadObjectResponse.builder().build(); Context.ModifyResponse ctx = newContext(original); SdkResponse sdkResponse = INTERCEPTOR.modifyResponse(ctx, new ExecutionAttributes()); assertThat(original.hashCode()).isEqualTo(sdkResponse.hashCode()); }	@Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }	DecodeUrlEncodedResponseInterceptor implements ExecutionInterceptor { @Override public SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes) { SdkResponse response = context.response(); if (shouldHandle(response)) { if (response instanceof ListObjectsResponse) { return modifyListObjectsResponse((ListObjectsResponse) response); } if (response instanceof ListObjectsV2Response) { return modifyListObjectsV2Response((ListObjectsV2Response) response); } if (response instanceof ListObjectVersionsResponse) { return modifyListObjectVersionsResponse((ListObjectVersionsResponse) response); } if (response instanceof ListMultipartUploadsResponse) { return modifyListMultipartUploadsResponse((ListMultipartUploadsResponse) response); } } return response; } @Override SdkResponse modifyResponse(Context.ModifyResponse context, ExecutionAttributes executionAttributes); }
@Test(expected = IllegalArgumentException.class) public void retrieveUnsetPrimaryPartitionKey() { TableMetadata tableMetadata = StaticTableMetadata.builder().build(); tableMetadata.primaryPartitionKey(); }	public static Builder builder() { return new Builder(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }
@Test(expected = IllegalArgumentException.class) public void retrieveUnsetPrimaryPartitionKey_withSortKeySet() { TableMetadata tableMetadata = StaticTableMetadata.builder() .addIndexSortKey(primaryIndexName(), ATTRIBUTE_NAME, AttributeValueType.S) .build(); tableMetadata.primaryPartitionKey(); }	public static Builder builder() { return new Builder(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }
@Test public void retrieveUnsetPrimarySortKey() { TableMetadata tableMetadata = StaticTableMetadata.builder() .addIndexPartitionKey(primaryIndexName(), ATTRIBUTE_NAME, AttributeValueType.S) .build(); assertThat(tableMetadata.primarySortKey(), is(Optional.empty())); }	public static Builder builder() { return new Builder(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }
@Test(expected = IllegalArgumentException.class) public void setSamePartitionKeyTwice() { StaticTableMetadata.builder() .addIndexPartitionKey("idx", "id", AttributeValueType.S) .addIndexPartitionKey("idx", "id", AttributeValueType.S) .build(); }	public static Builder builder() { return new Builder(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }
@Test(expected = IllegalArgumentException.class) public void setSameSortKeyTwice() { StaticTableMetadata.builder() .addIndexSortKey("idx", "id", AttributeValueType.S) .addIndexSortKey("idx", "id", AttributeValueType.S) .build(); }	public static Builder builder() { return new Builder(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }
@Test public void getPrimaryKeys_partitionAndSort() { TableMetadata tableMetadata = StaticTableMetadata.builder() .addIndexPartitionKey(primaryIndexName(), "primary_id", AttributeValueType.S) .addIndexSortKey(primaryIndexName(), "primary_sort", AttributeValueType.S) .addIndexPartitionKey(INDEX_NAME, "dummy", AttributeValueType.S) .addIndexSortKey(INDEX_NAME, "dummy2", AttributeValueType.S) .build(); assertThat(tableMetadata.primaryKeys(), containsInAnyOrder("primary_id", "primary_sort")); }	public static Builder builder() { return new Builder(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }	StaticTableMetadata implements TableMetadata { public static Builder builder() { return new Builder(); } private StaticTableMetadata(Builder builder); static Builder builder(); @Override Optional<T> customMetadataObject(String key, Class<? extends T> objectClass); @Override String indexPartitionKey(String indexName); @Override Optional<String> indexSortKey(String indexName); @Override Collection<String> indexKeys(String indexName); @Override Collection<String> allKeys(); @Override Collection<IndexMetadata> indices(); @Override Map<String, Object> customMetadata(); @Override Collection<KeyAttributeMetadata> keyAttributes(); @Override Optional<ScalarAttributeType> scalarAttributeType(String keyAttribute); @Override boolean equals(Object o); @Override int hashCode(); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.